sneakoscope 2.0.2 → 2.0.5

package/dist/core/commands/naruto-command.js

@@ -1,10 +1,20 @@
 import path from 'node:path';
 import { createMission, findLatestMission, loadMission } from '../mission.js';
-import { readJson, sksRoot } from '../fsx.js';
+import { readJson, sksRoot, writeJsonAtomic } from '../fsx.js';
 import { runNativeAgentOrchestrator } from '../agents/agent-orchestrator.js';
+import { classifyOllamaWorkerSlice } from '../agents/agent-runner-ollama.js';
 import { buildNarutoCloneRoster, systemSafeNarutoConcurrency } from '../agents/agent-roster.js';
 import { DEFAULT_NARUTO_CLONES, MAX_NARUTO_AGENT_COUNT } from '../agents/agent-schema.js';
+import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
 import { attachZellijSessionInteractive, launchZellijLayout } from '../zellij/zellij-launcher.js';
+import { buildNarutoWorkGraph } from '../naruto/naruto-work-graph.js';
+import { buildNarutoRoleDistribution } from '../naruto/naruto-role-policy.js';
+import { decideNarutoConcurrency } from '../naruto/naruto-concurrency-governor.js';
+import { simulateNarutoActivePool } from '../naruto/naruto-active-pool.js';
+import { buildNarutoVerificationDag } from '../naruto/naruto-verification-dag.js';
+import { buildNarutoGptFinalPack } from '../naruto/naruto-gpt-final-pack.js';
+import { planNarutoZellijDashboard } from '../zellij/zellij-naruto-dashboard.js';
+import { checkPromptPlaceholders } from '../prompt/prompt-placeholder-guard.js';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
 // $Naruto — Shadow Clone Swarm (影分身 / Kage Bunshin no Jutsu).
@@ -23,6 +33,27 @@ export async function narutoCommand(commandOrArgs = 'naruto', maybeArgs = []) {
 }
 async function narutoRun(parsed) {
     const root = await sksRoot();
+    const writeCapable = parsed.readonly !== true && parsed.writeMode !== 'off';
+    const placeholderGuard = checkPromptPlaceholders({
+        prompt: parsed.prompt,
+        writeCapable,
+        targetPaths: writeCapable ? ['.sneakoscope/naruto/patch-envelopes'] : []
+    });
+    if (!placeholderGuard.ok) {
+        return emit(parsed, {
+            schema: NARUTO_RESULT_SCHEMA,
+            ok: false,
+            mode: 'NARUTO',
+            action: 'run',
+            status: 'blocked',
+            prompt_placeholder_guard: placeholderGuard,
+            blockers: placeholderGuard.blockers
+        }, () => {
+            console.log('$Naruto blocked before work graph creation: unresolved prompt placeholder or empty write target path.');
+            for (const blocker of placeholderGuard.blockers)
+                console.log('- ' + blocker);
+        });
+    }
     const roster = buildNarutoCloneRoster({
         clones: parsed.clones,
         prompt: parsed.prompt,
@@ -32,10 +63,55 @@ async function narutoRun(parsed) {
     // The clone roster is the full work fan-out; live concurrency is throttled to a
     // system-safe number so naruto never spawns the whole count at once unless an
     // explicit operator override asks for a higher target.
-    const safe = systemSafeNarutoConcurrency({ backend: parsed.backend });
-    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || safe.cap));
+    const localWorker = await resolveNarutoLocalWorkerMode(parsed);
+    const schedulerBackend = localWorker.auto_select_eligible ? 'ollama' : parsed.backend;
+    const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
+    const workGraph = buildNarutoWorkGraph({
+        prompt: parsed.prompt,
+        requestedClones: roster.agent_count,
+        totalWorkItems: parsed.workItems,
+        readonly: parsed.readonly,
+        writeCapable,
+        targetPaths: ['.sneakoscope/naruto/patch-envelopes'],
+        maxActiveWorkers: parsed.concurrency || safe.cap
+    });
+    const roleDistribution = buildNarutoRoleDistribution(workGraph.work_items, { readonly: parsed.readonly });
+    const governor = decideNarutoConcurrency({
+        requestedClones: roster.agent_count,
+        totalWorkItems: workGraph.total_work_items,
+        pendingWorkQueueSize: workGraph.total_work_items,
+        backend: schedulerBackend
+    });
+    const backendMinimum = schedulerBackend === 'fake' ? roster.agent_count : Math.min(roster.agent_count, 2);
+    const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || Math.max(governor.safe_active_workers, backendMinimum), safe.cap));
+    const zellijVisiblePanes = Math.max(1, Math.min(activeSlots, governor.safe_zellij_visible_panes));
+    const activePool = simulateNarutoActivePool({ graph: workGraph, governor: { ...governor, safe_active_workers: activeSlots } });
+    const verificationDag = buildNarutoVerificationDag(workGraph, { cwd: root });
+    const gptFinalPack = buildNarutoGptFinalPack({
+        missionId: 'pending',
+        graph: workGraph,
+        roleDistribution,
+        localLlmMetrics: localWorker
+    });
+    const zellijDashboard = planNarutoZellijDashboard({
+        targetActiveWorkers: activeSlots,
+        visiblePaneCap: governor.safe_zellij_visible_panes,
+        backpressure: governor.backpressure,
+        roles: roleDistribution.work_item_roles.map((row) => row.role),
+        backend: schedulerBackend
+    });
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
     const ledgerRoot = path.join(mission.dir, 'agents');
+    await writeNarutoArtifacts(ledgerRoot, {
+        workGraph,
+        roleDistribution,
+        governor,
+        activePool,
+        verificationDag,
+        gptFinalPack: { ...gptFinalPack, mission_id: mission.id },
+        zellijDashboard,
+        placeholderGuard
+    });
     let liveZellij = null;
     if (!parsed.json && !parsed.mock && !parsed.noOpenZellij) {
         liveZellij = await launchZellijLayout({
@@ -43,12 +119,12 @@ async function narutoRun(parsed) {
             missionId: mission.id,
             ledgerRoot,
             kind: 'naruto',
-            slotCount: roster.agent_count,
+            slotCount: zellijVisiblePanes,
             dryRun: false,
             attach: false
         });
         if (liveZellij?.ok && liveZellij.capability?.status === 'ok') {
-            console.log('Zellij: prepared ' + roster.agent_count + ' live clone lane(s) in ' + liveZellij.session_name + '. Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
+            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + liveZellij.session_name + ' with ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s). Attach with: ' + (liveZellij.attach_command_with_env || liveZellij.attach_command));
             if (parsed.attach)
                 attachZellijSessionInteractive(liveZellij.session_name, { cwd: process.cwd(), configPath: liveZellij.clipboard_config_path });
         }
@@ -69,12 +145,17 @@ async function narutoRun(parsed) {
         agents: roster.agent_count,
         concurrency: activeSlots,
         targetActiveSlots: activeSlots,
-        visualLaneCount: roster.agent_count,
+        visualLaneCount: zellijVisiblePanes,
         desiredWorkItemCount: parsed.workItems,
         maxAgentCount: MAX_NARUTO_AGENT_COUNT,
         narutoMode: true,
         clones: roster.agent_count,
         backend: parsed.backend,
+        backendExplicit: parsed.backendExplicit,
+        noOllama: parsed.noOllama,
+        ollamaEnabled: parsed.ollamaEnabled,
+        ollamaModel: parsed.ollamaModel,
+        ollamaBaseUrl: parsed.ollamaBaseUrl,
         mock: parsed.mock,
         real: parsed.real,
         readonly: parsed.readonly,
@@ -86,6 +167,7 @@ async function narutoRun(parsed) {
         json: parsed.json
     });
     const clones = result.roster?.agent_count ?? roster.agent_count;
+    const localWorkerSummary = summarizeNarutoLocalWorkerResult(localWorker, result);
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: result.ok === true,
@@ -99,6 +181,21 @@ async function narutoRun(parsed) {
         target_active_slots: result.target_active_slots ?? activeSlots,
         concurrency_capped: clones > (result.target_active_slots ?? activeSlots),
         system: { cores: safe.cores, free_gb: safe.free_gb, safe_concurrency: safe.cap, heavy_backend: safe.heavy },
+        work_graph: {
+            total_work_items: workGraph.total_work_items,
+            mixed_work_kinds: workGraph.mixed_work_kinds,
+            write_allowed_count: workGraph.write_allowed_count,
+            ok: workGraph.ok
+        },
+        role_distribution: roleDistribution,
+        concurrency_governor: governor,
+        active_pool: {
+            ok: activePool.ok,
+            max_observed_active_workers: activePool.max_observed_active_workers,
+            refill_events: activePool.refill_events,
+            completed_count: activePool.completed_count
+        },
+        local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
         run: result,
         zellij: null
@@ -109,13 +206,27 @@ async function narutoRun(parsed) {
         console.log('Mission: ' + result.mission_id);
         console.log('Clones: ' + summary.clones + ' / max ' + MAX_NARUTO_AGENT_COUNT + ', running ' + summary.target_active_slots + ' at a time' + (summary.concurrency_capped ? ` (throttled to host capacity: ${safe.cores} cores, ${safe.free_gb} GB free)` : ''));
         console.log('Backend: ' + result.backend);
+        console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
         console.log('Proof: ' + summary.proof);
         if (summary.zellij?.ok && summary.zellij.capability?.status === 'ok')
-            console.log('Zellij: prepared ' + summary.clones + ' native clone lane(s) in ' + summary.zellij.session_name);
+            console.log('Zellij: prepared ' + zellijVisiblePanes + ' visible active clone lane(s) in ' + summary.zellij.session_name + '; dashboard tracks ' + Math.max(0, activeSlots - zellijVisiblePanes) + ' headless active worker(s)');
         else if (summary.zellij?.ok)
             console.log('Zellij: optional live panes unavailable (' + ((summary.zellij.warnings || []).join('; ') || summary.zellij.capability?.status || 'unknown') + ')');
     });
 }
+function summarizeNarutoLocalWorkerResult(localWorker, result) {
+    const backendCounts = {};
+    const rows = Array.isArray(result?.results) ? result.results : [];
+    for (const row of rows) {
+        const selected = String(row?.backend_router_report?.selected_backend || row?.backend || 'unknown');
+        backendCounts[selected] = (backendCounts[selected] || 0) + 1;
+    }
+    return {
+        ...localWorker,
+        selected_worker_count: backendCounts.ollama || 0,
+        backend_counts: backendCounts
+    };
+}
 async function narutoStatus(parsed) {
     const root = await sksRoot();
     const id = parsed.missionId && parsed.missionId !== 'latest' ? parsed.missionId : await findLatestMission(root);
@@ -124,6 +235,9 @@ async function narutoStatus(parsed) {
     const { dir } = await loadMission(root, id);
     const proof = await readJson(path.join(dir, 'agents', 'agent-proof-evidence.json'), null);
     const scheduler = await readJson(path.join(dir, 'agents', 'agent-scheduler-state.json'), null);
+    const roleDistribution = await readJson(path.join(dir, 'agents', 'naruto-role-distribution.json'), null);
+    const workGraph = await readJson(path.join(dir, 'agents', 'naruto-work-graph.json'), null);
+    const governor = await readJson(path.join(dir, 'agents', 'naruto-concurrency-governor.json'), null);
     const summary = {
         schema: NARUTO_RESULT_SCHEMA,
         ok: proof !== null,
@@ -132,13 +246,22 @@ async function narutoStatus(parsed) {
         proof: proof?.status || 'missing',
         target_active_slots: scheduler?.target_active_slots ?? null,
         max_active_slots: scheduler?.max_active_slots ?? null,
-        completed: scheduler?.completed_count ?? null
+        completed: scheduler?.completed_count ?? null,
+        role_distribution: roleDistribution,
+        work_graph: workGraph ? {
+            total_work_items: workGraph.total_work_items,
+            mixed_work_kinds: workGraph.mixed_work_kinds,
+            write_allowed_count: workGraph.write_allowed_count
+        } : null,
+        concurrency_governor: governor
     };
     return emit(parsed, summary, () => {
         console.log('🍥 Naruto mission: ' + id);
         console.log('Proof: ' + summary.proof);
         if (summary.target_active_slots !== null)
             console.log('Active clones: ' + summary.target_active_slots + ' / max ' + summary.max_active_slots);
+        if (roleDistribution?.entries)
+            console.log('Roles: ' + roleDistribution.entries.map((entry) => `${entry.role}:${entry.count}`).join(', '));
     });
 }
 async function narutoHelp(parsed) {
@@ -149,7 +272,7 @@ async function narutoHelp(parsed) {
         mode: 'NARUTO',
         description: 'Shadow Clone Swarm: fan out up to ' + MAX_NARUTO_AGENT_COUNT + ' parallel clone sessions.',
         usage: [
-            'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake] [--work-items N] [--real] [--readonly] [--json]',
+            'sks naruto run "<task>" [--clones N] [--backend codex-sdk|fake|ollama] [--local-model|--no-ollama] [--work-items N] [--real] [--readonly] [--json]',
             'sks naruto status [--mission <id>] [--json]'
         ],
         defaults: { clones: DEFAULT_NARUTO_CLONES, max_clones: MAX_NARUTO_AGENT_COUNT, backend: 'codex-sdk' }
@@ -162,6 +285,8 @@ async function narutoHelp(parsed) {
     });
 }
 function parseNarutoArgs(args = []) {
+    if (hasFlag(args, '--help') || hasFlag(args, '-h'))
+        args = ['help', ...args.filter((arg) => arg !== '--help' && arg !== '-h')];
     const first = args[0] && !String(args[0]).startsWith('--') ? String(args[0]) : '';
     const actions = new Set(['run', 'status', 'help']);
     const action = (actions.has(first) ? first : 'run');
@@ -171,18 +296,33 @@ function parseNarutoArgs(args = []) {
     const clones = clampClones(requestedClones);
     const workItems = clampWorkItems(Number(readOption(args, '--work-items', clones)), clones);
     const concurrency = normalizeConcurrency(readOption(args, '--concurrency', readOption(args, '--target-active-slots', null)), clones);
-    const backend = String(readOption(args, '--backend', hasFlag(args, '--mock') ? 'fake' : 'codex-sdk'));
+    const useOllama = hasFlag(args, '--ollama') || hasFlag(args, '--local-model');
+    const noOllama = hasFlag(args, '--no-ollama') || hasFlag(args, '--no-local-model');
+    const backendExplicit = hasOption(args, '--backend') || useOllama || noOllama;
+    const backend = String(readOption(args, '--backend', hasFlag(args, '--mock') ? 'fake' : useOllama && !noOllama ? 'ollama' : 'codex-sdk'));
     const mock = hasFlag(args, '--mock') || backend === 'fake';
     const real = hasFlag(args, '--real');
     const readonly = hasFlag(args, '--readonly') || hasFlag(args, '--read-only');
     const writeModeRaw = String(readOption(args, '--write-mode', hasFlag(args, '--parallel-write') ? 'parallel' : '') || '');
     const writeMode = (['proof-safe', 'parallel', 'serial', 'off'].includes(writeModeRaw) ? writeModeRaw : null);
     const missionId = String(readOption(args, '--mission', readOption(args, '--mission-id', 'latest')));
+    const ollamaModel = String(readOption(args, '--ollama-model', readOption(args, '--local-model-model', '')) || '') || null;
+    const ollamaBaseUrl = String(readOption(args, '--ollama-base-url', readOption(args, '--local-model-base-url', '')) || '') || null;
     const noOpenZellij = hasFlag(args, '--no-open-zellij') || hasFlag(args, '--no-zellij');
     const attach = hasFlag(args, '--attach');
-    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id']);
+    const valueFlags = new Set(['--clones', '--agents', '--work-items', '--concurrency', '--target-active-slots', '--backend', '--write-mode', '--mission', '--mission-id', '--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']);
     const prompt = positionalArgs(rest, valueFlags).join(' ').trim() || 'Naruto shadow clone swarm run';
-    return { action, prompt, clones, workItems, concurrency, backend, mock, real, readonly, writeMode, json, missionId, noOpenZellij, attach };
+    return { action, prompt, clones, workItems, concurrency, backend, backendExplicit, mock, real, readonly, ollamaEnabled: useOllama && !noOllama, noOllama, ollamaModel, ollamaBaseUrl, writeMode, json, missionId, noOpenZellij, attach };
+}
+async function writeNarutoArtifacts(ledgerRoot, artifacts) {
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-work-graph.json'), artifacts.workGraph);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-role-distribution.json'), artifacts.roleDistribution);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-concurrency-governor.json'), artifacts.governor);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-active-pool.json'), artifacts.activePool);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-verification-dag.json'), artifacts.verificationDag);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-gpt-final-pack.json'), artifacts.gptFinalPack);
+    await writeJsonAtomic(path.join(ledgerRoot, 'naruto-zellij-dashboard.json'), artifacts.zellijDashboard);
+    await writeJsonAtomic(path.join(ledgerRoot, 'prompt-placeholder-guard.json'), artifacts.placeholderGuard);
 }
 function clampClones(value) {
     if (!Number.isFinite(value) || value < 1)
@@ -212,6 +352,9 @@ function readOption(args, name, fallback) {
     const prefixed = args.find((arg) => String(arg).startsWith(name + '='));
     return prefixed ? prefixed.slice(name.length + 1) : fallback;
 }
+function hasOption(args, name) {
+    return args.includes(name) || args.some((arg) => String(arg).startsWith(name + '='));
+}
 function positionalArgs(args, valueFlags) {
     const out = [];
     for (let i = 0; i < args.length; i += 1) {
@@ -233,4 +376,44 @@ function emit(parsed, result, text) {
     text();
     return result;
 }
+async function resolveNarutoLocalWorkerMode(parsed) {
+    const configInput = {
+        ollamaEnabled: parsed.ollamaEnabled,
+        model: parsed.ollamaModel,
+        baseUrl: parsed.ollamaBaseUrl
+    };
+    if (parsed.backend === 'ollama')
+        configInput.backend = 'ollama';
+    const config = await resolveOllamaWorkerConfig(configInput).catch(() => null);
+    const policy = classifyOllamaWorkerSlice({
+        id: 'naruto-local-worker-probe',
+        role: parsed.readonly ? 'collector' : 'implementer',
+        description: parsed.prompt,
+        write_paths: parsed.readonly ? [] : ['<lease-scoped-worker-path>']
+    }, { route: NARUTO_ROUTE, agent: { role: parsed.readonly ? 'collector' : 'implementer' } });
+    const autoSelectEligible = parsed.backend === 'codex-sdk'
+        && parsed.backendExplicit !== true
+        && parsed.noOllama !== true
+        && config?.ok === true
+        && config.enabled === true
+        && policy.ok === true;
+    return {
+        schema: 'sks.naruto-local-worker-mode.v1',
+        enabled: config?.enabled === true,
+        provider: config?.provider || 'ollama',
+        model: config?.model || null,
+        requested_backend: parsed.backend,
+        backend_explicit: parsed.backendExplicit,
+        auto_select_eligible: autoSelectEligible,
+        worker_only: true,
+        no_strategy_planning_design: true,
+        policy,
+        blockers: [
+            ...(config?.blockers || (config ? [] : ['ollama_worker_config_unavailable'])),
+            ...(policy.blockers || []),
+            ...(parsed.backendExplicit ? ['backend_explicit'] : []),
+            ...(parsed.noOllama ? ['no_ollama_requested'] : [])
+        ]
+    };
+}
 //# sourceMappingURL=naruto-command.js.map

package/dist/core/commands/run-command.js

@@ -231,7 +231,7 @@ async function executeRouteCommand(root, route, prompt, { auto = false } = {}) {
     return routeExecutionResult(route, ['sks', ...commandArgs].join(' '), result, {
         okStatus: 'completed',
         trustStatus: 'verified_partial',
-        executionKind: route.command === '$DB' || route.command === '$Wiki' || route.command === '$Fast-Mode' || route.command === '$with-local-llm-on' ? 'safe_deterministic' : 'mock_safe',
+        executionKind: route.command === '$DB' || route.command === '$Wiki' || route.command === '$Fast-Mode' || route.command === '$with-local-llm-on' || route.command === '$Commit' || route.command === '$Commit-And-Push' ? 'safe_deterministic' : 'mock_safe',
     });
 }
 async function runAutoVerification(root, missionId) {
@@ -290,7 +290,7 @@ async function runSks(root, commandArgs) {
         cwd: root,
         timeoutMs: 180_000,
         maxOutputBytes: 512 * 1024,
-        env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', CI: 'true' },
+        env: { SKS_SKIP_NPM_FRESHNESS_CHECK: '1', SKS_LOCAL_LLM_TOGGLE_ONLY: '1', CI: 'true' },
     });
 }
 function routeExecutionResult(route, command, result, options = {}) {
@@ -348,6 +348,10 @@ function safeRouteExecutionArgs(route, prompt, { auto = false } = {}) {
         return ['fast-mode', fastModeActionFromPrompt(prompt), '--json'];
     if (route.command === '$with-local-llm-on')
         return ['with-local-llm', localModelActionFromPrompt(prompt), '--json'];
+    if (route.command === '$Commit')
+        return ['commit', '--json'];
+    if (route.command === '$Commit-And-Push')
+        return ['commit-and-push', '--json'];
     return ['team', prompt, '--mock', '--json', ...(auto ? ['--no-open-zellij'] : [])];
 }
 function fastModeActionFromPrompt(prompt = '') {

package/dist/core/doctor/doctor-readiness-matrix.js

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { nowIso, writeJsonAtomic } from '../fsx.js';
+import { resolveLocalCollaborationPolicy } from '../local-llm/local-collaboration-policy.js';
 export const DOCTOR_READINESS_MATRIX_SCHEMA = 'sks.doctor-readiness-matrix.v1';
 export async function writeDoctorReadinessMatrix(root, input = {}) {
     const matrix = buildDoctorReadinessMatrix(input);
@@ -53,6 +54,20 @@ export function buildDoctorReadinessMatrix(input = {}) {
         warnings.add('codex_app_fast_selector_repaired_restart_app_if_needed');
     if (input.codex_lb?.ok === false)
         warnings.add(`codex_lb_${input.codex_lb?.circuit?.state || 'blocked'}`);
+    const localModel = input.local_model || {};
+    const localStatus = String(localModel.status || (localModel.enabled ? 'enabled_unverified' : 'disabled'));
+    if (localModel.enabled === true && localStatus === 'enabled_unverified')
+        warnings.add('local_llm_enabled_unverified');
+    if (localModel.enabled === true && localStatus === 'degraded')
+        warnings.add('local_llm_degraded');
+    if (localModel.enabled === true && localStatus === 'blocked')
+        warnings.add('local_llm_blocked_worker_tier_disabled');
+    const localCollaborationPolicy = resolveLocalCollaborationPolicy({ mode: input.local_collaboration?.mode || null });
+    const gptFinalAvailable = input.local_collaboration?.gpt_final_arbiter_available === undefined
+        ? codexBinOk
+        : input.local_collaboration.gpt_final_arbiter_available === true;
+    if (localCollaborationPolicy.gpt_final_required && !gptFinalAvailable)
+        blockers.add('gpt_final_arbiter_unavailable');
     const codexConfigNode = nodeRead.ok !== false && codexConfig.ok !== false;
     const codexConfigChild = childRead.ok !== false && codexConfig.ok !== false;
     const cliReady = codexBinOk && codexConfigNode && codexConfigChild && cliConfigOk;
@@ -92,6 +107,25 @@ export function buildDoctorReadinessMatrix(input = {}) {
         hooks_ready: input.hooks_ready !== false,
         codex_app_ready: input.codex_app?.ok === true,
         codex_app_required_for_cli: false,
+        local_collaboration: {
+            mode: localCollaborationPolicy.mode,
+            local_backend: input.local_collaboration?.local_backend || localModel.provider || 'ollama',
+            local_model: input.local_collaboration?.local_model || localModel.model || null,
+            final_arbiter: gptFinalAvailable ? 'GPT available' : 'missing',
+            final_apply_allowed: localCollaborationPolicy.gpt_final_required ? gptFinalAvailable : localCollaborationPolicy.mode === 'disabled',
+            blockers: localCollaborationPolicy.gpt_final_required && !gptFinalAvailable ? ['gpt_final_arbiter_unavailable'] : localCollaborationPolicy.blockers
+        },
+        local_llm: {
+            enabled: localModel.enabled === true,
+            status: localStatus,
+            provider: localModel.provider || 'ollama',
+            model: localModel.model || null,
+            endpoint: localModel.endpoint || localModel.base_url || null,
+            last_smoke: localModel.last_smoke || null,
+            final_arbiter: 'GPT required',
+            worker_tier_enabled: localModel.enabled === true && localStatus === 'verified',
+            blockers: normalizeList(localModel.blockers)
+        },
         ready: blockers.size === 0 && cliReady,
         primary_blocker: [...blockers][0] || null,
         blockers: [...blockers],

package/dist/core/feature-fixtures.js

@@ -25,6 +25,7 @@ const FIXTURES = Object.freeze({
     'cli-status': fixture('execute', 'sks status --json', [], 'pass'),
     'cli-usage': fixture('execute', 'sks usage overview', [], 'pass'),
     'cli-quickstart': fixture('execute', 'sks quickstart', [], 'pass'),
+    'cli-update': fixture('mock', 'sks update now --dry-run --json', [], 'pass'),
     'cli-update-check': fixture('static', 'sks update-check --json', [], 'pass'),
     'cli-guard': fixture('execute', 'sks guard check --json', [], 'pass'),
     'cli-conflicts': fixture('execute', 'sks conflicts check --json', [], 'pass'),
@@ -55,6 +56,7 @@ const FIXTURES = Object.freeze({
     'cli-stats': fixture('execute', 'sks stats --json', [], 'pass'),
     'cli-dollar-commands': fixture('execute', 'sks dollar-commands --json', [], 'pass'),
     'cli-fast-mode': fixture('execute', 'sks fast-mode status --json', [], 'pass'),
+    'cli-with-local-llm': fixture('execute', 'sks with-local-llm status --json', [], 'pass'),
     'cli-dfix': fixture('execute_and_validate_artifacts', 'sks dfix fixture --json', ['completion-proof.json', 'dfix-gate.json', 'dfix-verification.json'], 'pass'),
     'cli-wiki': fixture('execute_and_validate_artifacts', 'sks wiki image-ingest test/fixtures/images/one-by-one.png --json', [{ path: '.sneakoscope/wiki/image-voxel-ledger.json', schema: 'sks.image-voxel-ledger.v1', require_anchors: false }], 'pass'),
     'cli-db': fixture('execute', 'sks db policy', [], 'pass'),
@@ -112,6 +114,8 @@ const FIXTURES = Object.freeze({
     'route-fast-on': fixture('mock', '$Fast-On covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
     'route-fast-off': fixture('mock', '$Fast-Off covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
     'route-local-model': fixture('execute', 'sks with-local-llm status --json', [], 'pass'),
+    'route-with-local-llm-on': fixture('mock', '$with-local-llm-on covered by hermetic local-model dollar-command blackbox toggle test', [], 'pass'),
+    'route-with-local-llm-off': fixture('mock', '$with-local-llm-off covered by hermetic local-model dollar-command blackbox toggle test', [], 'pass'),
     'route-help': fixture('mock', '$Help lightweight route', [], 'pass'),
     'route-commit': fixture('mock', '$Commit git route', ['completion-proof.json'], 'pass'),
     'route-commit-and-push': fixture('mock', '$Commit-And-Push git route', ['completion-proof.json'], 'pass'),

package/dist/core/fsx.js

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 import { fileURLToPath } from 'node:url';
-export const PACKAGE_VERSION = '2.0.2';
+export const PACKAGE_VERSION = '2.0.5';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 export function nowIso() {

package/dist/core/git-simple.js

@@ -1,5 +1,8 @@
-import { runProcess, projectRoot, isGitRepo } from './fsx.js';
+import path from 'node:path';
+import { runProcess, projectRoot, isGitRepo, nowIso, sha256 } from './fsx.js';
 import { redactSecrets } from './secret-redaction.js';
+import { runOllamaAgent } from './agents/agent-runner-ollama.js';
+import { resolveOllamaWorkerConfig } from './agents/ollama-worker-config.js';
 const TRAILER = 'Co-authored-by: Codex <noreply@openai.com>';
 export async function simpleGitCommitCommand(args = [], opts = {}) {
     const root = await projectRoot();
@@ -16,17 +19,24 @@ export async function simpleGitCommitCommand(args = [], opts = {}) {
 export async function simpleGitCommit(root, { message = null, push = false } = {}) {
     if (!await isGitRepo(root))
         return { schema: 'sks.simple-git.v1', ok: false, reason: 'not_git_repo', root };
-    const before = await git(root, ['status', '--short']);
+    const [before, branch, head] = await Promise.all([
+        git(root, ['status', '--short']),
+        git(root, ['branch', '--show-current']),
+        git(root, ['rev-parse', '--short', 'HEAD'])
+    ]);
     const changed = statusLines(before.stdout);
     if (!changed.length)
         return { schema: 'sks.simple-git.v1', ok: false, reason: 'no_changes', root };
+    const localWorker = message
+        ? localWorkerSkipped('message_provided')
+        : await draftCommitMessageWithLocalWorker(root, changed, { push, branch: branch.stdout.trim(), head: head.stdout.trim() });
     const add = await git(root, ['add', '-A']);
     if (add.code !== 0)
         return failure(root, 'git_add_failed', before, add);
     const stagedCheck = await git(root, ['diff', '--cached', '--quiet']);
     if (stagedCheck.code === 0)
         return { schema: 'sks.simple-git.v1', ok: false, reason: 'no_staged_changes', root, changed };
-    const commitMessage = ensureCodexTrailer(message || buildCommitMessage(changed));
+    const commitMessage = ensureCodexTrailer(message || localWorker.message || buildCommitMessage(changed));
     const commit = await git(root, ['commit', '-m', commitTitle(commitMessage), '-m', commitBody(commitMessage)]);
     if (commit.code !== 0)
         return failure(root, 'git_commit_failed', before, commit);
@@ -46,7 +56,8 @@ export async function simpleGitCommit(root, { message = null, push = false } = {
         commit: commitSummary(commit),
         hash: hash.stdout.trim(),
         pushed: Boolean(push && pushResult?.code === 0),
-        push: pushResult ? { ok: pushResult.code === 0, stdout: pushResult.stdout.trim(), stderr: pushResult.stderr.trim() } : null
+        push: pushResult ? { ok: pushResult.code === 0, stdout: pushResult.stdout.trim(), stderr: pushResult.stderr.trim() } : null,
+        local_worker: localWorker.report
     });
 }
 function failure(root, reason, before, failed, extra = {}) {
@@ -77,6 +88,134 @@ function buildCommitMessage(changed = []) {
     const more = changed.length > 12 ? `\n- ...and ${changed.length - 12} more` : '';
     return `chore: update project changes\n\nSummary: ${summary}\n\nChanged files:\n${files}${more}`;
 }
+async function draftCommitMessageWithLocalWorker(root, changed, context) {
+    const disabled = String(process.env.SKS_SIMPLE_GIT_LOCAL_LLM || '').trim() === '0';
+    if (disabled)
+        return { message: null, report: localWorkerSkipped('disabled_by_SKS_SIMPLE_GIT_LOCAL_LLM') };
+    const config = await resolveOllamaWorkerConfig().catch((error) => null);
+    if (!config?.ok || config.enabled !== true) {
+        return {
+            message: null,
+            report: {
+                schema: 'sks.simple-git-local-worker.v1',
+                generated_at: nowIso(),
+                ok: false,
+                used: false,
+                enabled: config?.enabled === true,
+                provider: config?.provider || 'ollama',
+                model: config?.model || null,
+                worker_only: true,
+                parent_owned_git_mutation: true,
+                task: context.push ? 'commit-and-push-message-draft' : 'commit-message-draft',
+                blockers: config?.blockers || ['ollama_worker_config_unavailable']
+            }
+        };
+    }
+    const runId = sha256(`${nowIso()}:${context.branch}:${context.head}:${changed.join('\n')}`).slice(0, 12);
+    const workerDirRel = path.join('.git', 'sks-local-workers', 'simple-git', runId);
+    const slice = {
+        id: `simple-git-message-${runId}`,
+        role: 'collector',
+        domain: 'git',
+        description: [
+            'simple collect summarize git status for a commit message draft only',
+            'Do not run git commands. Do not choose whether to commit or push.',
+            'Return summary as a conventional commit title and proposed_changes as short body bullets.',
+            `Action: ${context.push ? 'commit-and-push' : 'commit'}`,
+            `Branch: ${context.branch || 'unknown'}`,
+            `HEAD before commit: ${context.head || 'unknown'}`,
+            'Changed status lines:',
+            ...changed.slice(0, 80)
+        ].join('\n')
+    };
+    const agent = {
+        id: 'simple_git_local_worker',
+        session_id: `simple-git-${runId}`,
+        slot_id: 'local-worker',
+        generation_index: 1,
+        persona_id: 'local_git_summarizer',
+        role: 'collector'
+    };
+    const result = await runOllamaAgent(agent, slice, {
+        missionId: `simple-git-${runId}`,
+        agentRoot: root,
+        cwd: root,
+        workerDirRel,
+        route: context.push ? '$Commit-And-Push' : '$Commit',
+        fastMode: true,
+        serviceTier: 'fast',
+        ollamaTimeoutMs: Number(process.env.SKS_SIMPLE_GIT_OLLAMA_TIMEOUT_MS || 15000)
+    }).catch((error) => ({
+        status: 'blocked',
+        summary: '',
+        findings: [],
+        proposed_changes: [],
+        artifacts: [],
+        blockers: [error instanceof Error ? error.message : String(error)]
+    }));
+    const message = result.status === 'done' ? localWorkerCommitMessage(result, changed) : null;
+    return {
+        message,
+        report: {
+            schema: 'sks.simple-git-local-worker.v1',
+            generated_at: nowIso(),
+            ok: result.status === 'done',
+            used: Boolean(message),
+            enabled: true,
+            provider: config.provider,
+            model: config.model,
+            worker_only: true,
+            parent_owned_git_mutation: true,
+            task: context.push ? 'commit-and-push-message-draft' : 'commit-message-draft',
+            artifacts: result.artifacts || [],
+            summary: result.summary || null,
+            blockers: result.blockers || [],
+            fallback: message ? null : 'deterministic_commit_message'
+        }
+    };
+}
+function localWorkerCommitMessage(result, changed) {
+    const title = normalizeCommitTitle(result.summary);
+    if (!title)
+        return null;
+    const bodyLines = [
+        'Summary: local Ollama worker drafted this message from git status; parent SKS performed all git mutations.',
+        '',
+        ...stringArray(result.proposed_changes || result.findings).slice(0, 8).map((line) => `- ${line}`),
+        ...(stringArray(result.proposed_changes || result.findings).length ? [] : changed.slice(0, 8).map((line) => `- ${line}`))
+    ];
+    return `${title}\n\n${bodyLines.join('\n')}`;
+}
+function normalizeCommitTitle(value) {
+    const raw = String(value || '').split(/\r?\n/)[0]?.trim() || '';
+    const stripped = raw.replace(/^["']|["']$/g, '').replace(/\s+/g, ' ').trim();
+    if (!stripped)
+        return '';
+    const conventional = /^[a-z][a-z0-9-]*(\([^)]+\))?:\s+\S/.test(stripped);
+    const title = conventional ? stripped : `chore: ${stripped.replace(/^(commit message|summary)\s*:\s*/i, '')}`;
+    return title.length > 96 ? title.slice(0, 93).trimEnd() + '...' : title;
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((line) => String(line || '').trim()).filter(Boolean) : [];
+}
+function localWorkerSkipped(reason) {
+    return {
+        message: null,
+        report: {
+            schema: 'sks.simple-git-local-worker.v1',
+            generated_at: nowIso(),
+            ok: true,
+            used: false,
+            enabled: false,
+            provider: 'ollama',
+            model: null,
+            worker_only: true,
+            parent_owned_git_mutation: true,
+            task: 'commit-message-draft',
+            blockers: [reason]
+        }
+    };
+}
 function ensureCodexTrailer(message = '') {
     const withoutDuplicate = String(message || '')
         .split(/\r?\n/)