sneakoscope 2.0.1 → 2.0.4

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

@@ -8,6 +8,7 @@ import { assertAgentSessionGenerationsClosed } from './agent-session-generation.
 import { readZellijLaneSupervisor } from './zellij-lane-supervisor.js';
 import { writeFakeRealProofPolicyReport } from '../proof/fake-real-proof-policy.js';
 import { buildRuntimeTruthMatrix, writeRuntimeTruthMatrix } from '../proof/runtime-truth-matrix.js';
+import { evaluateLocalCollaborationFinalGate, localCollaborationParticipated, resolveLocalCollaborationPolicy } from '../local-llm/local-collaboration-policy.js';
 export async function writeAgentProofEvidence(root, input) {
     const lifecycle = await assertAllAgentSessionsClosed(root);
     const terminal = await assertAgentTerminalSessionsClosed(root);
@@ -28,6 +29,18 @@ export async function writeAgentProofEvidence(root, input) {
     const patchRollbackProof = await readJson(path.join(root, 'agent-patch-rollback-proof.json'), null);
     const patchProof = await readJson(path.join(root, 'agent-patch-proof.json'), null);
     const patchSwarm = input.patchSwarm || await readJson(path.join(root, 'agent-patch-swarm-runtime.json'), null);
+    const localCollaborationPolicy = input.localCollaborationPolicy || await readJson(path.join(root, 'local-collaboration-policy.json'), null) || resolveLocalCollaborationPolicy();
+    const gptFinalArbiter = input.gptFinalArbiter || await readJson(path.join(root, 'gpt-final-arbiter', 'gpt-final-arbiter.json'), null);
+    const localParticipated = localCollaborationParticipated(input.results || []) || Number(gptFinalArbiter?.local_outputs_count || 0) > 0;
+    const finalGptPatchStage = input.finalGptPatchStage || null;
+    const localFinalGate = gptFinalArbiter?.final_gate || evaluateLocalCollaborationFinalGate({
+        policy: localCollaborationPolicy,
+        localParticipated,
+        gptFinalStatus: gptFinalArbiter?.result?.status || null,
+        gptFinalAvailable: Boolean(gptFinalArbiter),
+        gptFinalBackend: gptFinalArbiter?.backend || null,
+        applyPatches: parallelWritePolicy?.apply_patches === true
+    });
     const nativeCliSessionProof = input.nativeCliSessionProof || await readJson(path.join(root, 'native-cli-session-proof.json'), null);
     const noSubagentScalingPolicy = input.noSubagentScalingPolicy || await readJson(path.join(root, 'no-subagent-scaling-policy.json'), null);
     const fastModePropagation = input.fastModePropagation || await readJson(path.join(root, 'fast-mode-propagation-proof.json'), null);
@@ -161,6 +174,9 @@ export async function writeAgentProofEvidence(root, input) {
         ...(patchSwarm && !patchApplyOk ? ['patch_apply_not_ok'] : []),
         ...(patchSwarm && !patchVerificationOk ? ['patch_verification_not_ok'] : []),
         ...(patchSwarm && !patchRollbackOk ? ['patch_rollback_not_ok'] : []),
+        ...(localParticipated && localFinalGate.ok !== true ? localFinalGate.blockers || ['gpt_final_arbiter_gate_not_ok'] : []),
+        ...(localParticipated && gptFinalArbiter?.ok !== true ? gptFinalArbiter?.blockers || ['gpt_final_arbiter_not_ok'] : []),
+        ...(localParticipated && finalGptPatchStage?.ok === false ? finalGptPatchStage.blockers || ['final_gpt_patch_stage_not_ok'] : []),
         ...agentChangedFileLeaseViolations(input.results || [], input.partition?.leases || [])
     ];
     const evidence = {
@@ -197,6 +213,15 @@ export async function writeAgentProofEvidence(root, input) {
         parallel_write_apply_patches: parallelWritePolicy?.apply_patches === true,
         parallel_write_dry_run_patches: parallelWritePolicy?.dry_run_patches === true,
         parallel_write_max_write_agents: Number(parallelWritePolicy?.max_write_agents || 0),
+        local_collaboration_policy: 'local-collaboration-policy.json',
+        local_collaboration_mode: localCollaborationPolicy.mode || null,
+        local_collaboration_participated: localParticipated,
+        gpt_final_arbiter: gptFinalArbiter ? 'gpt-final-arbiter/gpt-final-arbiter.json' : null,
+        gpt_final_status: gptFinalArbiter?.result?.status || (localParticipated ? 'missing' : 'not_required_no_local_outputs'),
+        gpt_final_backend: gptFinalArbiter?.backend || null,
+        gpt_final_patch_source: finalGptPatchStage?.final_patch_source || (localParticipated ? 'blocked' : 'not_applicable'),
+        gpt_final_gate_ok: localFinalGate.ok === true,
+        gpt_final_gate: localFinalGate,
         patch_swarm_runtime: patchSwarm ? 'agent-patch-swarm-runtime.json' : null,
         patch_queue: patchSwarm ? 'agent-patch-queue.json' : null,
         patch_queue_events: patchSwarm ? 'agent-patch-queue-events.jsonl' : null,
@@ -329,6 +354,7 @@ export async function writeAgentProofEvidence(root, input) {
             'strategy-gate.json': strategyGate,
             'agent-patch-proof.json': patchProof,
             'agent-patch-swarm-runtime.json': patchSwarm,
+            'gpt-final-arbiter/gpt-final-arbiter.json': gptFinalArbiter,
             'native-cli-session-proof.json': nativeCliSessionProof,
             'no-subagent-scaling-policy.json': noSubagentScalingPolicy,
             'fast-mode-propagation-proof.json': fastModePropagation

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

@@ -29,7 +29,7 @@ export function systemSafeNarutoConcurrency(opts = {}) {
     const freeGb = freeBytes / (1024 * 1024 * 1024);
     const totalGb = totalBytes / (1024 * 1024 * 1024);
     const backend = String(opts.backend || 'codex-sdk');
-    const heavy = backend === 'codex-sdk' || backend === 'zellij' || backend === 'process';
+    const heavy = backend === 'codex-sdk' || backend === 'zellij' || backend === 'process' || backend === 'ollama';
     const ceiling = MAX_NARUTO_AGENT_COUNT;
     // macOS reports very low freemem while reclaimable memory is still available, so
     // budget against a total-memory-derived floor rather than the instantaneous free.

package/dist/core/agents/agent-runner-ollama.js

@@ -0,0 +1,411 @@
+import path from 'node:path';
+import { nowIso, sha256, writeJsonAtomic } from '../fsx.js';
+import { loadTriWikiRuntimeContext, triWikiContextBlock, triWikiProofRecord } from '../triwiki-runtime.js';
+import { validateAgentWorkerResult } from './agent-worker-pipeline.js';
+import { normalizeAgentPatchEnvelope } from './agent-patch-schema.js';
+import { resolveOllamaWorkerConfig } from './ollama-worker-config.js';
+export const OLLAMA_WORKER_POLICY_SCHEMA = 'sks.ollama-worker-policy.v1';
+export const OLLAMA_WORKER_REQUEST_SCHEMA = 'sks.ollama-worker-request.v1';
+export const OLLAMA_WORKER_RESPONSE_SCHEMA = 'sks.ollama-worker-response.v1';
+export async function runOllamaAgent(agent, slice, opts = {}) {
+    const root = path.resolve(opts.agentRoot || opts.cwd || process.cwd());
+    const workerDirRel = String(opts.workerDirRel || agent.session_artifact_dir || path.join('sessions', String(agent.id || 'ollama-worker'), 'worker'));
+    const workerDir = path.join(root, workerDirRel);
+    const triwikiContext = await loadTriWikiRuntimeContext(root);
+    const config = await resolveOllamaWorkerConfig({
+        backend: 'ollama',
+        ollamaEnabled: opts.ollamaEnabled === true || opts.ollama_enabled === true,
+        model: opts.ollamaModel || opts.ollama_model || null,
+        baseUrl: opts.ollamaBaseUrl || opts.ollama_base_url || null,
+        keepAlive: opts.ollamaKeepAlive || opts.ollama_keep_alive || null,
+        timeoutMs: Number(opts.ollamaTimeoutMs || opts.ollama_timeout_ms || 0) || null,
+        temperature: Number(opts.ollamaTemperature || opts.ollama_temperature || 0),
+        think: typeof opts.ollamaThink === 'boolean' ? opts.ollamaThink
+            : typeof opts.ollama_think === 'boolean' ? opts.ollama_think
+                : null
+    });
+    const policy = classifyOllamaWorkerSlice(slice, { route: opts.route, agent });
+    await writeJsonAtomic(path.join(workerDir, 'ollama-worker-config.json'), config);
+    await writeJsonAtomic(path.join(workerDir, 'ollama-worker-policy.json'), policy);
+    await writeJsonAtomic(path.join(workerDir, 'ollama-triwiki-context.json'), buildOllamaTriWikiArtifact(triwikiContext));
+    if (!config.ok || !policy.ok) {
+        return validateAgentWorkerResult(blockedResult(agent, slice, opts, [...config.blockers, ...policy.blockers], [
+            path.join(workerDirRel, 'ollama-worker-config.json'),
+            path.join(workerDirRel, 'ollama-worker-policy.json'),
+            path.join(workerDirRel, 'ollama-triwiki-context.json')
+        ]));
+    }
+    const requestId = `ollama:${sha256(`${nowIso()}:${agent.session_id || agent.id}:${slice?.id || ''}`).slice(0, 16)}`;
+    const request = buildOllamaGenerateRequest(agent, slice, opts, config, requestId, triwikiContext);
+    await writeJsonAtomic(path.join(workerDir, 'ollama-request.json'), {
+        schema: OLLAMA_WORKER_REQUEST_SCHEMA,
+        generated_at: nowIso(),
+        request_id: requestId,
+        endpoint: `${config.base_url}/api/generate`,
+        model: config.model,
+        keep_alive: config.keep_alive,
+        stream: false,
+        think: config.think,
+        policy: 'worker_only_no_strategy_planning_design',
+        triwiki_context: triWikiProofRecord(triwikiContext),
+        stack_current_docs_required: true,
+        prompt_sha256: sha256(request.prompt)
+    });
+    const response = await callOllamaGenerate(config, request)
+        .catch((error) => ({ ok: false, error: error instanceof Error ? error.message : String(error) }));
+    const workerText = response.ok === true ? extractOllamaWorkerText(response.data) : { text: '', source: 'empty' };
+    await writeJsonAtomic(path.join(workerDir, 'ollama-response.json'), {
+        schema: OLLAMA_WORKER_RESPONSE_SCHEMA,
+        generated_at: nowIso(),
+        request_id: requestId,
+        ok: response.ok === true,
+        model: config.model,
+        response_sha256: response.ok === true ? sha256(workerText.text) : null,
+        response_source: response.ok === true ? workerText.source : null,
+        data: response.ok === true ? safeResponseData(response.data) : null,
+        error: response.ok === true ? null : response.error
+    });
+    if (response.ok !== true) {
+        return validateAgentWorkerResult(blockedResult(agent, slice, opts, ['ollama_generate_failed', String(response.error || 'unknown_error')], [
+            path.join(workerDirRel, 'ollama-triwiki-context.json'),
+            path.join(workerDirRel, 'ollama-request.json'),
+            path.join(workerDirRel, 'ollama-response.json')
+        ]));
+    }
+    const parsed = parseWorkerJson(workerText.text);
+    if (!parsed.ok) {
+        return validateAgentWorkerResult(blockedResult(agent, slice, opts, ['ollama_worker_json_parse_failed'], [
+            path.join(workerDirRel, 'ollama-triwiki-context.json'),
+            path.join(workerDirRel, 'ollama-request.json'),
+            path.join(workerDirRel, 'ollama-response.json')
+        ]));
+    }
+    const patchEnvelopes = normalizeOllamaPatchEnvelopes(parsed.value, agent, slice, opts, requestId);
+    const changedFiles = [...new Set(patchEnvelopes.flatMap((envelope) => envelope.operations.map((operation) => operation.path)))];
+    const writePaths = collectWritePaths(slice, opts);
+    return validateAgentWorkerResult({
+        mission_id: String(opts.missionId || opts.mission_id || ''),
+        agent_id: String(agent.id || 'ollama-worker'),
+        session_id: String(agent.session_id || ''),
+        persona_id: String(agent.persona_id || agent.id || 'ollama-worker'),
+        task_slice_id: String(slice?.id || ''),
+        status: writePaths.length > 0 && patchEnvelopes.length === 0 ? 'blocked' : 'done',
+        backend: 'ollama',
+        summary: String(parsed.value.summary || parsed.value.result || 'Ollama local worker completed.'),
+        findings: [
+            'ollama local worker executed through /api/generate',
+            'triwiki context consulted before local worker prompt',
+            ...stringArray(parsed.value.findings)
+        ],
+        proposed_changes: stringArray(parsed.value.proposed_changes || parsed.value.proposedChanges),
+        changed_files: changedFiles,
+        lease_compliance: { ok: true, violations: [] },
+        artifacts: [
+            path.join(workerDirRel, 'ollama-worker-config.json'),
+            path.join(workerDirRel, 'ollama-worker-policy.json'),
+            path.join(workerDirRel, 'ollama-triwiki-context.json'),
+            path.join(workerDirRel, 'ollama-request.json'),
+            path.join(workerDirRel, 'ollama-response.json')
+        ],
+        blockers: writePaths.length > 0 && patchEnvelopes.length === 0 ? ['ollama_no_patch_envelopes_for_write_task'] : [],
+        confidence: 'model_authored_local',
+        handoff_notes: 'Local Ollama worker produced worker JSON; parent SKS remains responsible for merge, apply, verification, and rollback.',
+        unverified: [
+            'local_model_output_not_strategy_or_verification_authority',
+            ...(triwikiContext.present ? [] : ['triwiki_context_missing_parent_should_refresh_with_context7_or_official_docs_before_relying_on_local_worker'])
+        ],
+        writes: changedFiles,
+        ...(patchEnvelopes.length ? { patch_envelopes: patchEnvelopes } : {}),
+        model_authored_patch_envelopes: patchEnvelopes.length > 0,
+        fixture_patch_envelopes: false,
+        source_intelligence_refs: agent.source_intelligence_refs || opts.source_intelligence_refs || null,
+        goal_mode_ref: agent.goal_mode_ref || opts.goal_mode_ref || null,
+        verification: { status: 'passed', checks: ['ollama-api-generate', 'ollama-worker-policy', 'triwiki-runtime-context', 'agent-patch-envelope-schema'] },
+        recursion_guard: { ok: true, violations: [] }
+    });
+}
+export function classifyOllamaWorkerSlice(slice, input = {}) {
+    const writePaths = collectWritePaths(slice, {});
+    const text = [
+        input.route,
+        input.agent?.role,
+        input.agent?.persona_id,
+        slice?.role,
+        slice?.domain,
+        slice?.title,
+        slice?.description,
+        ...(Array.isArray(slice?.target_paths) ? slice.target_paths : [])
+    ].map((value) => String(value || '')).join('\n');
+    const bannedRole = /(?:^|\b)(architect|verifier|safety|integrator|schema|release|ux|db)(?:\b|$)/i.test(String(input.agent?.role || slice?.role || ''));
+    const collection = /\b(collect|gather|extract|inventory|list|scan|grep|tail|summarize|catalog)\b|수집|추출|목록|스캔|인벤토리/i.test(text);
+    const coding = /\b(code|implement|patch|write|edit|fix|mechanical|simple)\b|코드|작성|수정|구현|패치|단순/i.test(text);
+    const banned = /\b(strategy|strategize|planning|plan|architecture|architect|design|review|verify|verification|safety|risk|consensus|debate|orchestrate|policy|decide|decision|migration|database|schema)\b|전략|기획|설계|디자인|검증|리뷰|안전|위험|합의|토론|결정|마이그레이션|데이터베이스/i.test(text);
+    const allowed = !bannedRole && !banned && (writePaths.length > 0 || collection || coding);
+    const blockers = [
+        ...(allowed ? [] : ['ollama_worker_task_not_simple_code_or_collection']),
+        ...(bannedRole ? ['ollama_worker_role_blocked'] : []),
+        ...(banned ? ['ollama_worker_strategy_planning_design_blocked'] : [])
+    ];
+    return {
+        schema: OLLAMA_WORKER_POLICY_SCHEMA,
+        generated_at: nowIso(),
+        ok: blockers.length === 0,
+        worker_only: true,
+        no_strategy_planning_design: true,
+        allowed_work: ['simple_code_patch_envelopes', 'read_only_collection'],
+        write_path_count: writePaths.length,
+        collection_detected: collection,
+        coding_detected: coding,
+        blockers
+    };
+}
+function buildOllamaTriWikiArtifact(triwikiContext) {
+    return {
+        ...triwikiContext,
+        proof: triWikiProofRecord(triwikiContext),
+        stack_current_docs_policy: {
+            required: true,
+            memory_path: '.sneakoscope/memory/q2_facts/stack-current-docs.md',
+            refresh_command: 'sks wiki refresh',
+            validate_command: 'sks wiki validate .sneakoscope/wiki/context-pack.json',
+            current_docs_source: 'Context7 or official vendor docs',
+            parent_action_when_stale_or_missing: 'Refresh stack-current-docs evidence with Context7 or official docs, then refresh/validate TriWiki before retrying the local worker.'
+        }
+    };
+}
+function buildOllamaGenerateRequest(agent, slice, opts, config, requestId, triwikiContext) {
+    const writePaths = collectWritePaths(slice, opts);
+    const prompt = [
+        'You are an SKS local Ollama worker. You are not an architect, planner, reviewer, verifier, safety judge, or strategist.',
+        'Only perform the narrow worker task below. If the task asks for strategy, planning, design, review, verification, risk judgment, or orchestration, return JSON with status "blocked" and blockers.',
+        'Before writing or collecting, consult the TriWiki context below first. Treat use_first as high-trust project memory and hydrate_first as source/evidence that the parent must verify before risky or user-visible work.',
+        'If TriWiki is missing, stale, or lacks current stack syntax/version guidance, do not invent from model memory. Return blocked and tell the parent SKS route to update .sneakoscope/memory/q2_facts/stack-current-docs.md with Context7 or official vendor docs, then run `sks wiki refresh` and `sks wiki validate .sneakoscope/wiki/context-pack.json` before retrying.',
+        'Return JSON only. Do not wrap it in markdown.',
+        'Required shape: {"summary": string, "findings": string[], "proposed_changes": string[], "patch_envelopes": [patchEnvelope]}.',
+        'Each patchEnvelope must contain operations: [{"op":"write","path":"relative/path","content":"text"}] or replace/unified_diff operations.',
+        'Patch envelope operations may be write, replace, or unified_diff. Use only allowed write paths.',
+        '',
+        triWikiContextBlock(triwikiContext),
+        '',
+        JSON.stringify({
+            request_id: requestId,
+            mission_id: opts.missionId || opts.mission_id || '',
+            route: opts.route || '$Agent',
+            agent: {
+                id: agent.id || '',
+                session_id: agent.session_id || '',
+                slot_id: agent.slot_id || agent.id || '',
+                generation_index: Number(agent.generation_index || 1),
+                role: agent.role || agent.persona_id || ''
+            },
+            task_slice: slice || {},
+            allowed_write_paths: writePaths,
+            triwiki_context: triWikiProofRecord(triwikiContext),
+            stack_current_docs_policy: {
+                required: true,
+                memory_path: '.sneakoscope/memory/q2_facts/stack-current-docs.md',
+                refresh: 'sks wiki refresh',
+                validate: 'sks wiki validate .sneakoscope/wiki/context-pack.json',
+                current_docs_source: 'Context7 or official vendor docs'
+            }
+        }, null, 2)
+    ].join('\n');
+    return {
+        model: config.model,
+        prompt,
+        stream: false,
+        format: 'json',
+        think: config.think,
+        keep_alive: config.keep_alive,
+        options: {
+            temperature: config.temperature
+        }
+    };
+}
+async function callOllamaGenerate(config, request) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), config.timeout_ms);
+    try {
+        const response = await fetch(`${config.base_url}/api/generate`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(request),
+            signal: controller.signal
+        });
+        const text = await response.text();
+        if (!response.ok)
+            return { ok: false, error: `http_${response.status}:${text.slice(0, 500)}` };
+        return { ok: true, data: JSON.parse(text) };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function parseWorkerJson(text) {
+    const trimmed = text.trim().replace(/^```(?:json)?\s*/i, '').replace(/\s*```$/, '');
+    try {
+        return { ok: true, value: JSON.parse(trimmed) };
+    }
+    catch {
+        const match = trimmed.match(/\{[\s\S]*\}/);
+        if (!match)
+            return { ok: false };
+        try {
+            return { ok: true, value: JSON.parse(match[0] || '{}') };
+        }
+        catch {
+            return { ok: false };
+        }
+    }
+}
+function normalizeOllamaPatchEnvelopes(value, agent, slice, opts, requestId) {
+    const rawEnvelopes = Array.isArray(value?.patch_envelopes) ? value.patch_envelopes
+        : Array.isArray(value?.patchEnvelopes) ? value.patchEnvelopes
+            : value?.patch_envelope ? [value.patch_envelope]
+                : value?.patchEnvelope ? [value.patchEnvelope]
+                    : Array.isArray(value?.operations) ? [{ operations: value.operations }]
+                        : value?.operation ? [{ operation: value.operation }]
+                            : looksLikePatchOperation(value) ? [value]
+                                : [];
+    return rawEnvelopes.map((raw, index) => {
+        const operations = normalizeOllamaOperations(raw);
+        const allowedPaths = collectWritePaths(slice, opts);
+        const firstPath = String(operations[0]?.path || allowedPaths[index] || slice?.id || `ollama-${index + 1}`);
+        const leaseId = String(raw?.lease_id || raw?.lease_proof?.lease_id || `write:${String(agent.id || 'ollama')}:${firstPath}`);
+        const nodeId = String(slice?.micro_win_id || slice?.id || `ollama-patch-${index + 1}`);
+        const verificationNodeId = String(slice?.verification_node_id || `verify:${nodeId}`);
+        const rollbackNodeId = String(slice?.rollback_node_id || `rollback:${nodeId}`);
+        return normalizeAgentPatchEnvelope({
+            ...raw,
+            source: 'model_authored',
+            mission_id: String(opts.missionId || opts.mission_id || raw?.mission_id || ''),
+            route: String(opts.route || raw?.route || '$Agent'),
+            agent_id: String(agent.id || raw?.agent_id || 'ollama-worker'),
+            session_id: String(agent.session_id || raw?.session_id || ''),
+            slot_id: String(agent.slot_id || raw?.slot_id || agent.id || 'ollama-worker'),
+            generation_index: Number(agent.generation_index || raw?.generation_index || 1),
+            task_slice_id: String(slice?.id || raw?.task_slice_id || ''),
+            native_cli_worker_session_id: String(agent.session_id || raw?.native_cli_worker_session_id || ''),
+            native_cli_process_id: process.pid,
+            worker_process_id: process.pid,
+            backend_ollama_request_id: requestId,
+            fast_mode: opts.fastMode !== false,
+            service_tier: opts.serviceTier === 'standard' ? 'standard' : 'fast',
+            lease_id: leaseId,
+            allowed_paths: allowedPaths.length ? allowedPaths : raw?.allowed_paths,
+            strategy_task_id: nodeId,
+            verification_node_id: verificationNodeId,
+            rollback_node_id: rollbackNodeId,
+            lease_proof: {
+                lease_id: leaseId,
+                owner_agent: String(agent.id || 'ollama-worker'),
+                owner_persona: String(agent.persona_id || agent.role || 'ollama-worker'),
+                allowed_paths: allowedPaths.length ? allowedPaths : raw?.allowed_paths,
+                strategy_task_id: nodeId,
+                micro_win_id: slice?.micro_win_id ? String(slice.micro_win_id) : undefined,
+                protected_path_check: 'passed',
+                conflict_prediction_id: `conflict:${nodeId}`,
+                verification_node_id: verificationNodeId,
+                rollback_node_id: rollbackNodeId
+            },
+            operations
+        });
+    });
+}
+function normalizeOllamaOperations(raw) {
+    if (Array.isArray(raw?.operations))
+        return raw.operations;
+    if (raw?.operation)
+        return normalizeOllamaOperations(raw.operation);
+    if (Array.isArray(raw?.changes))
+        return raw.changes.flatMap((change) => normalizeOllamaOperations(change));
+    if (Array.isArray(raw?.edits))
+        return raw.edits.flatMap((edit) => normalizeOllamaOperations(edit));
+    const pathValue = raw?.path || raw?.file || raw?.filepath || raw?.file_path || raw?.target_path || raw?.targetPath;
+    if (pathValue && (raw?.content !== undefined || raw?.text !== undefined)) {
+        return [{ op: 'write', path: String(pathValue), content: String(raw.content ?? raw.text ?? '') }];
+    }
+    if (pathValue && (raw?.diff !== undefined || raw?.unified_diff !== undefined || raw?.unifiedDiff !== undefined)) {
+        return [{ op: 'unified_diff', path: String(pathValue), diff: String(raw.diff ?? raw.unified_diff ?? raw.unifiedDiff ?? '') }];
+    }
+    if (pathValue && (raw?.search !== undefined || raw?.find !== undefined || raw?.replace !== undefined)) {
+        return [{
+                op: 'replace',
+                path: String(pathValue),
+                search: String(raw.search ?? raw.find ?? ''),
+                replace: String(raw.replace || '')
+            }];
+    }
+    return [];
+}
+function looksLikePatchOperation(value) {
+    return Boolean(value && typeof value === 'object' && (value.path !== undefined ||
+        value.file !== undefined ||
+        value.filepath !== undefined ||
+        value.file_path !== undefined ||
+        value.target_path !== undefined ||
+        value.targetPath !== undefined ||
+        value.content !== undefined ||
+        value.text !== undefined ||
+        value.diff !== undefined ||
+        value.unified_diff !== undefined ||
+        value.unifiedDiff !== undefined ||
+        value.search !== undefined ||
+        value.find !== undefined));
+}
+function blockedResult(agent, slice, opts, blockers, artifacts) {
+    return {
+        mission_id: String(opts.missionId || opts.mission_id || ''),
+        agent_id: String(agent.id || 'ollama-worker'),
+        session_id: String(agent.session_id || ''),
+        persona_id: String(agent.persona_id || agent.id || 'ollama-worker'),
+        task_slice_id: String(slice?.id || ''),
+        status: 'blocked',
+        backend: 'ollama',
+        summary: 'Ollama local worker blocked by configuration or worker-only policy.',
+        findings: [],
+        proposed_changes: [],
+        changed_files: [],
+        lease_compliance: { ok: true, violations: [] },
+        artifacts,
+        blockers,
+        confidence: 'blocked',
+        handoff_notes: 'Local model did not run.',
+        unverified: [],
+        writes: [],
+        verification: { status: 'failed', checks: ['ollama-worker-policy'] },
+        recursion_guard: { ok: true, violations: [] }
+    };
+}
+function collectWritePaths(slice, opts) {
+    return [
+        ...(Array.isArray(slice?.write_paths) ? slice.write_paths : []),
+        ...(Array.isArray(opts?.write_paths) ? opts.write_paths : [])
+    ].map(String).filter(Boolean);
+}
+function stringArray(value) {
+    return Array.isArray(value) ? value.map(String) : [];
+}
+function safeResponseData(data) {
+    return {
+        model: data?.model || null,
+        created_at: data?.created_at || null,
+        done: data?.done === true,
+        response_present: typeof data?.response === 'string' && data.response.length > 0,
+        thinking_present: typeof data?.thinking === 'string' && data.thinking.length > 0,
+        total_duration: data?.total_duration || null,
+        load_duration: data?.load_duration || null,
+        prompt_eval_count: data?.prompt_eval_count || null,
+        eval_count: data?.eval_count || null
+    };
+}
+function extractOllamaWorkerText(data) {
+    const response = String(data?.response || '').trim();
+    if (response)
+        return { text: response, source: 'response' };
+    const thinking = String(data?.thinking || '').trim();
+    if (thinking)
+        return { text: thinking, source: 'thinking' };
+    return { text: '', source: 'empty' };
+}
+//# sourceMappingURL=agent-runner-ollama.js.map

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

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

package/dist/core/agents/intelligent-work-graph.js

@@ -77,6 +77,8 @@ export function enhanceTaskGraphWithIntelligence(taskGraph, graph) {
         return taskGraph;
     const bottleneckTargets = new Set((graph.integration_bottlenecks?.bottlenecks || []).map((row) => String(row.file)));
     const criticalTargets = new Set(graph.critical_path?.path || []);
+    const targetActiveSlots = Math.max(1, Math.floor(Number(taskGraph.target_active_slots || 1)));
+    const canSerializeCriticalPath = taskGraph.work_items.length > targetActiveSlots;
     const workItems = taskGraph.work_items.map((item, index) => {
         const targets = Array.isArray(item.target_paths) ? item.target_paths.map(String) : [];
         const critical = targets.some((file) => criticalTargets.has(file));
@@ -90,7 +92,7 @@ export function enhanceTaskGraphWithIntelligence(taskGraph, graph) {
             test_ownership_ref: 'agent-test-ownership-map.json',
             critical_path_ref: 'agent-critical-path.json',
             integration_bottleneck_ref: 'agent-integration-bottlenecks.json',
-            dependencies: mergeDependencies(item.dependencies, critical && index > 0 ? [taskGraph.work_items[index - 1]?.work_item_id].filter(Boolean) : []),
+            dependencies: mergeDependencies(item.dependencies, canSerializeCriticalPath && critical && index > 0 ? [taskGraph.work_items[index - 1]?.work_item_id].filter(Boolean) : []),
             lease_requirements: [
                 ...(Array.isArray(item.lease_requirements) ? item.lease_requirements : []),
                 ...(bottleneck ? targets.map((file) => ({ kind: 'integration-bottleneck-read', path: file })) : [])
@@ -109,8 +111,9 @@ export function enhanceTaskGraphWithIntelligence(taskGraph, graph) {
     };
 }
 export async function writeIntelligentWorkGraphArtifacts(root, graph) {
-    await writeJsonAtomic(path.join(root, 'agent-intelligent-work-graph.json'), graph);
-    await writeJsonAtomic(path.join(root, 'agent-intelligent-work-graph-v2.json'), graph);
+    const compact = compactIntelligentWorkGraph(graph);
+    await writeJsonAtomic(path.join(root, 'agent-intelligent-work-graph.json'), compact);
+    await writeJsonAtomic(path.join(root, 'agent-intelligent-work-graph-v2.json'), compact);
     await writeJsonAtomic(path.join(root, 'agent-symbol-ownership-map.json'), {
         schema: 'sks.agent-symbol-ownership-map.v1',
         generated_at: graph.generated_at,
@@ -180,6 +183,45 @@ export async function writeIntelligentWorkGraphArtifacts(root, graph) {
         ...graph.integration_bottlenecks
     });
 }
+export function compactIntelligentWorkGraph(graph) {
+    return {
+        schema: graph.schema,
+        generated_at: graph.generated_at,
+        ok: graph.ok,
+        mode: graph.mode,
+        compact: true,
+        source_inventory_count: graph.source_inventory_count,
+        test_inventory_count: graph.test_inventory_count,
+        docs_inventory_count: graph.docs_inventory_count,
+        script_schema_inventory_count: graph.script_schema_inventory_count,
+        dependency_edge_count: graph.dependency_edge_count,
+        ast_coverage: graph.ast_coverage,
+        test_ownership_confidence: graph.test_ownership_confidence,
+        changed_file_candidates: limitArray(graph.changed_file_candidates, 200),
+        route_domain_priority: limitArray(graph.route_domain_priority, 100),
+        critical_path: graph.critical_path,
+        integration_bottlenecks: graph.integration_bottlenecks,
+        parallelizable_groups: limitArray(graph.parallelizable_groups, 80),
+        serial_dependency_groups: limitArray(graph.serial_dependency_groups, 40),
+        work_graph_quality_score: graph.work_graph_quality_score,
+        proof_level: graph.proof_level,
+        ast_parser_limitations: limitArray(graph.ast_parser_limitations, 100),
+        warnings: limitArray(graph.warnings, 200),
+        blockers: graph.blockers,
+        expanded_artifacts: {
+            symbol_ownership: 'agent-symbol-ownership-map.json',
+            route_ownership: 'agent-route-ownership-map.json',
+            command_ownership: 'agent-command-ownership-map.json',
+            test_ownership: 'agent-test-ownership-map.json',
+            source_test_ownership: 'agent-source-test-ownership-v2.json',
+            critical_path: 'agent-critical-path-v2.json',
+            integration_bottlenecks: 'agent-integration-bottlenecks-v2.json'
+        }
+    };
+}
+function limitArray(items, limit) {
+    return Array.isArray(items) ? items.slice(0, limit) : [];
+}
 function buildTestOwnershipMap(sourceFiles, testFiles, ast, dependencyGraph = {}) {
     const ownerBySource = {};
     const relations = [];

package/dist/core/agents/native-cli-session-swarm.js

@@ -42,6 +42,8 @@ class NativeCliSessionSwarmRecorder {
             parent_mission_id: this.input.missionId,
             route: this.input.route,
             backend: this.input.backend,
+            backend_explicit: this.input.backendExplicit === true,
+            no_ollama: this.input.noOllama === true || ctx.opts.noOllama === true,
             agent_root: this.root,
             agent: ctx.agent,
             slice: ctx.slice,
@@ -51,6 +53,9 @@ class NativeCliSessionSwarmRecorder {
             patch_envelope_path: patchRel,
             service_tier: this.input.fastModePolicy.service_tier,
             fast_mode: this.input.fastModePolicy.fast_mode,
+            ollama_enabled: ctx.opts.ollamaEnabled === true || this.input.backend === 'ollama',
+            ollama_model: ctx.opts.ollamaModel || null,
+            ollama_base_url: ctx.opts.ollamaBaseUrl || null,
             source_intelligence_refs: ctx.agent.source_intelligence_refs || null,
             goal_mode_ref: ctx.agent.goal_mode_ref || null,
             strategy_refs: ctx.slice?.strategy_refs || null,
@@ -192,6 +197,8 @@ class NativeCliSessionSwarmRecorder {
                 SKS_AGENT_SESSION_ID: String(input.ctx.agent.session_id || ''),
                 SKS_AGENT_SLOT_ID: slotId,
                 SKS_AGENT_GENERATION_INDEX: String(input.ctx.agent.generation_index || 1),
+                ...(input.ctx.opts.ollamaModel ? { SKS_OLLAMA_MODEL: String(input.ctx.opts.ollamaModel) } : {}),
+                ...(input.ctx.opts.ollamaBaseUrl ? { SKS_OLLAMA_BASE_URL: String(input.ctx.opts.ollamaBaseUrl) } : {}),
                 SKS_ZELLIJ_WORKER_PANE: '1',
                 SKS_ZELLIJ_SESSION_NAME: sessionName
             }
@@ -220,7 +227,7 @@ class NativeCliSessionSwarmRecorder {
             serviceTier: this.input.fastModePolicy.service_tier
         });
         const launchBlockers = paneRecord.blockers || [];
-        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--name', paneRecord.pane_name, '--', 'sh', '-lc', '<native-cli-worker-command>'];
+        input.record.command_line = ['zellij', '--session', sessionName, 'action', 'new-pane', '--direction', paneRecord.direction_applied, '--name', paneRecord.pane_name, '--', 'sh', '-lc', '<native-cli-worker-command>'];
         input.record.zellij_session_name = sessionName;
         input.record.zellij_pane_id = paneRecord.pane_id || null;
         input.record.zellij_pane_id_source = paneRecord.pane_id_source;

package/dist/core/agents/native-cli-worker.js

@@ -159,7 +159,7 @@ export async function runNativeCliWorker(input = {}) {
         structured_output_valid: routed.report?.structured_output_valid === true,
         backend_router_report: routed.report,
         backend_child_process_ids: routed.report.child_process_ids,
-        backend_child_execution: routed.report.child_process_ids.length > 0 || Boolean(routed.report?.sdk_thread_id) || backend === 'fake',
+        backend_child_execution: routed.report.child_process_ids.length > 0 || Boolean(routed.report?.sdk_thread_id) || backend === 'fake' || backend === 'ollama',
         recursion_guard_env: process.env.SKS_DISABLE_ROUTE_RECURSION === '1',
         worker_env: process.env.SKS_AGENT_WORKER === '1',
         exit_code: guard.ok ? 0 : 1