sneakoscope 2.0.2 → 2.0.4

package/dist/core/codex-control/gpt-final-proof-pack.js

@@ -0,0 +1,120 @@
+import { nowIso, sha256 } from '../fsx.js';
+export const GPT_FINAL_PROOF_PACK_SCHEMA = 'sks.gpt-final-proof-pack.v1';
+export function buildGptFinalProofPack(input, opts = {}) {
+    const maxCriticalLogChars = Math.max(1000, Number(opts.maxCriticalLogChars || 6000));
+    const localOutputs = Array.isArray(input.local_outputs) ? input.local_outputs : [];
+    const candidatePatchEnvelopes = Array.isArray(input.candidate_patch_envelopes) ? input.candidate_patch_envelopes : [];
+    const verificationResults = Array.isArray(input.verification_results) ? input.verification_results : [];
+    const pack = {
+        schema: GPT_FINAL_PROOF_PACK_SCHEMA,
+        generated_at: nowIso(),
+        route: String(input.route || ''),
+        mission_id: String(input.mission_id || ''),
+        local_mode: String(input.local_mode || ''),
+        worker_count: localOutputs.length,
+        changed_files: sortedUnique([
+            ...candidatePatchEnvelopes.flatMap((envelope) => envelopeChangedFiles(envelope)),
+            ...localOutputs.flatMap((output) => Array.isArray(output?.changed_files) ? output.changed_files.map(String) : [])
+        ]),
+        local_output_summaries: localOutputs.map((output, index) => ({
+            worker_id: String(output?.worker_id || output?.agent_id || output?.id || `worker-${index + 1}`),
+            backend: String(output?.backend || 'local-llm'),
+            status: String(output?.status || 'unknown'),
+            summary: trim(String(output?.summary || ''), 600),
+            proof: trim(String(output?.proof || output?.verification?.status || ''), 600),
+            blocker_count: Array.isArray(output?.blockers) ? output.blockers.length : 0,
+            patch_envelope_count: Array.isArray(output?.patch_envelopes) ? output.patch_envelopes.length : output?.patch_envelope ? 1 : 0
+        })),
+        candidate_diff_sha256: sha256(String(input.candidate_diff || '')),
+        candidate_diff_tail: tail(String(input.candidate_diff || ''), maxCriticalLogChars),
+        candidate_patch_envelopes: candidatePatchEnvelopes.map((envelope, index) => summarizeEnvelope(envelope, index)),
+        verification_failures: verificationResults.filter((result) => result?.ok === false || result?.status === 'failed').map((result) => ({
+            id: String(result?.id || result?.patch_entry_id || result?.name || 'verification'),
+            status: String(result?.status || (result?.ok === false ? 'failed' : 'unknown')),
+            blockers: stringArray(result?.blockers || result?.violations)
+        })),
+        side_effect_ledger_summary: summarizeObject(input.side_effect_report),
+        mutation_ledger_summary: summarizeObject(input.mutation_ledger),
+        rollback_plan_summary: summarizeObject(input.rollback_plan),
+        conflict_map: buildConflictMap(candidatePatchEnvelopes),
+        critical_logs_tail: tail(JSON.stringify({
+            local_outputs: localOutputs.map((output) => ({
+                id: output?.worker_id || output?.agent_id || output?.id,
+                blockers: output?.blockers || [],
+                unverified: output?.unverified || []
+            })),
+            verification_results: verificationResults
+        }), maxCriticalLogChars),
+        token_budget_estimate: 0
+    };
+    return {
+        ...pack,
+        token_budget_estimate: estimateTokens(pack)
+    };
+}
+export function buildGptFinalLatencyBudgetReport(input) {
+    const workerCount = Math.max(0, Number(input.workerCount || 0));
+    const tokenBudgetEstimate = Math.max(0, Number(input.tokenBudgetEstimate || 0));
+    const capAdjustment = tokenBudgetEstimate > 8000 || workerCount > 20 ? 'reduce_local_parallelism_or_pack_size' : 'within_budget';
+    return {
+        schema: 'sks.gpt-final-latency-budget.v1',
+        generated_at: nowIso(),
+        worker_count: workerCount,
+        token_budget_estimate: tokenBudgetEstimate,
+        latency_ms: input.latencyMs ?? null,
+        cap_adjustment: capAdjustment,
+        ok: capAdjustment === 'within_budget'
+    };
+}
+function summarizeEnvelope(envelope, index) {
+    return {
+        id: String(envelope?.id || envelope?.patch_id || `patch-${index + 1}`),
+        agent_id: String(envelope?.agent_id || 'unknown'),
+        source: String(envelope?.source || 'local-llm'),
+        operations: Array.isArray(envelope?.operations) ? envelope.operations.length : 0,
+        write_paths: envelopeChangedFiles(envelope),
+        lease_id: envelope?.lease_id || envelope?.lease_proof?.lease_id || null,
+        rollback_ready: Boolean(envelope?.rollback_hint || envelope?.lease_proof?.rollback_node_id)
+    };
+}
+function envelopeChangedFiles(envelope) {
+    return Array.isArray(envelope?.operations) ? envelope.operations.map((operation) => String(operation?.path || '')).filter(Boolean) : [];
+}
+function buildConflictMap(envelopes) {
+    const owners = new Map();
+    for (const envelope of envelopes) {
+        const agent = String(envelope?.agent_id || 'unknown');
+        for (const file of envelopeChangedFiles(envelope))
+            owners.set(file, [...(owners.get(file) || []), agent]);
+    }
+    return [...owners.entries()]
+        .filter(([, agents]) => new Set(agents).size > 1)
+        .map(([file, agents]) => ({ file, agents: sortedUnique(agents) }));
+}
+function summarizeObject(value) {
+    if (!value || typeof value !== 'object')
+        return null;
+    return {
+        schema: value.schema || null,
+        ok: typeof value.ok === 'boolean' ? value.ok : null,
+        status: value.status || null,
+        blockers: stringArray(value.blockers).slice(0, 20),
+        keys: Object.keys(value).slice(0, 30)
+    };
+}
+function estimateTokens(value) {
+    return Math.ceil(JSON.stringify(value).length / 4);
+}
+function tail(value, max) {
+    return value.length <= max ? value : value.slice(value.length - max);
+}
+function trim(value, max) {
+    return value.length <= max ? value : value.slice(0, max);
+}
+function sortedUnique(values) {
+    return [...new Set(values.map(String).filter(Boolean))].sort();
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
+}
+//# sourceMappingURL=gpt-final-proof-pack.js.map

package/dist/core/codex-control/gpt-final-review-schema.js

@@ -0,0 +1,71 @@
+export const GPT_FINAL_ARBITER_RESULT_SCHEMA_ID = 'sks.gpt-final-arbiter-result.v1';
+export const GPT_FINAL_ARBITER_INPUT_SCHEMA = 'sks.gpt-final-arbiter-input.v1';
+export const gptFinalArbiterResultSchema = {
+    type: 'object',
+    required: [
+        'schema',
+        'status',
+        'summary',
+        'gpt_review_findings',
+        'accepted_patch_envelopes',
+        'modified_patch_envelopes',
+        'rejected_patch_envelopes',
+        'required_followup_work',
+        'verification_plan',
+        'rollback_notes',
+        'blockers',
+        'confidence'
+    ],
+    properties: {
+        schema: { const: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID },
+        status: { enum: ['approved', 'modified', 'rejected', 'needs_more_work'] },
+        summary: { type: 'string' },
+        gpt_review_findings: { type: 'array', items: { type: 'object' } },
+        accepted_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        modified_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        rejected_patch_envelopes: { type: 'array', items: { type: 'object' } },
+        required_followup_work: { type: 'array', items: { type: 'object' } },
+        verification_plan: { type: 'array', items: { type: 'string' } },
+        rollback_notes: { type: 'array', items: { type: 'string' } },
+        blockers: { type: 'array', items: { type: 'string' } },
+        confidence: { enum: ['low', 'medium', 'high'] }
+    },
+    additionalProperties: true
+};
+export function normalizeGptFinalArbiterResult(value) {
+    const status = normalizeStatus(value?.status);
+    return {
+        schema: GPT_FINAL_ARBITER_RESULT_SCHEMA_ID,
+        status,
+        summary: String(value?.summary || defaultSummary(status)),
+        gpt_review_findings: array(value?.gpt_review_findings),
+        accepted_patch_envelopes: array(value?.accepted_patch_envelopes),
+        modified_patch_envelopes: array(value?.modified_patch_envelopes),
+        rejected_patch_envelopes: array(value?.rejected_patch_envelopes),
+        required_followup_work: array(value?.required_followup_work),
+        verification_plan: stringArray(value?.verification_plan),
+        rollback_notes: stringArray(value?.rollback_notes),
+        blockers: stringArray(value?.blockers),
+        confidence: normalizeConfidence(value?.confidence)
+    };
+}
+function normalizeStatus(value) {
+    return value === 'approved' || value === 'modified' || value === 'rejected' || value === 'needs_more_work'
+        ? value
+        : 'needs_more_work';
+}
+function normalizeConfidence(value) {
+    return value === 'low' || value === 'medium' || value === 'high' ? value : 'medium';
+}
+function array(value) {
+    return Array.isArray(value) ? value : [];
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map((entry) => String(entry || '').trim()).filter(Boolean) : [];
+}
+function defaultSummary(status) {
+    return status === 'approved' || status === 'modified'
+        ? 'GPT final arbiter accepted the candidate result.'
+        : 'GPT final arbiter did not approve the candidate result.';
+}
+//# sourceMappingURL=gpt-final-review-schema.js.map

package/dist/core/commands/local-model-command.js

@@ -26,7 +26,7 @@ function normalizeLocalModelAction(value) {
     return text;
 }
 async function enable(args) {
-    const model = readOption(args, '--model', args[0] || '');
+    const model = readOption(args, '--model', firstPositional(args) || '');
     const baseUrl = readOption(args, '--base-url', '');
     const think = readBoolFlag(args, '--think', '--no-think');
     const patch = { enabled: true, provider: 'ollama' };
@@ -102,4 +102,19 @@ function readBoolFlag(args, trueName, falseName) {
         return false;
     return null;
 }
+function firstPositional(args = []) {
+    for (let i = 0; i < args.length; i += 1) {
+        const arg = String(args[i] || '');
+        if (arg === '--model' || arg === '--base-url') {
+            if (args[i + 1] && !String(args[i + 1]).startsWith('--'))
+                i += 1;
+            continue;
+        }
+        if (arg.startsWith('--model=') || arg.startsWith('--base-url='))
+            continue;
+        if (!arg.startsWith('--'))
+            return arg;
+    }
+    return '';
+}
 //# sourceMappingURL=local-model-command.js.map

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' || 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) {
@@ -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,12 @@ 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 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 +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'),
@@ -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.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/)