sneakoscope 4.8.7 → 5.3.0

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-cli-worker.js

@@ -327,7 +327,6 @@ function startWorkerProgressTelemetry(input) {
             status: 'running',
             backend: input.backend,
             serviceTier: input.serviceTier,
-            progress: { done: tick, total: 0, label: 'heartbeat' },
             artifacts: [input.heartbeatRel],
             logTail: `backend running ${tick}`
         }).catch(() => undefined);

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');