sneakoscope 4.8.7 → 5.1.2

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

@@ -1,7 +1,11 @@
 import path from 'node:path';
-import { appendJsonl, appendJsonlMany, 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,6 +39,43 @@ 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));
     }
@@ -98,4 +145,50 @@ export class PersistentAgentPatchQueueStore {
         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
         };
@@ -97,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-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-worker-backend-router.js

@@ -10,6 +10,8 @@ import { normalizeAgentPatchEnvelope } from './agent-patch-schema.js';
 import { runCodexTask } from '../codex-control/codex-control-plane.js';
 import { CODEX_AGENT_WORKER_RESULT_SCHEMA_ID, codexAgentWorkerResultSchema } from '../codex-control/schemas/agent-worker-result.schema.js';
 import { leanEngineeringCompactText, leanPolicyReference } from '../lean-engineering-policy.js';
+import { readLbHealth } from '../codex-lb/codex-lb-env.js';
+import { categoryForWorkerRole, modelRouteReason, routeModel } from '../provider/model-router.js';
 export const NATIVE_WORKER_BACKEND_ROUTER_SCHEMA = 'sks.native-worker-backend-router.v1';
 export async function runNativeWorkerBackendRouter(input) {
     const root = path.resolve(input.agentRoot);
@@ -23,6 +25,7 @@ export async function runNativeWorkerBackendRouter(input) {
     let patchEnvelopes = [];
     let proofLevel = 'blocked';
     let outputLastMessagePath = null;
+    let modelRouting = null;
     if (!input.guard?.ok) {
         result = validateAgentWorkerResult(blockedResult(input, ['native_cli_worker_recursion_guard_missing']));
     }
@@ -91,6 +94,7 @@ export async function runNativeWorkerBackendRouter(input) {
     }
     else if (backend === 'codex-sdk' || backend === 'zellij' || backend === 'local-llm') {
         const localPreferred = backend === 'local-llm';
+        modelRouting = await resolveWorkerModelRouting(input);
         const sdkTask = await runCodexTask({
             route: String(input.intake.route || '$Agent'),
             tier: 'worker',
@@ -101,6 +105,10 @@ export async function runNativeWorkerBackendRouter(input) {
             sessionId: String(input.agent.session_id || ''),
             cwd: String(input.intake.cwd || root),
             prompt: buildWorkerPrompt(input.slice),
+            model: modelRouting.choice.model,
+            reasoningEffort: modelRouting.choice.reasoning,
+            modelReasoningEffort: modelRouting.choice.reasoning,
+            serviceTier: modelRouting.choice.serviceTier,
             inputFiles: input.intake.input_files || [],
             inputImages: input.intake.input_images || [],
             outputSchemaId: CODEX_AGENT_WORKER_RESULT_SCHEMA_ID,
@@ -112,6 +120,8 @@ export async function runNativeWorkerBackendRouter(input) {
                 read_only: !hasWriteLease(input.slice, input.intake),
                 allowed_paths: writePaths(input.slice, input.intake),
                 write_paths: writePaths(input.slice, input.intake),
+                model_route_reason: modelRouting.reason,
+                service_tier: modelRouting.choice.serviceTier,
                 user_confirmed_full_access: false,
                 mad_sks_authorized: input.intake.mad_sks_authorized === true || process.env.SKS_MAD_SKS_ACTIVE === '1'
             },
@@ -143,6 +153,10 @@ export async function runNativeWorkerBackendRouter(input) {
             structured_output_valid: sdkTask.structuredOutputValid,
             worker_result_path: sdkTask.workerResultPath,
             patch_envelope_path: sdkTask.patchEnvelopePath || null,
+            model: modelRouting.choice.model,
+            model_reasoning_effort: modelRouting.choice.reasoning,
+            service_tier: modelRouting.choice.serviceTier,
+            model_route_reason: modelRouting.reason,
             blockers: sdkTask.blockers
         };
         childReports = [sdkReport];
@@ -219,7 +233,11 @@ export async function runNativeWorkerBackendRouter(input) {
         proof_level: proofLevel,
         lean_engineering_policy: leanPolicyReference(),
         fast_mode: input.fastModePolicy.fast_mode,
-        service_tier: input.fastModePolicy.service_tier,
+        service_tier: modelRouting?.choice.serviceTier || input.fastModePolicy.service_tier,
+        model: modelRouting?.choice.model || input.agent.model || null,
+        model_reasoning_effort: modelRouting?.choice.reasoning || input.agent.model_reasoning_effort || null,
+        model_route_reason: modelRouting?.reason || null,
+        model_route_category: modelRouting?.category || null,
         sdk_thread_id: childReports.find((report) => report?.sdk_thread_id)?.sdk_thread_id || null,
         sdk_run_id: childReports.find((report) => report?.sdk_run_id)?.sdk_run_id || null,
         stream_event_count: Number(childReports.find((report) => report?.stream_event_count)?.stream_event_count || 0),
@@ -239,6 +257,39 @@ export async function runNativeWorkerBackendRouter(input) {
         patchEnvelopes
     };
 }
+async function resolveWorkerModelRouting(input) {
+    const category = categoryForWorkerRole(String(input.agent?.role || input.slice?.role || input.slice?.type || input.agent?.persona_id || 'executor'));
+    const lbHealth = await readLbHealth().catch(() => null);
+    const explicitModel = String(process.env.SKS_WORKER_MODEL || process.env.SKS_AGENT_MODEL || '').trim();
+    const explicitReasoning = normalizeModelReasoning(process.env.SKS_WORKER_REASONING || process.env.SKS_WORKER_MODEL_REASONING || '');
+    const explicitTier = normalizeServiceTier(process.env.SKS_WORKER_SERVICE_TIER || process.env.SKS_SERVICE_TIER || '');
+    const routed = explicitModel
+        ? {
+            model: explicitModel,
+            reasoning: explicitReasoning || normalizeModelReasoning(input.agent?.model_reasoning_effort) || 'medium',
+            serviceTier: explicitTier || input.fastModePolicy.service_tier || 'fast'
+        }
+        : await routeModel(category, { lbHealth });
+    return {
+        category,
+        choice: routed,
+        explicit: Boolean(explicitModel),
+        lb_health: lbHealth,
+        reason: modelRouteReason(category, routed, {
+            explicit: Boolean(explicitModel),
+            quotaLow: lbHealth?.quota_low === true,
+            degraded: lbHealth?.degraded_models || []
+        })
+    };
+}
+function normalizeModelReasoning(value) {
+    const text = String(value || '').toLowerCase();
+    return text === 'low' || text === 'medium' || text === 'high' || text === 'xhigh' ? text : null;
+}
+function normalizeServiceTier(value) {
+    const text = String(value || '').toLowerCase();
+    return text === 'standard' ? 'standard' : text === 'fast' || text === 'priority' ? 'fast' : null;
+}
 async function maybeAutoSelectOllamaBackend(backend, input) {
     if (backend !== 'codex-sdk')
         return backend;
@@ -286,6 +337,12 @@ function buildWorkerPrompt(slice) {
         write.length
             ? `Write-capable slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; include patch_envelopes for write_paths=${JSON.stringify(write)}.`
             : `Read-only slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; do not report pre-existing repository dirtiness as changed_files.`,
+        write.length
+            ? 'Quality gates run before queue acceptance: impact-scan requires cochanged callers for exported signature changes, machine-feedback runs type/lint/related tests, diff-quality blocks dead exports, and compiled mistake rules block repeated mistakes.'
+            : '',
+        write.length
+            ? 'If this is a bugfix, create a regression test first and include regression_proof with failed_before true and passed_after true. For repair work, include repair_hypothesis before patching.'
+            : '',
         leanEngineeringCompactText(),
         'Required JSON fields: status, summary, findings, changed_files, patch_envelopes, verification, rollback_notes, blockers.'
     ].join('\n');

package/dist/core/codex-app/sks-menubar.js

@@ -3,6 +3,7 @@ import os from 'node:os';
 import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { ensureDir, exists, PACKAGE_VERSION, readJson, readText, runProcess, sha256, which, writeJsonAtomic, writeTextAtomic } from '../fsx.js';
+import { withHeartbeat } from '../../cli/cli-theme.js';
 export const SKS_MENUBAR_LABEL = 'com.sneakoscope.sks-menubar';
 const LABEL = SKS_MENUBAR_LABEL;
 const CONTROL_CENTER_DOMAIN = 'com.apple.controlcenter';
@@ -16,6 +17,7 @@ const MENU_ITEMS = [
     'Fast Check',
     'SKS Version Check',
     'Update SKS Now',
+    'Open Dashboard',
     'Open Codex Settings',
     'Restart Codex',
     'Quit SKS Menu'
@@ -208,7 +210,8 @@ export async function installSksMenuBar(opts = {}) {
                 codesign,
                 swiftSource,
                 infoPlist,
-                actions
+                actions,
+                quiet: opts.quiet === true
             });
         }
         catch (err) {
@@ -245,7 +248,7 @@ export async function installSksMenuBar(opts = {}) {
             warnings.push(preferredPosition.warning);
     }
     const launch = launchRequested && launchctl && !(stampMatches && runningBeforeLaunch)
-        ? await launchWithLaunchctl({ launchctl, open, paths, skipIfRunning: stampMatches })
+        ? await launchWithLaunchctl({ launchctl, open, paths, skipIfRunning: stampMatches, quiet: opts.quiet === true })
         : {
             requested: launchRequested && !(stampMatches && runningBeforeLaunch),
             method: 'skipped',
@@ -724,6 +727,7 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         add(menu, "SKS Version Check", #selector(sksVersionCheck))
         add(menu, "Update SKS Now", #selector(updateSksNow))
         menu.addItem(NSMenuItem.separator())
+        add(menu, "Open Dashboard", #selector(openDashboard))
         add(menu, "Open Codex Settings", #selector(openCodexSettings))
         add(menu, "Restart Codex", #selector(restartCodex))
         menu.addItem(NSMenuItem.separator())
@@ -844,6 +848,12 @@ final class AppDelegate: NSObject, NSApplicationDelegate {
         runSksInTerminal(["update"], tail: "echo; echo 'SKS update finished.'")
     }
 
+    @objc func openDashboard() {
+        let command = "\\(shellQuote(actionScript)) ui; echo; echo 'SKS dashboard requested.'"
+        runInTerminal(command)
+        runProcess("/usr/bin/open", ["http://127.0.0.1:4477"])
+    }
+
     @objc func openCodexSettings() {
         runProcess("/usr/bin/open", ["codex://settings"])
     }
@@ -916,10 +926,11 @@ async function buildMenuBarAppAtomically(input) {
     input.actions.push(`wrote ${input.paths.source_path}`);
     await writeTextAtomic(path.join(input.paths.staging_app_path, 'Contents', 'Info.plist'), input.infoPlist);
     const stagingExecutable = path.join(input.paths.staging_app_path, 'Contents', 'MacOS', 'SKSMenuBar');
-    const compile = await runProcess(input.swiftc, ['-framework', 'Cocoa', input.paths.source_path, '-o', stagingExecutable], {
+    const compileWork = runProcess(input.swiftc, ['-framework', 'Cocoa', input.paths.source_path, '-o', stagingExecutable], {
         timeoutMs: 60_000,
         maxOutputBytes: 64 * 1024
     }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
+    const compile = input.quiet === true ? await compileWork : await withHeartbeat('swiftc SKS menu bar', compileWork, { warnAfterMs: 30_000 });
     if (compile.code !== 0) {
         throw new MenuBarBuildError('swift_compile_failed', String(compile.stderr || compile.stdout || '').trim());
     }
@@ -956,7 +967,8 @@ async function launchWithLaunchctl(input) {
         stdoutFile: path.join(input.paths.install_dir, 'launchctl.out.log'),
         stderrFile: path.join(input.paths.install_dir, 'launchctl.err.log')
     };
-    const already = await waitForLaunchctlRunning(input.launchctl, service);
+    const alreadyWork = waitForLaunchctlRunning(input.launchctl, service);
+    const already = input.quiet === true ? await alreadyWork : await withHeartbeat('launchctl SKS menu bar wait', alreadyWork, { warnAfterMs: 10_000 });
     if (input.skipIfRunning && already.running) {
         return { requested: true, method: 'launchctl', ok: true, print_code: already.code, error: null };
     }
@@ -975,7 +987,8 @@ async function launchWithLaunchctl(input) {
             ...stdio
         }).catch((err) => ({ code: 1, stdout: '', stderr: err?.message || String(err) }));
         if (kickstart.code !== 0) {
-            const printed = await waitForLaunchctlRunning(input.launchctl, service);
+            const printedWork = waitForLaunchctlRunning(input.launchctl, service);
+            const printed = input.quiet === true ? await printedWork : await withHeartbeat('launchctl SKS menu bar wait', printedWork, { warnAfterMs: 10_000 });
             if (printed.running) {
                 return {
                     requested: true,

package/dist/core/codex-app.js

@@ -582,6 +582,7 @@ export function codexAppGuidance({ appInstalled, codex, mcpList, featureList, re
     }
     else if (appInstalled || codex?.bin) {
         lines.push('Codex image_generation was not visible from `codex features list`. Required imagegen/gpt-image-2 evidence must stay blocked or unverified until $imagegen is available in Codex App.');
+        lines.push('Run: sks doctor --fix to attempt Codex CLI/App image_generation repair, then rerun the blocked visual route.');
     }
     if (computerUseReady && !computerUseMcpListed) {
         lines.push('Computer Use plugin files are installed, but this check cannot prove the current thread exposes the live Computer Use tools. Start a new Codex App thread and invoke @Computer or @AppName only for native Mac/non-web target apps or screens; web/browser/webapp verification must use the Chrome Extension gate.');

package/dist/core/codex-control/codex-sdk-config-policy.js

@@ -1,8 +1,9 @@
 export function buildCodexSdkConfig(input) {
     const model = String(input.model || process.env.SKS_CODEX_MODEL || process.env.CODEX_MODEL || 'gpt-5.5');
+    const serviceTier = String(input.serviceTier || process.env.SKS_SERVICE_TIER || 'fast');
     const config = {
         model,
-        service_tier: 'fast',
+        service_tier: serviceTier === 'standard' ? 'standard' : 'fast',
         model_reasoning_effort: String(input.modelReasoningEffort || input.reasoningEffort || process.env.SKS_CODEX_REASONING || process.env.CODEX_MODEL_REASONING_EFFORT || 'medium'),
         mcp_servers: {},
         sks: {

package/dist/core/codex-control/codex-sdk-env-policy.js

@@ -30,7 +30,7 @@ export function buildCodexSdkEnv(input) {
         env.SKS_AGENT_SESSION_ID = input.sessionId;
     if (input.generationIndex !== undefined)
         env.SKS_AGENT_GENERATION_INDEX = String(input.generationIndex);
-    env.SKS_SERVICE_TIER = 'fast';
+    env.SKS_SERVICE_TIER = String(input.serviceTier || 'fast');
     const isolatedRoot = path.resolve(input.mutationLedgerRoot, 'codex-sdk-home');
     env.HOME = path.join(isolatedRoot, 'home');
     env.CODEX_HOME = path.join(isolatedRoot, 'codex');

package/dist/core/codex-control/schemas/agent-worker-result.schema.js

@@ -3,7 +3,7 @@ const patchOperationSchema = {
     type: 'object',
     required: ['op', 'path', 'search', 'replace', 'content', 'diff'],
     properties: {
-        op: { type: 'string', enum: ['replace', 'write', 'unified_diff'] },
+        op: { type: 'string', enum: ['replace', 'write', 'unified_diff', 'git_apply_patch'] },
         path: { type: 'string' },
         search: { type: 'string' },
         replace: { type: 'string' },
@@ -38,7 +38,12 @@ const patchEnvelopeSchema = {
         lease_id: { type: 'string' },
         allowed_paths: { type: 'array', items: { type: 'string' } },
         operations: { type: 'array', items: patchOperationSchema },
-        rationale: { type: 'string' }
+        rationale: { type: 'string' },
+        cochange_acknowledged: { type: 'boolean' },
+        cochange_acknowledged_reason: { type: 'string' },
+        regression_proof: { type: 'object', additionalProperties: true },
+        repair_hypothesis: { type: 'object', additionalProperties: true },
+        tournament: { type: 'object', additionalProperties: true }
     },
     additionalProperties: false
 };
@@ -70,7 +75,11 @@ export const codexAgentWorkerResultSchema = {
             additionalProperties: false
         },
         rollback_notes: { type: 'array', items: { type: 'string' } },
-        blockers: { type: 'array', items: { type: 'string' } }
+        blockers: { type: 'array', items: { type: 'string' } },
+        work_item_kind: { type: 'string' },
+        regression_proof: { type: 'object', additionalProperties: true },
+        repair_hypothesis: { type: 'object', additionalProperties: true },
+        tournament: { type: 'object', additionalProperties: true }
     },
     additionalProperties: false
 };