sneakoscope 2.0.1 → 2.0.4

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

@@ -2,8 +2,10 @@ import path from 'node:path';
 import { createMission, findLatestMission, loadMission } from '../mission.js';
 import { readJson, sksRoot } 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';
 const NARUTO_RESULT_SCHEMA = 'sks.naruto-command-result.v1';
 const NARUTO_ROUTE = '$Naruto';
@@ -32,7 +34,9 @@ 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 localWorker = await resolveNarutoLocalWorkerMode(parsed);
+    const schedulerBackend = localWorker.auto_select_eligible ? 'ollama' : parsed.backend;
+    const safe = systemSafeNarutoConcurrency({ backend: schedulerBackend });
     const activeSlots = Math.max(1, Math.min(roster.agent_count, parsed.concurrency || safe.cap));
     const mission = await createMission(root, { mode: 'naruto', prompt: parsed.prompt });
     const ledgerRoot = path.join(mission.dir, 'agents');
@@ -75,6 +79,11 @@ async function narutoRun(parsed) {
         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 +95,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 +109,7 @@ 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 },
+        local_worker: localWorkerSummary,
         proof: result.proof?.status || 'missing',
         run: result,
         zellij: null
@@ -116,6 +127,19 @@ async function narutoRun(parsed) {
             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);
@@ -149,7 +173,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' }
@@ -171,18 +195,23 @@ 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 };
 }
 function clampClones(value) {
     if (!Number.isFinite(value) || value < 1)
@@ -212,6 +241,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 +265,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' ? '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) {
@@ -346,6 +346,12 @@ function safeRouteExecutionArgs(route, prompt, { auto = false } = {}) {
         return ['wiki', 'refresh', '--json'];
     if (route.command === '$Fast-Mode')
         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 = '') {
@@ -372,6 +378,32 @@ function fastModeActionFromPrompt(prompt = '') {
         return 'clear';
     return 'status';
 }
+function localModelActionFromPrompt(prompt = '') {
+    const text = String(prompt || '');
+    const lower = text.toLowerCase();
+    if (/\$with-local-llm-off\b/.test(lower))
+        return 'disable';
+    if (/\$with-local-llm-on\b/.test(lower))
+        return 'enable';
+    const routeMatch = /\$with-local-llm\b/i.exec(text);
+    if (!routeMatch)
+        return 'status';
+    const afterRoute = text
+        .slice(routeMatch.index + routeMatch[0].length)
+        .replace(/^[\s:=\-]+/, '')
+        .trimStart()
+        .toLowerCase();
+    const token = afterRoute.match(/^[^\s?!.,;:()"'`]+/)?.[0] || '';
+    if (['off', 'disable', 'disabled', '끄기', '꺼', '꺼줘'].includes(token) || token.startsWith('끄') || token.startsWith('꺼'))
+        return 'disable';
+    if (['on', 'enable', 'enabled', '켜기', '켜', '켜줘'].includes(token) || token.startsWith('켜'))
+        return 'enable';
+    if (['model', 'set-model', 'set'].includes(token))
+        return 'set-model';
+    if (['status', 'state', 'check', '확인', '상태'].includes(token))
+        return 'status';
+    return 'status';
+}
 function destructiveDbPrompt(prompt = '') {
     return /\b(drop|truncate|delete\s+from|update\s+\w+\s+set|reset|db\s+push|disable\s+rls)\b/i.test(prompt);
 }

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

@@ -26,7 +26,11 @@ export async function team(args = []) {
     const jsonOutput = flag(args, '--json');
     const mock = flag(args, '--mock');
     const openZellij = !mock && !jsonOutput && !flag(args, '--no-open-zellij') && !flag(args, '--no-zellij');
-    const cleanCreateArgs = args.filter((arg) => !['--open-zellij', '--zellij-open', '--no-open-zellij', '--no-zellij', '--no-attach', '--mock'].includes(String(arg)));
+    const useOllama = flag(args, '--ollama') || flag(args, '--local-model');
+    const noOllama = flag(args, '--no-ollama') || flag(args, '--no-local-model');
+    const ollamaModel = readFlagValue(args, '--ollama-model', readFlagValue(args, '--local-model-model', '')) || null;
+    const ollamaBaseUrl = readFlagValue(args, '--ollama-base-url', readFlagValue(args, '--local-model-base-url', '')) || null;
+    const cleanCreateArgs = stripTeamCreateControlArgs(args);
     const opts = parseTeamCreateArgs(cleanCreateArgs);
     const { prompt, agentSessions, roleCounts, roster } = opts;
     const targetActiveSlots = readBoundedIntegerFlag(args, '--target-active-slots', roster.bundle_size, 1, 20);
@@ -40,7 +44,7 @@ export async function team(args = []) {
     const dryRunPatches = flag(args, '--dry-run-patches') || flag(args, '--dryrun-patches');
     const maxWriteAgents = readBoundedIntegerFlag(args, '--max-write-agents', Math.min(roster.bundle_size, 5), 1, 20);
     if (!prompt) {
-        console.error('Usage: sks team "task" [20:agents] [executor:5 reviewer:6 user:1] [--agents N] [--work-items N] [--target-active-slots N] [--profile NAME] [--write-mode off|proof-safe|parallel|serial] [--apply-patches] [--no-open-zellij] [--json] [--mock]');
+        console.error('Usage: sks team "task" [20:agents] [executor:5 reviewer:6 user:1] [--agents N] [--work-items N] [--target-active-slots N] [--profile NAME] [--write-mode off|proof-safe|parallel|serial] [--apply-patches] [--ollama|--no-ollama] [--no-open-zellij] [--json] [--mock]');
         process.exitCode = 1;
         return;
     }
@@ -111,6 +115,10 @@ export async function team(args = []) {
         applyPatches,
         dryRunPatches,
         maxWriteAgents,
+        ollamaEnabled: useOllama && !noOllama,
+        noOllama,
+        ollamaModel,
+        ollamaBaseUrl,
         routeCommand: 'sks team',
         routeBlackboxKind: 'actual_team_command'
     });
@@ -198,6 +206,27 @@ export function parseTeamCreateArgs(args) {
     const normalized = normalizeTeamSpec({ agentSessions: spec.agentSessions, roleCounts: spec.roleCounts, prompt });
     return { prompt, agentSessions: normalized.agentSessions, roleCounts: normalized.roleCounts, roster: normalized.roster };
 }
+function stripTeamCreateControlArgs(args = []) {
+    const booleanFlags = new Set([
+        '--open-zellij', '--zellij-open', '--no-open-zellij', '--no-zellij', '--no-attach',
+        '--mock', '--ollama', '--local-model', '--no-ollama', '--no-local-model'
+    ]);
+    const valueFlags = new Set(['--ollama-model', '--local-model-model', '--ollama-base-url', '--local-model-base-url']);
+    const out = [];
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = String(args[i]);
+        if (booleanFlags.has(arg))
+            continue;
+        if (valueFlags.has(arg)) {
+            i += 1;
+            continue;
+        }
+        if ([...valueFlags].some((flagName) => arg.startsWith(flagName + '=')))
+            continue;
+        out.push(args[i]);
+    }
+    return out;
+}
 export function buildTeamPlan(id, prompt, opts = {}) {
     const spec = normalizeTeamSpec({ ...opts, prompt });
     const { agentSessions, roleCounts, roster } = spec;

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);
@@ -47,10 +48,18 @@ export function buildDoctorReadinessMatrix(input = {}) {
         warnings.add('codex_app_needs_setup_optional_for_cli');
     if (input.codex_app_ui?.fast_selector === 'manual_action_required')
         warnings.add('codex_app_fast_selector_manual_action_required');
+    if (input.codex_app_ui?.requires_confirmation === true)
+        blockers.add('codex_app_fast_ui_repair_requires_confirmation');
     if (input.codex_app_ui?.fast_selector === 'repaired')
         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 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;
@@ -58,6 +67,8 @@ export function buildDoctorReadinessMatrix(input = {}) {
     const nextActions = normalizeList(input.operator_actions || codexConfig.operator_actions);
     if (!nextActions.length && blockers.size)
         nextActions.push('Run `sks doctor --fix`, then run `sks mad repair-config --apply` if config-load still fails.');
+    if (input.codex_app_ui?.requires_confirmation === true)
+        nextActions.push(input.codex_app_ui.next_action || 'Run `sks doctor --fix --repair-codex-app-ui` after reviewing the repair plan.');
     if (!zellijReadyForInteractive)
         nextActions.push('Install Zellij for `sks --mad` and interactive lane UI. On macOS: `brew install zellij`.');
     return {
@@ -88,6 +99,14 @@ 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 || input.local_model?.provider || 'ollama',
+            local_model: input.local_collaboration?.local_model || input.local_model?.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
+        },
         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'),
@@ -111,6 +113,9 @@ const FIXTURES = Object.freeze({
     'route-fast-mode': fixture('execute', 'sks fast-mode status --json', [], 'pass'),
     '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.1';
+export const PACKAGE_VERSION = '2.0.4';
 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/)

package/dist/core/hooks-runtime.js

@@ -1036,7 +1036,7 @@ function updateOfferThrottleMs() {
     return 8 * 60 * 1000;
 }
 function sksUpdateInstallCommand(version) {
-    return `npm i -g sneakoscope@${version} --registry https://registry.npmjs.org/`;
+    return `sks update now --version ${version}`;
 }
 function copyStableUpdateChoiceText(latest, current = null) {
     const installed = current ? `installed ${current}, latest ${latest}` : `latest ${latest}`;

package/dist/core/init.js

@@ -1024,6 +1024,8 @@ export async function installSkills(root) {
         'fast-mode': `---\nname: fast-mode\ndescription: Dollar-command route for $Fast-Mode, $Fast-On, and $Fast-Off project-local Fast mode toggles.\n---\n\nUse when the user invokes $Fast-Mode, $Fast-On, $Fast-Off, or asks to turn SKS Fast mode on/off for dollar commands. Prefer \`sks fast-mode on|off|status|clear --json\`. The command writes only .sneakoscope/state/fast-mode.json in the active project. Explicit runtime flags still win: \`--fast\`, \`--no-fast\`, and \`--service-tier standard|fast\` override the saved preference for that run. Finish with a short status and Honest Mode; do not start Team or broad implementation for a toggle-only request.\n`,
         'fast-on': `---\nname: fast-on\ndescription: Alias for $Fast-On project-local SKS Fast mode enablement.\n---\n\nUse the same rules as fast-mode. Run or instruct \`sks fast-mode on --json\`, then report the active state, state file, and the fact that explicit per-run flags still override the saved preference.\n`,
         'fast-off': `---\nname: fast-off\ndescription: Alias for $Fast-Off project-local SKS Fast mode disablement.\n---\n\nUse the same rules as fast-mode. Run or instruct \`sks fast-mode off --json\`, then report the active state, state file, and the fact that explicit per-run flags still override the saved preference.\n`,
+        'with-local-llm-on': `---\nname: with-local-llm-on\ndescription: Dollar-command route for $with-local-llm-on local Ollama worker enablement.\n---\n\nUse when the user invokes $with-local-llm-on or asks to enable the optional local Ollama worker backend. Prefer \`sks with-local-llm on --json\`. The command writes the machine-local config at \`~/.sneakoscope/local-model.json\`. Default off means SKS stays GPT-only until this command enables local workers. Enabled mode only lets policy-eligible simple code patch-envelope or read-only collection worker slices use Ollama; GPT/Codex still owns strategy, planning, design, review, verification, safety, and integration. \`--no-ollama\` and \`SKS_OLLAMA_WORKERS=0\` still force local workers off for a run. Finish with a short status and Honest Mode; do not start Team for a toggle-only request.\n`,
+        'with-local-llm-off': `---\nname: with-local-llm-off\ndescription: Dollar-command route for $with-local-llm-off local Ollama worker disablement.\n---\n\nUse when the user invokes $with-local-llm-off or asks to disable the optional local Ollama worker backend. Prefer \`sks with-local-llm off --json\`. The command writes the machine-local config at \`~/.sneakoscope/local-model.json\`. Disabled mode keeps SKS GPT-only by default. Strategy, planning, design, review, verification, safety, and integration remain GPT/Codex-owned regardless of this toggle. Finish with a short status and Honest Mode; do not start Team for a toggle-only request.\n`,
         'wiki': `---\nname: wiki\ndescription: Dollar-command route for $Wiki TriWiki refresh, pack, validate, and prune commands.\n---\n\nUse for $Wiki or Korean wiki-refresh requests. Refresh/update/갱신: run sks wiki refresh, then validate .sneakoscope/wiki/context-pack.json. Pack: run sks wiki pack, then validate. Prune/clean/정리: use sks wiki refresh --prune, or sks wiki prune --dry-run for inspection. Report claims, anchors, trust, attention.use_first/hydrate_first, validation, and blockers. Do not start ambiguity-gated implementation, subagents, or unrelated work.\n`,
         'team': `---\nname: team\ndescription: SKS Team orchestration for $Team/code work; $From-Chat-IMG is the explicit chat-image alias.\n---\n\nUse for $Team/code work. Auto-seal the route contract from prompt, TriWiki/current-code defaults, and conservative policy; do not surface a prequestion sheet. Read pipeline-plan.json or run sks pipeline plan to see the runtime lane, kept/skipped stages, and verification before implementation. Write team-roster.json; team-gate.json needs team_roster_confirmed=true. executor:N means N native analysis agents, N debate voices, then fresh N executors. ${MIN_TEAM_REVIEW_POLICY_TEXT} After consensus, compile team-graph.json, team-runtime-tasks.json, team-decomposition-report.json, and team-inbox/ so worker handoff uses concrete runtime task ids with role/path/domain/lane hints. Refresh/validate TriWiki before debate, implementation, review, and final; consume attention.use_first and hydrate attention.hydrate_first before risky decisions. ${outcomeRubricPolicyText()} ${speedLanePolicyText()} ${solutionScoutPolicyText('fix this broken behavior')} ${skillDreamPolicyText()} Log events and use sks team message for bounded inter-agent communication in transcript/lane panes. Color-coded Zellij lanes distinguish overview/native-analysis/planning/execution/review/safety sessions in one Zellij window using split panes when Zellij is available. $Team/$team plus sks --mad uses the MAD-SKS permission gate module: user-authorized target-project scopes such as files, shell, packages, services, network, browser/Computer Use, generated assets, file permissions, migrations, normal DB writes, Supabase MCP writes, direct SQL, and schema cleanup are open only for the active invocation; catastrophic wipe/all-row/project-management, credential exfiltration, persistent security weakening, and unrequested fallback guards remain. End with cleanup-zellij or a cleanup event so follow panes show cleanup and stop; pass team-session-cleanup.json, then reflection and Honest Mode. Parent integrates/verifies.\n\n${chatCaptureIntakeText()}\n`,
         'from-chat-img': `---\nname: from-chat-img\ndescription: Explicit $From-Chat-IMG Team alias for chat screenshot plus attachment analysis.\n---\n\nUse only for From-Chat-IMG/$From-Chat-IMG. It enters the normal Team pipeline. Treat uploads as chat screenshot plus originals. For web/browser/webapp targets use Codex Chrome Extension first; for native Mac/non-web app surfaces use Codex Computer Use visual inspection when available. List requirements first, match regions to attachments with confidence, write ${FROM_CHAT_IMG_COVERAGE_ARTIFACT}, ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT}, ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT}, and ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT}, then continue Team gates, review, reflection, and Honest Mode. ${CODEX_WEB_VERIFICATION_POLICY} ${CODEX_COMPUTER_USE_ONLY_POLICY} The ledger must account for every visible customer request, screenshot image region, and separate attachment; ${FROM_CHAT_IMG_CHECKLIST_ARTIFACT} must have a checked item for each request, image-region/attachment match, work item, scoped QA-LOOP, and verification step; ${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT} stores temporary TriWiki-backed session context with expires_after_sessions=${FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS}. ${FROM_CHAT_IMG_QA_LOOP_ARTIFACT} must prove QA-LOOP ran over the exact customer-request work-order range after implementation, with every work item covered, post-fix verification complete, and zero unresolved findings. team-gate.json cannot pass From-Chat-IMG completion until unresolved_items is empty, every checklist box is checked, and scoped_qa_loop_completed=true.\n`,