sneakoscope 2.0.4 → 2.0.6

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

@@ -31,6 +31,13 @@ export async function writeAgentProofEvidence(root, input) {
     const patchSwarm = input.patchSwarm || await readJson(path.join(root, 'agent-patch-swarm-runtime.json'), null);
     const localCollaborationPolicy = input.localCollaborationPolicy || await readJson(path.join(root, 'local-collaboration-policy.json'), null) || resolveLocalCollaborationPolicy();
     const gptFinalArbiter = input.gptFinalArbiter || await readJson(path.join(root, 'gpt-final-arbiter', 'gpt-final-arbiter.json'), null);
+    const narutoWorkGraph = await readJson(path.join(root, 'naruto-work-graph.json'), null);
+    const narutoRoleDistribution = await readJson(path.join(root, 'naruto-role-distribution.json'), null);
+    const narutoConcurrencyGovernor = await readJson(path.join(root, 'naruto-concurrency-governor.json'), null);
+    const narutoActivePool = await readJson(path.join(root, 'naruto-active-pool.json'), null);
+    const narutoVerificationDag = await readJson(path.join(root, 'naruto-verification-dag.json'), null);
+    const narutoGptFinalPack = await readJson(path.join(root, 'naruto-gpt-final-pack.json'), null);
+    const narutoZellijDashboard = await readJson(path.join(root, 'naruto-zellij-dashboard.json'), null);
     const localParticipated = localCollaborationParticipated(input.results || []) || Number(gptFinalArbiter?.local_outputs_count || 0) > 0;
     const finalGptPatchStage = input.finalGptPatchStage || null;
     const localFinalGate = gptFinalArbiter?.final_gate || evaluateLocalCollaborationFinalGate({
@@ -74,6 +81,7 @@ export async function writeAgentProofEvidence(root, input) {
     const workQueueGoalRefsOk = Boolean(workQueue?.items?.length) && workQueue.items.every((item) => item.goal_mode_ref);
     const workQueueStrategyRefsOk = Boolean(workQueue?.items?.length) && workQueue.items.every((item) => item.slice?.strategy_refs);
     const route = String(input.route || taskGraph?.route_type || '$Agent');
+    const isNarutoRoute = route === '$Naruto';
     const routeCommand = String(input.routeCommand || 'sks agent run');
     const genericAgentRouteStandIn = !/\$?agent$/i.test(route) && /\bagent\s+run\b/i.test(routeCommand) && /--route/i.test(routeCommand);
     const realRouteCommandUsed = !genericAgentRouteStandIn;
@@ -111,6 +119,14 @@ export async function writeAgentProofEvidence(root, input) {
         return !changed || Boolean(row.rollback_digest);
     }) : true;
     const parallelPatchApplyVerified = patchSwarm ? Array.isArray(patchProof?.wall_clock_parallel_evidence) && patchProof.wall_clock_parallel_evidence.length > 0 || Number(patchSwarm?.parallel_apply_count || 0) > 1 : false;
+    const readOnlyNoWriteLeaseMode = isReadOnlyNoWriteLeaseMode({
+        results: input.results || [],
+        leases: input.partition?.leases || [],
+        parallelWritePolicy,
+        taskGraph,
+        narutoWorkGraph
+    });
+    const changedFileLeaseBlockers = readOnlyNoWriteLeaseMode ? [] : agentChangedFileLeaseViolations(input.results || [], input.partition?.leases || []);
     const blockers = [
         ...(lifecycle.ok ? [] : ['agent_lifecycle_not_all_closed']),
         ...(lifecycle.ok ? [] : lifecycle.open_sessions.map((id) => 'session_open:' + id)),
@@ -177,7 +193,17 @@ export async function writeAgentProofEvidence(root, input) {
         ...(localParticipated && localFinalGate.ok !== true ? localFinalGate.blockers || ['gpt_final_arbiter_gate_not_ok'] : []),
         ...(localParticipated && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
         ...(localParticipated && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
-        ...agentChangedFileLeaseViolations(input.results || [], input.partition?.leases || [])
+        ...(isNarutoRoute && !narutoWorkGraph ? ['naruto_work_graph_missing'] : []),
+        ...(isNarutoRoute && narutoWorkGraph?.ok === false ? narutoWorkGraph.blockers || ['naruto_work_graph_not_ok'] : []),
+        ...(isNarutoRoute && !narutoRoleDistribution ? ['naruto_role_distribution_missing'] : []),
+        ...(isNarutoRoute && narutoRoleDistribution?.ok === false ? narutoRoleDistribution.blockers || ['naruto_role_distribution_not_ok'] : []),
+        ...(isNarutoRoute && !narutoConcurrencyGovernor ? ['naruto_concurrency_governor_missing'] : []),
+        ...(isNarutoRoute && !narutoActivePool ? ['naruto_active_pool_missing'] : []),
+        ...(isNarutoRoute && narutoActivePool?.ok === false ? narutoActivePool.blockers || ['naruto_active_pool_not_ok'] : []),
+        ...(isNarutoRoute && !narutoVerificationDag ? ['naruto_verification_dag_missing'] : []),
+        ...(isNarutoRoute && !narutoGptFinalPack ? ['naruto_gpt_final_pack_missing'] : []),
+        ...(isNarutoRoute && !narutoZellijDashboard ? ['naruto_zellij_dashboard_missing'] : []),
+        ...changedFileLeaseBlockers
     ];
     const evidence = {
         schema: AGENT_PROOF_EVIDENCE_SCHEMA,
@@ -222,6 +248,23 @@ export async function writeAgentProofEvidence(root, input) {
         gpt_final_patch_source: finalGptPatchStage?.final_patch_source || (localParticipated ? 'blocked' : 'not_applicable'),
         gpt_final_gate_ok: localFinalGate.ok === true,
         gpt_final_gate: localFinalGate,
+        naruto_work_graph: narutoWorkGraph ? 'naruto-work-graph.json' : null,
+        naruto_total_work_items: Number(narutoWorkGraph?.total_work_items || 0),
+        naruto_mixed_work_kinds: narutoWorkGraph?.mixed_work_kinds || [],
+        naruto_write_allowed_count: Number(narutoWorkGraph?.write_allowed_count || 0),
+        naruto_role_distribution: narutoRoleDistribution ? 'naruto-role-distribution.json' : null,
+        naruto_role_distribution_entries: narutoRoleDistribution?.entries || [],
+        naruto_verifier_only: narutoRoleDistribution?.verifier_only === true,
+        naruto_implementation_like_ratio: Number(narutoRoleDistribution?.implementation_like_ratio || 0),
+        naruto_concurrency_governor: narutoConcurrencyGovernor ? 'naruto-concurrency-governor.json' : null,
+        naruto_safe_active_workers: Number(narutoConcurrencyGovernor?.safe_active_workers || 0),
+        naruto_safe_zellij_visible_panes: Number(narutoConcurrencyGovernor?.safe_zellij_visible_panes || 0),
+        naruto_headless_workers: Number(narutoConcurrencyGovernor?.headless_workers || 0),
+        naruto_active_pool: narutoActivePool ? 'naruto-active-pool.json' : null,
+        naruto_active_pool_refill_events: Number(narutoActivePool?.refill_events || 0),
+        naruto_verification_dag: narutoVerificationDag ? 'naruto-verification-dag.json' : null,
+        naruto_gpt_final_pack: narutoGptFinalPack ? 'naruto-gpt-final-pack.json' : null,
+        naruto_zellij_dashboard: narutoZellijDashboard ? 'naruto-zellij-dashboard.json' : null,
         patch_swarm_runtime: patchSwarm ? 'agent-patch-swarm-runtime.json' : null,
         patch_queue: patchSwarm ? 'agent-patch-queue.json' : null,
         patch_queue_events: patchSwarm ? 'agent-patch-queue-events.jsonl' : null,
@@ -334,7 +377,7 @@ export async function writeAgentProofEvidence(root, input) {
         triwiki_use_first_count: Number(input.triwikiContext?.use_first?.length || 0),
         triwiki_hydrate_first_count: Number(input.triwikiContext?.hydrate_first?.length || 0),
         triwiki_claim_count: Number(input.triwikiContext?.claim_count || 0),
-        changed_files_lease_checked: true,
+        changed_files_lease_checked: !readOnlyNoWriteLeaseMode,
         dependency_collision_risk: input.partition?.no_overlap_proof?.dependency_collision_risk || [],
         blockers
     };
@@ -413,6 +456,20 @@ function agentChangedFileLeaseViolations(results, leases) {
     }
     return violations;
 }
+function isReadOnlyNoWriteLeaseMode(input) {
+    const writeLeaseCount = input.leases.filter((lease) => lease.kind === 'write').length;
+    if (writeLeaseCount > 0)
+        return false;
+    const resultWriteSignals = input.results.some((result) => (Array.isArray(result?.writes) && result.writes.length > 0)
+        || (Array.isArray(result?.patch_envelopes) && result.patch_envelopes.length > 0));
+    if (resultWriteSignals)
+        return false;
+    const policyReadonly = input.parallelWritePolicy?.readonly === true;
+    const policyWriteOff = String(input.parallelWritePolicy?.write_mode || 'off') === 'off';
+    const narutoReadOnly = input.narutoWorkGraph?.readonly === true || Number(input.narutoWorkGraph?.write_allowed_count || 0) === 0;
+    const taskGraphNoWrites = Number(input.taskGraph?.write_allowed_count || 0) === 0;
+    return policyReadonly || policyWriteOff || narutoReadOnly || taskGraphNoWrites;
+}
 function pathWithin(file, leasePath) {
     const left = String(file || '').replace(/\\/g, '/').replace(/^\.\//, '');
     const right = String(leasePath || '').replace(/\\/g, '/').replace(/^\.\//, '').replace(/\/+$/, '');

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

@@ -2,6 +2,7 @@ import os from 'node:os';
 import { DEFAULT_AGENT_CONCURRENCY, DEFAULT_AGENT_COUNT, DEFAULT_NARUTO_CLONES, MAX_AGENT_COUNT, MAX_NARUTO_AGENT_COUNT, agentSessionId } from './agent-schema.js';
 import { defaultAgentPersonas, validatePersonaUniqueness } from './agent-persona.js';
 import { buildAgentEffortPolicy, decideAgentEffort, decideNarutoCloneEffort } from './agent-effort-policy.js';
+import { mapNarutoRoleToAgentRole, narutoRoleAllowsWrite } from '../naruto/naruto-role-policy.js';
 // $Naruto must never blindly spawn the full clone count at once, but the live
 // CONCURRENCY ceiling is NOT a function of CPU cores. Each clone is a separate CLI
 // worker process that spends ~all of its wall-clock awaiting the Codex API
@@ -156,28 +157,40 @@ export function buildNarutoCloneRoster(opts = {}) {
     const basePool = pool.length ? pool : defaultAgentPersonas(DEFAULT_AGENT_COUNT);
     const personas = [];
     const roster = [];
+    const roleCycle = narutoRoleCycle(readonly);
     for (let index = 0; index < cloneCount; index += 1) {
         const base = basePool[index % basePool.length];
         const cloneTag = 'clone-' + String(index + 1).padStart(3, '0');
         const id = 'naruto_' + cloneTag.replace(/-/g, '_');
-        const cloneReadonly = readonly || base.read_only;
+        const narutoRole = roleCycle[index % roleCycle.length] || 'verifier';
+        const writeAllowed = !readonly && narutoRoleAllowsWrite(narutoRole);
+        const cloneReadonly = readonly || !writeAllowed;
+        const role = mapNarutoRoleToAgentRole(narutoRole);
+        const allowedTools = writeAllowed ? ['read', 'search', 'edit', 'test'] : narutoRole === 'verifier' ? ['read', 'search', 'test'] : ['read', 'search'];
         // Dynamic per-clone effort like team mode, capped at low/medium and always fast.
-        const effort = decideNarutoCloneEffort({ persona: base, prompt: opts.prompt || '', agentId: id, readonly: cloneReadonly });
+        const effort = decideNarutoCloneEffort({ persona: { ...base, role, allowed_tools: allowedTools, read_only: cloneReadonly, write_policy: writeAllowed ? 'exclusive Naruto patch-envelope lease required' : 'read-only Naruto role' }, prompt: opts.prompt || '', agentId: id, readonly: cloneReadonly });
         const persona = {
             ...base,
             id,
             stable_id: base.stable_id + '-' + cloneTag,
-            read_only: readonly || base.read_only,
-            prompt: 'SHADOW CLONE: ' + cloneTag + ' (Kage Bunshin of ' + base.stable_id + ')\n' + base.prompt
+            role,
+            naruto_role: narutoRole,
+            write_allowed: writeAllowed,
+            read_only: cloneReadonly,
+            allowed_tools: allowedTools,
+            write_policy: writeAllowed ? 'exclusive Naruto patch-envelope lease required' : 'read-only Naruto role',
+            prompt: 'SHADOW CLONE: ' + cloneTag + ' (Kage Bunshin of ' + base.stable_id + ')\nNARUTO ROLE: ' + narutoRole + '\n' + base.prompt
         };
         personas.push(persona);
         roster.push({
             id,
             session_id: agentSessionId(id, index + 1),
             persona_id: id,
-            role: base.role,
+            role,
+            naruto_role: narutoRole,
+            write_allowed: writeAllowed,
             index: index + 1,
-            write_policy: cloneReadonly ? 'read-only' : base.write_policy,
+            write_policy: cloneReadonly ? 'read-only' : 'exclusive Naruto patch-envelope lease required',
             status: 'pending',
             reasoning_effort: effort.reasoning_effort,
             model_reasoning_effort: effort.model_reasoning_effort,
@@ -208,4 +221,20 @@ export function buildNarutoCloneRoster(opts = {}) {
     };
     return { ...result, effort_policy: buildAgentEffortPolicy(result) };
 }
+function narutoRoleCycle(readonly) {
+    if (readonly)
+        return ['verifier', 'researcher', 'verifier', 'gpt_final_arbiter'];
+    return [
+        'implementer',
+        'modifier',
+        'test_writer',
+        'verifier',
+        'researcher',
+        'conflict_resolver',
+        'rollback_planner',
+        'integrator',
+        'modifier',
+        'test_writer'
+    ];
+}
 //# sourceMappingURL=agent-roster.js.map

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

@@ -14,7 +14,7 @@ export const DEFAULT_AGENT_CONCURRENCY = 5;
 // cap; every other roster/scheduler caller keeps MAX_AGENT_COUNT as the default.
 export const MAX_NARUTO_AGENT_COUNT = 100;
 export const DEFAULT_NARUTO_CLONES = 12;
-export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk', 'zellij', 'ollama'];
+export const AGENT_BACKENDS = ['fake', 'process', 'codex-sdk', 'zellij', 'ollama', 'local-llm'];
 export function normalizeAgentBackend(input) {
     const value = String(input || 'codex-sdk');
     return AGENT_BACKENDS.includes(value) ? value : 'codex-sdk';

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

@@ -67,7 +67,8 @@ 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'] };
     }
-    if (patchEnvelopeValidation.envelopes.length === 0 && (normalized.changed_files.length > 0 || normalized.writes.length > 0)) {
+    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';
         normalized.blockers.push('no_patch_generated');
         normalized.verification = { status: 'failed', checks: [...normalized.verification.checks, 'agent-patch-envelope-required-for-write'] };
@@ -132,4 +133,11 @@ function normalizeVerification(value) {
         checks: Array.isArray(value?.checks) ? value.checks : []
     };
 }
+function acceptsNoPatchReadOnlyOrNoop(value) {
+    if (!value || typeof value !== 'object')
+        return false;
+    return value.ok === true
+        && value.read_only_or_noop_evidence === true
+        && String(value.reason || '') === 'read_only_or_no_write_paths';
+}
 //# sourceMappingURL=agent-worker-pipeline.js.map

package/dist/core/agents/native-worker-backend-router.js

@@ -57,6 +57,7 @@ export async function runNativeWorkerBackendRouter(input) {
         result = validateAgentWorkerResult({
             ...processRun,
             patch_envelopes: patchEnvelopes,
+            ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, backend) }),
             artifacts: [...new Set([...(processRun.artifacts || []), ...(patchEnvelopes.length ? [input.patchRel] : [])])],
             process_child_report: processReport,
             model_authored_patch_envelopes: false,
@@ -81,12 +82,14 @@ export async function runNativeWorkerBackendRouter(input) {
             ...ollamaRun,
             backend: 'ollama',
             patch_envelopes: patchEnvelopes,
+            ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, backend) }),
             model_authored_patch_envelopes: patchEnvelopes.length > 0,
             fixture_patch_envelopes: false,
             verification: { status: ollamaRun.status === 'done' ? 'passed' : 'failed', checks: [...(ollamaRun.verification?.checks || []), 'native-worker-backend-router', 'ollama-api-generate'] }
         });
     }
-    else if (backend === 'codex-sdk' || backend === 'zellij') {
+    else if (backend === 'codex-sdk' || backend === 'zellij' || backend === 'local-llm') {
+        const localPreferred = backend === 'local-llm';
         const sdkTask = await runCodexTask({
             route: String(input.intake.route || '$Agent'),
             tier: 'worker',
@@ -111,6 +114,12 @@ export async function runNativeWorkerBackendRouter(input) {
                 user_confirmed_full_access: false,
                 mad_sks_authorized: input.intake.mad_sks_authorized === true || process.env.SKS_MAD_SKS_ACTIVE === '1'
             },
+            backendPreference: localPreferred ? ['local-llm', 'codex-sdk'] : ['codex-sdk'],
+            allowLocalLlm: localPreferred,
+            ...(localPreferred ? { localLlmPolicy: {
+                    mode: 'local_preferred',
+                    requiresGptFinal: true
+                } } : {}),
             mutationLedgerRoot: path.join(root, input.workerDirRel),
             zellijPaneId: await readZellijPaneId(root, input.workerDirRel),
             reliabilityPolicy: {
@@ -121,12 +130,14 @@ export async function runNativeWorkerBackendRouter(input) {
         outputLastMessagePath = sdkTask.workerResultPath;
         const sdkWorkerResult = await readJson(sdkTask.workerResultPath, null);
         patchEnvelopes = normalizeSdkPatchEnvelopes(sdkWorkerResult?.patch_envelopes || [], input, sdkTask.sdkThreadId);
-        proofLevel = sdkTask.ok ? (patchEnvelopes.length ? 'model_authored' : 'codex_sdk_thread_proven') : 'blocked';
+        proofLevel = sdkTask.ok ? (patchEnvelopes.length ? 'model_authored' : sdkTask.backend === 'local-llm' ? 'local_llm_worker_proven' : 'codex_sdk_thread_proven') : 'blocked';
         const sdkReport = {
             schema: 'sks.codex-sdk-worker-adapter.v1',
-            backend: 'codex-sdk',
+            backend: sdkTask.backend,
+            backend_family: sdkTask.backend_family,
             sdk_thread_id: sdkTask.sdkThreadId,
             sdk_run_id: sdkTask.sdkRunId,
+            local_llm_proof_path: sdkTask.localLlmProofPath || null,
             stream_event_count: sdkTask.streamEventCount,
             structured_output_valid: sdkTask.structuredOutputValid,
             worker_result_path: sdkTask.workerResultPath,
@@ -136,17 +147,31 @@ export async function runNativeWorkerBackendRouter(input) {
         childReports = [sdkReport];
         result = validateAgentWorkerResult({
             ...sdkWorkerResult,
-            backend: 'codex-sdk',
+            backend: sdkTask.backend === 'local-llm' ? 'local-llm' : 'codex-sdk',
             patch_envelopes: patchEnvelopes,
+            ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, sdkTask.backend || backend) }),
             codex_child_report: sdkReport,
             codex_sdk_thread: sdkReport,
             model_authored_patch_envelopes: patchEnvelopes.length > 0,
             fixture_patch_envelopes: false,
-            artifacts: [...new Set([...(sdkWorkerResult?.artifacts || []), path.relative(root, sdkTask.workerResultPath), path.join(input.workerDirRel, 'codex-control-proof.json'), path.join(input.workerDirRel, 'codex-thread-registry.json'), path.join(input.workerDirRel, 'codex-sdk-events.jsonl')])],
+            artifacts: [...new Set([
+                    ...(sdkWorkerResult?.artifacts || []),
+                    path.relative(root, sdkTask.workerResultPath),
+                    path.join(input.workerDirRel, 'codex-control-proof.json'),
+                    path.join(input.workerDirRel, 'codex-thread-registry.json'),
+                    sdkTask.backend === 'local-llm' ? path.join(input.workerDirRel, 'local-llm-events.jsonl') : path.join(input.workerDirRel, 'codex-sdk-events.jsonl'),
+                    ...(sdkTask.localLlmProofPath ? [path.relative(root, sdkTask.localLlmProofPath)] : [])
+                ])],
             blockers: [...(sdkWorkerResult?.blockers || []), ...sdkTask.blockers],
             verification: {
                 status: sdkTask.ok ? 'passed' : 'failed',
-                checks: [...(sdkWorkerResult?.verification?.checks || []), 'codex-sdk-control-plane', 'codex-sdk-event-stream', 'codex-sdk-structured-output']
+                checks: [
+                    ...(sdkWorkerResult?.verification?.checks || []),
+                    sdkTask.backend === 'local-llm' ? 'local-llm-control-plane' : 'codex-sdk-control-plane',
+                    sdkTask.backend === 'local-llm' ? 'local-llm-event-stream' : 'codex-sdk-event-stream',
+                    sdkTask.backend === 'local-llm' ? 'local-llm-structured-output' : 'codex-sdk-structured-output',
+                    ...(sdkTask.backend === 'local-llm' ? ['gpt-final-required-before-acceptance'] : [])
+                ]
             }
         });
     }
@@ -167,6 +192,7 @@ export async function runNativeWorkerBackendRouter(input) {
         result = validateAgentWorkerResult({
             ...zellijRun,
             patch_envelopes: patchEnvelopes,
+            ...(patchEnvelopes.length ? {} : { no_patch_reason: buildNoPatchReason(input, backend) }),
             zellij_child_report: zellijReport,
             model_authored_patch_envelopes: false,
             fixture_patch_envelopes: false,
@@ -221,13 +247,13 @@ async function maybeAutoSelectOllamaBackend(backend, input) {
         model: input.intake?.ollama_model || null,
         baseUrl: input.intake?.ollama_base_url || null
     }).catch(() => null);
-    if (!config?.ok || config.enabled !== true)
+    if (!config?.ok || config.enabled !== true || config.status !== 'verified')
         return backend;
     const policy = classifyOllamaWorkerSlice(input.slice, { route: input.intake?.route, agent: input.agent });
-    return policy.ok ? 'ollama' : backend;
+    return policy.ok ? 'local-llm' : backend;
 }
 function normalizeBackend(value) {
-    return value === 'fake' || value === 'process' || value === 'codex-sdk' || value === 'zellij' || value === 'ollama' ? value : null;
+    return value === 'fake' || value === 'process' || value === 'codex-sdk' || value === 'zellij' || value === 'ollama' || value === 'local-llm' ? value : null;
 }
 function envelopeOpts(input, source, childPid) {
     return {
@@ -257,10 +283,24 @@ 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}.`,
+            : `Read-only slice. Return JSON matching ${CODEX_AGENT_WORKER_RESULT_SCHEMA_ID}; do not report pre-existing repository dirtiness as changed_files.`,
         'Required JSON fields: status, summary, findings, changed_files, patch_envelopes, verification, rollback_notes, blockers.'
     ].join('\n');
 }
+function buildNoPatchReason(input, backend) {
+    const writePathCount = writePaths(input.slice, input.intake).length;
+    return {
+        schema: 'sks.native-cli-worker-no-patch-reason.v1',
+        generated_at: nowIso(),
+        ok: writePathCount === 0,
+        reason: writePathCount ? 'write_capable_task_without_backend_patch_envelope' : 'read_only_or_no_write_paths',
+        route_justification: writePathCount ? 'backend returned no patch envelopes for a write-capable task' : 'task has no write paths',
+        read_only_or_noop_evidence: writePathCount === 0,
+        task_slice_id: input.slice?.id || null,
+        backend,
+        blockers: writePathCount && backend !== 'fake' ? ['write_capable_no_patch_envelope'] : []
+    };
+}
 function hasWriteLease(slice, intake) {
     return writePaths(slice, intake).length > 0;
 }

package/dist/core/agents/ollama-worker-config.js

@@ -2,12 +2,16 @@ import os from 'node:os';
 import path from 'node:path';
 import { ensureDir, exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
 export const LOCAL_MODEL_CONFIG_SCHEMA = 'sks.local-model-config.v1';
+export const LOCAL_MODEL_CONFIG_SCHEMA_V2 = 'sks.local-model-config.v2';
 export const OLLAMA_WORKER_CONFIG_SCHEMA = 'sks.ollama-worker-config.v1';
 export const DEFAULT_OLLAMA_CODER_MODEL = 'rafw007/qwen36-a3b-claude-coder:q4_K_M';
 export const DEFAULT_OLLAMA_BASE_URL = 'http://127.0.0.1:11434';
+export const DEFAULT_MLX_LM_MODEL = 'mlx-community/Qwen3.6-35B-A3B-4bit';
+export const DEFAULT_MLX_LM_BASE_URL = 'http://127.0.0.1:8080';
 export const DEFAULT_OLLAMA_KEEP_ALIVE = '30m';
 export const DEFAULT_OLLAMA_TIMEOUT_MS = 120_000;
 export const DEFAULT_OLLAMA_THINK = false;
+export const LOCAL_LLM_SMOKE_TTL_MS = 24 * 60 * 60 * 1000;
 export function localModelConfigPath() {
     return process.env.SKS_LOCAL_MODEL_CONFIG
         ? path.resolve(process.env.SKS_LOCAL_MODEL_CONFIG)
@@ -30,28 +34,38 @@ export async function resolveOllamaWorkerConfig(input = {}) {
     const explicitDisable = boolEnv(process.env.SKS_OLLAMA_WORKERS) === false;
     const explicitEnable = boolEnv(process.env.SKS_OLLAMA_WORKERS) === true || input.ollamaEnabled === true || input.backend === 'ollama';
     const enabled = explicitDisable ? false : explicitEnable || stored.enabled === true;
-    const model = firstText(process.env.SKS_OLLAMA_MODEL, input.model, stored.model, DEFAULT_OLLAMA_CODER_MODEL);
-    const baseUrl = trimTrailingSlash(firstText(process.env.SKS_OLLAMA_BASE_URL, input.baseUrl, stored.base_url, DEFAULT_OLLAMA_BASE_URL));
+    const explicitProvider = firstText(process.env.SKS_LOCAL_LLM_PROVIDER, input.provider, input.backend === 'ollama' ? 'ollama' : '');
+    const provider = explicitProvider ? normalizeProvider(explicitProvider) : normalizeProvider(stored.provider);
+    const storedMatchesProvider = stored.provider === provider;
+    const model = firstText(process.env.SKS_LOCAL_LLM_MODEL, process.env.SKS_OLLAMA_MODEL, input.model, storedMatchesProvider ? stored.model : '', defaultModelForProvider(provider));
+    const baseUrl = trimTrailingSlash(firstText(process.env.SKS_LOCAL_LLM_BASE_URL, process.env.SKS_OLLAMA_BASE_URL, input.baseUrl, storedMatchesProvider ? stored.base_url : '', defaultBaseUrlForProvider(provider)));
     const keepAlive = firstText(process.env.SKS_OLLAMA_KEEP_ALIVE, input.keepAlive, stored.keep_alive, DEFAULT_OLLAMA_KEEP_ALIVE);
     const timeoutMs = positiveNumber(process.env.SKS_OLLAMA_TIMEOUT_MS, input.timeoutMs, stored.timeout_ms, DEFAULT_OLLAMA_TIMEOUT_MS);
     const temperature = finiteNumber(process.env.SKS_OLLAMA_TEMPERATURE, input.temperature, stored.temperature, 0.1);
     const think = boolEnv(process.env.SKS_OLLAMA_THINK) ?? input.think ?? stored.think ?? DEFAULT_OLLAMA_THINK;
+    const status = enabled ? resolveEnabledStatus(stored) : 'disabled';
     const blockers = [
         ...(enabled ? [] : ['ollama_workers_disabled']),
-        ...(!model ? ['ollama_model_missing'] : []),
-        ...(!baseUrl ? ['ollama_base_url_missing'] : [])
+        ...(enabled && status !== 'verified' ? [`local_llm_${status}`] : []),
+        ...(!model ? ['local_model_missing'] : []),
+        ...(!baseUrl ? ['local_model_base_url_missing'] : [])
     ];
     return {
         schema: OLLAMA_WORKER_CONFIG_SCHEMA,
         ok: blockers.length === 0,
         enabled,
-        provider: 'ollama',
+        status,
+        provider,
         model,
         base_url: baseUrl,
+        endpoint: baseUrl,
         keep_alive: keepAlive,
         timeout_ms: timeoutMs,
         temperature,
         think,
+        policy: stored.policy,
+        capability: stored.capability,
+        last_smoke: stored.last_smoke,
         config_path: localModelConfigPath(),
         explicit_disable: explicitDisable,
         explicit_enable: explicitEnable,
@@ -59,25 +73,62 @@ export async function resolveOllamaWorkerConfig(input = {}) {
     };
 }
 export function normalizeLocalModelConfig(raw = {}) {
+    const enabled = raw.enabled === true;
+    const lastSmoke = normalizeSmoke(raw.last_smoke || raw.lastSmoke || null);
+    const status = enabled ? normalizeStatus(raw.status, lastSmoke) : 'disabled';
+    const provider = normalizeProvider(raw.provider);
+    const baseUrl = trimTrailingSlash(firstText(raw.base_url, raw.baseUrl, raw.endpoint, defaultBaseUrlForProvider(provider)));
     return {
-        schema: LOCAL_MODEL_CONFIG_SCHEMA,
+        schema: LOCAL_MODEL_CONFIG_SCHEMA_V2,
         ...(raw.generated_at ? { generated_at: String(raw.generated_at) } : { generated_at: nowIso() }),
         ...(raw.updated_at ? { updated_at: String(raw.updated_at) } : {}),
-        enabled: raw.enabled === true,
-        provider: 'ollama',
-        model: firstText(raw.model, DEFAULT_OLLAMA_CODER_MODEL),
-        base_url: trimTrailingSlash(firstText(raw.base_url, raw.baseUrl, DEFAULT_OLLAMA_BASE_URL)),
+        enabled,
+        status,
+        provider,
+        model: firstText(raw.model, defaultModelForProvider(provider)),
+        endpoint: baseUrl,
+        base_url: baseUrl,
         keep_alive: firstText(raw.keep_alive, raw.keepAlive, DEFAULT_OLLAMA_KEEP_ALIVE),
         timeout_ms: positiveNumber(raw.timeout_ms, raw.timeoutMs, DEFAULT_OLLAMA_TIMEOUT_MS),
         temperature: finiteNumber(raw.temperature, 0.1),
         think: typeof raw.think === 'boolean' ? raw.think : DEFAULT_OLLAMA_THINK,
-        policy: {
-            worker_only: true,
-            no_strategy_planning_design: true,
-            allowed_work: ['simple_code_patch_envelopes', 'read_only_collection']
-        }
+        policy: normalizePolicy(raw.policy),
+        capability: normalizeCapability(raw.capability),
+        last_smoke: lastSmoke,
+        blockers: Array.isArray(raw.blockers) ? raw.blockers.map(String) : status === 'blocked' ? ['local_llm_smoke_failed'] : []
     };
 }
+export function applyLocalLlmSmokeResult(config, smoke) {
+    const blockers = Array.isArray(smoke.blockers) ? smoke.blockers.map(String) : [];
+    const status = smoke.skipped
+        ? 'enabled_unverified'
+        : smoke.ok && smoke.schema_valid !== false
+            ? 'verified'
+            : smoke.status === 'degraded'
+                ? 'degraded'
+                : 'blocked';
+    return normalizeLocalModelConfig({
+        ...config,
+        enabled: true,
+        status,
+        capability: {
+            ...config.capability,
+            api_reachable: smoke.ok !== false,
+            model_installed: smoke.ok !== false
+        },
+        last_smoke: {
+            ...smoke,
+            status
+        },
+        blockers
+    });
+}
+export function localModelSmokeFresh(smoke, now = Date.now()) {
+    if (!smoke?.ok || smoke.schema_valid === false || !smoke.ran_at)
+        return false;
+    const ranAt = Date.parse(smoke.ran_at);
+    return Number.isFinite(ranAt) && now - ranAt <= LOCAL_LLM_SMOKE_TTL_MS;
+}
 export function boolEnv(value) {
     const text = String(value ?? '').trim().toLowerCase();
     if (!text)
@@ -99,6 +150,104 @@ function firstText(...values) {
 function trimTrailingSlash(value) {
     return value.replace(/\/+$/, '');
 }
+export function normalizeProvider(...values) {
+    for (const value of values) {
+        const text = String(value ?? '').trim().toLowerCase();
+        if (!text)
+            continue;
+        if (['ollama'].includes(text))
+            return 'ollama';
+        if (['mlx', 'mlx-lm', 'mlx_lm', 'mlxlm'].includes(text))
+            return 'mlx-lm';
+        if (['openai-compatible', 'openai_compatible', 'openai', 'openai-compatible-local'].includes(text))
+            return 'openai-compatible';
+    }
+    return 'ollama';
+}
+export function defaultModelForProvider(provider) {
+    if (provider === 'mlx-lm')
+        return DEFAULT_MLX_LM_MODEL;
+    if (provider === 'openai-compatible')
+        return '';
+    return DEFAULT_OLLAMA_CODER_MODEL;
+}
+export function defaultBaseUrlForProvider(provider) {
+    if (provider === 'mlx-lm')
+        return DEFAULT_MLX_LM_BASE_URL;
+    if (provider === 'openai-compatible')
+        return '';
+    return DEFAULT_OLLAMA_BASE_URL;
+}
+function resolveEnabledStatus(config) {
+    if (config.status === 'verified' && !localModelSmokeFresh(config.last_smoke))
+        return 'enabled_unverified';
+    return config.status === 'disabled' ? 'enabled_unverified' : config.status;
+}
+function normalizeStatus(value, smoke) {
+    const text = String(value ?? '').trim();
+    const known = ['disabled', 'enabled_unverified', 'verified', 'degraded', 'blocked'];
+    if (known.includes(text)) {
+        if (text === 'verified' && !localModelSmokeFresh(smoke))
+            return 'enabled_unverified';
+        return text;
+    }
+    return localModelSmokeFresh(smoke) ? 'verified' : 'enabled_unverified';
+}
+function normalizePolicy(value) {
+    const defaultAllowed = ['simple_patch_envelope', 'read_only_collection', 'grep_like_qa', 'test_generation_draft'];
+    const allowed = [
+        ...defaultAllowed,
+        ...(Array.isArray(value?.allowed_task_classes) ? value.allowed_task_classes : []),
+        ...(Array.isArray(value?.allowed_work) ? value.allowed_work : [])
+    ];
+    const forbidden = Array.isArray(value?.forbidden_task_classes) ? value.forbidden_task_classes : [
+        'planning',
+        'strategy',
+        'final_review',
+        'verification_authority',
+        'safety_authority',
+        'integration_authority'
+    ];
+    return {
+        role: 'worker_only',
+        allowed_task_classes: [...new Set(allowed.map(String))],
+        forbidden_task_classes: forbidden.map(String),
+        requires_gpt_final: value?.requires_gpt_final !== false
+    };
+}
+function normalizeCapability(value) {
+    return {
+        api_reachable: value?.api_reachable === true,
+        model_installed: value?.model_installed === true,
+        supports_streaming: value?.supports_streaming !== false,
+        supports_json_schema: value?.supports_json_schema === true,
+        supports_tools: value?.supports_tools === true,
+        supports_images: value?.supports_images === true,
+        context_window: positiveNumber(value?.context_window, 32768),
+        max_parallel_requests: Math.max(1, Math.min(16, positiveNumber(value?.max_parallel_requests, 4)))
+    };
+}
+function normalizeSmoke(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    return {
+        ok: value.ok === true,
+        ...(value.skipped === true ? { skipped: true } : {}),
+        ...(value.ran_at ? { ran_at: String(value.ran_at) } : {}),
+        ...(value.prompt_hash ? { prompt_hash: String(value.prompt_hash) } : {}),
+        ...(Number.isFinite(Number(value.latency_ms)) ? { latency_ms: Number(value.latency_ms) } : {}),
+        ...(Number.isFinite(Number(value.tokens_per_second)) ? { tokens_per_second: Number(value.tokens_per_second) } : {}),
+        ...(typeof value.schema_valid === 'boolean' ? { schema_valid: value.schema_valid } : {}),
+        ...(value.result_path ? { result_path: String(value.result_path) } : {}),
+        ...(normalizeKnownStatus(value.status) ? { status: normalizeKnownStatus(value.status) } : {}),
+        ...(value.reason ? { reason: String(value.reason) } : {}),
+        ...(Array.isArray(value.blockers) ? { blockers: value.blockers.map(String) } : {})
+    };
+}
+function normalizeKnownStatus(value) {
+    const text = String(value ?? '').trim();
+    return ['disabled', 'enabled_unverified', 'verified', 'degraded', 'blocked'].includes(text) ? text : undefined;
+}
 function positiveNumber(...values) {
     for (const value of values) {
         const n = Number(value);