sneakoscope 2.0.1 → 2.0.4

package/dist/core/local-llm/local-collaboration-policy.js

@@ -0,0 +1,93 @@
+import { nowIso } from '../fsx.js';
+export const LOCAL_COLLABORATION_POLICY_SCHEMA = 'sks.local-collaboration-policy.v1';
+export const LOCAL_COLLABORATION_FINAL_GATE_SCHEMA = 'sks.local-collaboration-final-gate.v1';
+export const DEFAULT_LOCAL_COLLABORATION_MODE = 'local-parallel-gpt-final';
+export const LOCAL_COLLABORATION_MODES = [
+    'disabled',
+    'local-draft-gpt-final',
+    'local-worker-gpt-orchestrator',
+    'local-parallel-gpt-final',
+    'local-only-draft'
+];
+export function resolveLocalCollaborationPolicy(input = {}) {
+    const env = input.env || process.env;
+    const requested = firstText(input.mode, env.SKS_LOCAL_COLLAB_MODE, DEFAULT_LOCAL_COLLABORATION_MODE);
+    const mode = normalizeLocalCollaborationMode(requested);
+    const invalid = mode ? [] : [`invalid_local_collaboration_mode:${requested}`];
+    const resolvedMode = mode || DEFAULT_LOCAL_COLLABORATION_MODE;
+    return {
+        schema: LOCAL_COLLABORATION_POLICY_SCHEMA,
+        generated_at: nowIso(),
+        mode: resolvedMode,
+        default_mode: DEFAULT_LOCAL_COLLABORATION_MODE,
+        local_llm_role: resolvedMode === 'disabled' ? 'disabled' : 'draft_worker',
+        gpt_final_required: resolvedMode !== 'disabled' && resolvedMode !== 'local-only-draft',
+        gpt_final_backend_must_be_remote: resolvedMode !== 'disabled',
+        local_only_draft: resolvedMode === 'local-only-draft',
+        final_accepted_statuses: ['approved', 'modified'],
+        final_patch_source_when_enabled: 'gpt_final_arbiter',
+        blockers: [
+            ...invalid,
+            ...(resolvedMode === 'local-only-draft' ? ['needs_gpt_final_review'] : [])
+        ]
+    };
+}
+export function evaluateLocalCollaborationFinalGate(input = {}) {
+    const policy = input.policy || resolveLocalCollaborationPolicy(input.mode === undefined ? {} : { mode: input.mode });
+    const localParticipated = input.localParticipated !== false && policy.mode !== 'disabled';
+    const status = normalizeGptFinalStatus(input.gptFinalStatus);
+    const requiresGptFinal = policy.gpt_final_required && localParticipated;
+    const gptBackend = String(input.gptFinalBackend || '');
+    const remoteBackendOk = !gptBackend || !isLocalBackendName(gptBackend);
+    const blockers = [
+        ...policy.blockers,
+        ...(requiresGptFinal && input.gptFinalAvailable === false ? ['gpt_final_arbiter_unavailable'] : []),
+        ...(requiresGptFinal && !status ? ['gpt_final_arbiter_missing'] : []),
+        ...(requiresGptFinal && status && !policy.final_accepted_statuses.includes(status) ? [`gpt_final_status_not_accepted:${status}`] : []),
+        ...(requiresGptFinal && !remoteBackendOk ? ['gpt_final_backend_must_not_be_local_llm'] : []),
+        ...(policy.local_only_draft && input.applyPatches === true ? ['local_only_draft_apply_blocked'] : [])
+    ];
+    const accepted = blockers.length === 0 && (!requiresGptFinal || status === 'approved' || status === 'modified');
+    return {
+        schema: LOCAL_COLLABORATION_FINAL_GATE_SCHEMA,
+        generated_at: nowIso(),
+        ok: accepted,
+        mode: policy.mode,
+        local_participated: localParticipated,
+        gpt_final_required: requiresGptFinal,
+        gpt_final_status: status,
+        gpt_final_backend: gptBackend || null,
+        final_status: accepted ? 'accepted' : policy.local_only_draft ? 'draft_only' : 'blocked',
+        apply_allowed: accepted && policy.local_only_draft !== true,
+        release_proof_allowed: accepted,
+        final_patch_source: accepted && policy.mode !== 'disabled' ? policy.final_patch_source_when_enabled : 'not_applicable',
+        blockers
+    };
+}
+export function localCollaborationParticipated(results = []) {
+    return results.some((result) => {
+        const backend = String(result?.backend_router_report?.selected_backend || result?.backend || '').toLowerCase();
+        return backend === 'ollama' || backend === 'local-llm' || backend === 'local_llm';
+    });
+}
+export function normalizeLocalCollaborationMode(value) {
+    const text = String(value ?? '').trim();
+    return LOCAL_COLLABORATION_MODES.includes(text) ? text : null;
+}
+export function normalizeGptFinalStatus(value) {
+    const text = String(value ?? '').trim();
+    return text === 'approved' || text === 'modified' || text === 'rejected' || text === 'needs_more_work' ? text : null;
+}
+function firstText(...values) {
+    for (const value of values) {
+        const text = String(value ?? '').trim();
+        if (text)
+            return text;
+    }
+    return '';
+}
+function isLocalBackendName(value) {
+    const text = value.toLowerCase();
+    return text === 'ollama' || text === 'local-llm' || text === 'local_llm';
+}
+//# sourceMappingURL=local-collaboration-policy.js.map

package/dist/core/local-llm/local-llm-config.js

@@ -0,0 +1,15 @@
+import { resolveOllamaWorkerConfig } from '../agents/ollama-worker-config.js';
+export async function resolveLocalLlmConfig(input = {}) {
+    const config = await resolveOllamaWorkerConfig(input);
+    return {
+        schema: 'sks.local-llm-config.v1',
+        ok: config.ok,
+        enabled: config.enabled,
+        provider: config.provider,
+        model: config.model,
+        base_url: config.base_url,
+        worker_only: true,
+        blockers: config.blockers
+    };
+}
+//# sourceMappingURL=local-llm-config.js.map

package/dist/core/pipeline/final-gpt-patch-stage.js

@@ -0,0 +1,31 @@
+export function selectFinalGptPatchSource(gptFinal, localPatchEnvelopes = []) {
+    const status = String(gptFinal?.result?.status || gptFinal?.status || '');
+    if (status === 'modified') {
+        return {
+            schema: 'sks.final-gpt-patch-stage.v1',
+            ok: true,
+            final_patch_source: 'gpt_final_arbiter',
+            patch_envelopes: Array.isArray(gptFinal?.result?.modified_patch_envelopes) ? gptFinal.result.modified_patch_envelopes : [],
+            blockers: []
+        };
+    }
+    if (status === 'approved') {
+        return {
+            schema: 'sks.final-gpt-patch-stage.v1',
+            ok: true,
+            final_patch_source: 'gpt_final_arbiter',
+            patch_envelopes: Array.isArray(gptFinal?.result?.accepted_patch_envelopes) && gptFinal.result.accepted_patch_envelopes.length
+                ? gptFinal.result.accepted_patch_envelopes
+                : localPatchEnvelopes,
+            blockers: []
+        };
+    }
+    return {
+        schema: 'sks.final-gpt-patch-stage.v1',
+        ok: false,
+        final_patch_source: 'blocked',
+        patch_envelopes: [],
+        blockers: ['gpt_final_not_approved']
+    };
+}
+//# sourceMappingURL=final-gpt-patch-stage.js.map

package/dist/core/pipeline/final-gpt-review-stage.js

@@ -0,0 +1,5 @@
+import { runGptFinalArbiter } from '../codex-control/gpt-final-arbiter.js';
+export async function runFinalGptReviewStage(input, opts = {}) {
+    return runGptFinalArbiter(input, opts);
+}
+//# sourceMappingURL=final-gpt-review-stage.js.map

package/dist/core/provider/provider-context.js

@@ -1,15 +1,22 @@
 import path from 'node:path';
-import { exists, nowIso, readJson, writeJsonAtomic } from '../fsx.js';
+import { exists, nowIso, readJson, readText, writeJsonAtomic } from '../fsx.js';
 export const PROVIDER_CONTEXT_SCHEMA = 'sks.provider-context.v1';
 export async function resolveProviderContext(input = {}) {
     const env = input.env || process.env;
     const root = path.resolve(input.root || process.cwd());
     const codexHome = path.resolve(String(input.codexHome || env.CODEX_HOME || path.join(env.HOME || '', '.codex')));
+    const configText = await readText(path.join(codexHome, 'config.toml'), '').catch(() => '');
+    const configModelProvider = readTopLevelTomlString(configText, 'model_provider');
+    const codexLbProviderBlockPresent = hasCodexLbProviderBlock(configText);
+    const codexLbEnvKey = codexLbProviderEnvKey(configText) || (codexLbProviderBlockPresent ? 'CODEX_LB_API_KEY' : null);
+    const codexLbRequiresOpenAiAuth = codexLbProviderRequiresOpenAiAuth(configText);
+    const codexLbProviderValid = codexLbProviderBlockPresent && (codexLbRequiresOpenAiAuth === false || codexLbRequiresOpenAiAuth == null);
     const openaiKey = Boolean(String(env.OPENAI_API_KEY || '').trim());
-    const lbKey = Boolean(String(env.CODEX_LB_API_KEY || '').trim());
+    const lbKey = Boolean(String((codexLbEnvKey ? env[codexLbEnvKey] : env.CODEX_LB_API_KEY) || env.CODEX_LB_API_KEY || '').trim());
     const envProvider = String(env.SKS_MODEL_PROVIDER || env.CODEX_MODEL_PROVIDER || env.OPENAI_MODEL_PROVIDER || '').trim();
-    const modelProvider = String(input.modelProvider || envProvider || '').trim() || null;
-    const lbExplicit = modelProvider === 'codex-lb' || env.SKS_PROVIDER === 'codex-lb' || env.SKS_USE_CODEX_LB === '1';
+    const modelProvider = String(input.modelProvider || envProvider || configModelProvider || '').trim() || null;
+    const envLbExplicit = env.SKS_PROVIDER === 'codex-lb' || env.SKS_USE_CODEX_LB === '1';
+    const lbExplicit = modelProvider === 'codex-lb' || envLbExplicit;
     const auth = await readJson(path.join(codexHome, 'auth.json'), null).catch(() => null);
     const appAuthPresent = Boolean(auth) || await exists(path.join(codexHome, 'auth.json'));
     const conflict = (lbKey && openaiKey && !lbExplicit && !modelProvider) || (modelProvider === 'codex-lb' && !lbKey && openaiKey);
@@ -17,17 +24,23 @@ export async function resolveProviderContext(input = {}) {
     let authMode = 'unknown';
     let source = 'unknown';
     let confidence = 'low';
-    if (lbExplicit && lbKey) {
+    if (envLbExplicit && lbKey) {
         provider = 'codex-lb';
         authMode = 'codex_lb_key';
         source = 'codex_lb';
         confidence = 'high';
     }
-    else if (modelProvider === 'codex-lb') {
+    else if (modelProvider === 'codex-lb' && codexLbProviderValid && lbKey) {
         provider = 'codex-lb';
-        authMode = lbKey ? 'codex_lb_key' : 'unknown';
+        authMode = 'codex_lb_key';
         source = 'config';
-        confidence = lbKey ? 'medium' : 'low';
+        confidence = 'high';
+    }
+    else if (modelProvider === 'codex-lb' && codexLbProviderValid) {
+        provider = 'codex-lb';
+        authMode = 'unknown';
+        source = 'config';
+        confidence = 'low';
     }
     else if (openaiKey) {
         provider = 'openai';
@@ -43,6 +56,7 @@ export async function resolveProviderContext(input = {}) {
     }
     const warnings = [
         ...(conflict ? ['provider_conflict'] : []),
+        ...(modelProvider === 'codex-lb' && !codexLbProviderValid && !envLbExplicit ? ['codex_lb_provider_config_missing_or_invalid'] : []),
         ...(provider === 'codex-lb' && !lbKey ? ['codex_lb_selected_without_key'] : [])
     ];
     return {
@@ -61,7 +75,11 @@ export async function resolveProviderContext(input = {}) {
             codex_lb_key_present: lbKey,
             codex_lb_explicit: lbExplicit,
             codex_app_auth_present: appAuthPresent,
-            model_provider: modelProvider
+            model_provider: modelProvider,
+            codex_lb_provider_block_present: codexLbProviderBlockPresent,
+            codex_lb_env_key: codexLbEnvKey,
+            codex_lb_requires_openai_auth: codexLbRequiresOpenAiAuth,
+            codex_lb_available: codexLbProviderValid && lbKey
         }
     };
 }
@@ -79,4 +97,49 @@ function normalizeServiceTier(value) {
         return 'standard';
     return 'unknown';
 }
+export function readTopLevelTomlString(text, key) {
+    const lines = String(text || '').split(/\r?\n/);
+    for (const line of lines) {
+        if (/^\s*\[/.test(line))
+            break;
+        const match = line.match(new RegExp(`^\\s*${escapeRegExp(key)}\\s*=\\s*"([^"]*)"\\s*(?:#.*)?$`));
+        if (match?.[1] != null)
+            return match[1];
+    }
+    return null;
+}
+export function hasCodexLbProviderBlock(text) {
+    return codexLbProviderBody(text) != null;
+}
+export function codexLbProviderEnvKey(text) {
+    const body = codexLbProviderBody(text);
+    return body == null ? null : readTopLevelTomlString(body, 'env_key');
+}
+export function codexLbProviderRequiresOpenAiAuth(text) {
+    const body = codexLbProviderBody(text);
+    if (body == null)
+        return null;
+    const match = body.match(/^\s*requires_openai_auth\s*=\s*(true|false)\s*(?:#.*)?$/m);
+    return match?.[1] === 'true' ? true : match?.[1] === 'false' ? false : null;
+}
+function codexLbProviderBody(text) {
+    const lines = String(text || '').split(/\r?\n/);
+    const out = [];
+    let inTable = false;
+    for (const line of lines) {
+        const table = line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/)?.[1]?.trim();
+        if (table) {
+            if (inTable)
+                break;
+            inTable = table === 'model_providers.codex-lb' || table === 'model_providers."codex-lb"' || table === '"model_providers"."codex-lb"';
+            continue;
+        }
+        if (inTable)
+            out.push(line);
+    }
+    return inTable ? out.join('\n') : null;
+}
+function escapeRegExp(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 //# sourceMappingURL=provider-context.js.map

package/dist/core/retention.js

@@ -52,6 +52,10 @@ const DISPOSABLE_MISSION_DIRS = Object.freeze([
     'research/cycles',
     'research/tmp'
 ]);
+const DISPOSABLE_MISSION_FILES = Object.freeze([
+    'agents/agent-intelligent-work-graph.json',
+    'agents/agent-intelligent-work-graph-v2.json'
+]);
 const MISSION_CLOSE_GATES = Object.freeze([
     'team-gate.json',
     'reflection-gate.json',
@@ -235,6 +239,9 @@ async function compactClosedMissionWorkdirs(root, policy, dryRun, actions, opts
             const target = path.join(mission.path, rel);
             await removePath('remove_closed_mission_workdir', target, dryRun, actions, { mission: mission.id, rel, reason: 'closed_mission_disposable_workdir' });
         }
+        for (const rel of DISPOSABLE_MISSION_FILES) {
+            await removePath('remove_closed_mission_large_file', path.join(mission.path, rel), dryRun, actions, { mission: mission.id, rel, reason: 'closed_mission_disposable_large_file' });
+        }
         await pruneMissionDisposableLogs(mission, dryRun, actions);
     }
 }
@@ -272,6 +279,9 @@ async function compactOldMissionWithDurableArtifacts(mission, dryRun, actions, r
     for (const rel of DISPOSABLE_MISSION_DIRS) {
         await removePath('remove_old_mission_workdir', path.join(mission.path, rel), dryRun, actions, { mission: mission.id, rel, reason });
     }
+    for (const rel of DISPOSABLE_MISSION_FILES) {
+        await removePath('remove_old_mission_large_file', path.join(mission.path, rel), dryRun, actions, { mission: mission.id, rel, reason });
+    }
     await pruneMissionDisposableLogs(mission, dryRun, actions);
 }
 async function canCompactActiveMission(mission, opts = {}) {
@@ -545,6 +555,7 @@ export async function enforceRetention(root, opts = {}) {
         action_count: actions.length,
         protected_durable_context: DURABLE_RETENTION_CLASSES,
         disposable_mission_dirs: DISPOSABLE_MISSION_DIRS,
+        disposable_mission_files: DISPOSABLE_MISSION_FILES,
         prune_report_logs: Boolean(opts.pruneReportLogs || policy.prune_disposable_report_logs),
         completed_mission_id: opts.completedMissionId || null,
         actions

package/dist/core/routes.js

@@ -335,6 +335,22 @@ export const ROUTES = [
         cliEntrypoint: 'sks fast-mode on|off|status|clear [--json]',
         examples: ['$Fast-On', '$Fast-Off', '$Fast-Mode status']
     },
+    {
+        id: 'LocalModel',
+        command: '$with-local-llm-on',
+        mode: 'LOCAL_MODEL',
+        route: 'local Ollama worker toggle',
+        description: 'Turn the optional local Ollama worker backend on or off. Default off keeps SKS GPT-only; enabled mode lets eligible simple code/collection worker slices use Ollama while GPT/Codex owns strategy, design, review, verification, and integration.',
+        requiredSkills: ['with-local-llm-on', 'honest-mode'],
+        dollarAliases: ['$with-local-llm-off'],
+        appSkillAliases: ['with-local-llm-off'],
+        lifecycle: ['global_local_model_toggle', 'worker_only_policy_status', 'honest_mode'],
+        context7Policy: 'not_required',
+        reasoningPolicy: 'low',
+        stopGate: 'none',
+        cliEntrypoint: 'sks with-local-llm on|off|status|set-model [--json]',
+        examples: ['$with-local-llm-on', '$with-local-llm-off', 'sks with-local-llm status --json']
+    },
     {
         id: 'Team',
         command: '$Team',
@@ -534,7 +550,7 @@ export const ROUTES = [
         requiredSkills: ['mad-sks', 'db-safety-guard', 'pipeline-runner', 'context7-docs', REFLECTION_SKILL_NAME, 'honest-mode'],
         lifecycle: ['explicit_invocation', 'auto_sealed_permission_scope', 'scoped_permission_override', 'catastrophic_guard', 'permission_deactivation', 'post_route_reflection', 'honest_mode'],
         context7Policy: 'required',
-        reasoningPolicy: 'high',
+        reasoningPolicy: 'xhigh',
         stopGate: 'mad-sks-gate.json',
         cliEntrypoint: 'Codex App prompt route only: $MAD-SKS <task>',
         examples: ['$MAD-SKS $Team target project maintenance with package/service/file and DB scopes', '$DB Supabase 점검 $MAD-SKS']
@@ -607,6 +623,7 @@ export const COMMAND_CATALOG = [
     { name: 'quickstart', usage: 'sks quickstart', description: 'Show the shortest safe setup and verification flow.' },
     { name: 'bootstrap', usage: 'sks bootstrap [--install-scope global|project] [--local-only] [--json]', description: 'Initialize the current project, install SKS Codex App files/skills, check Context7/Codex App/Zellij, and print ready true/false.' },
     { name: 'root', usage: 'sks root [--json]', description: 'Show whether SKS is using a project root or the per-user global SKS runtime root.' },
+    { name: 'update', usage: 'sks update check|now [--version <version>] [--json] [--dry-run]', description: 'Check for SKS updates or install the requested package version through npm global mode.' },
     { name: 'deps', usage: 'sks deps check [--json] [--yes]', description: 'Check Node/npm, Codex CLI, and Zellij readiness; pass --yes to repair missing Codex CLI/Zellij tooling when supported.' },
     { name: 'codex', usage: 'sks codex compatibility|version|doctor|schema [--json]', description: 'Check Codex CLI rust-v0.136.0 compatibility, installed version, 0.136 capabilities, inherited 0.135/0.134/0.133 behavior, and vendored hook schema snapshot freshness.' },
     { name: 'codex-app', usage: 'sks codex-app [check|chrome-extension|pat status|remote-control]', description: 'Check Codex App install, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI 0.130.0+ remote-control availability.' },
@@ -621,6 +638,7 @@ export const COMMAND_CATALOG = [
     { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch SKS Zellij with the auto-review profile.' },
     { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Team.' },
     { name: 'fast-mode', usage: 'sks fast-mode on|off|status|clear [--json]', description: 'Toggle the project-local Fast mode default used by $Fast-On, $Fast-Off, and native-agent routes.' },
+    { name: 'with-local-llm', usage: 'sks with-local-llm on|off|status|set-model [--json]', description: 'Toggle the optional local Ollama worker backend used by $with-local-llm-on/$with-local-llm-off and eligible simple worker slices.' },
     { name: 'commit', usage: 'sks commit [--message "msg"] [--json]', description: 'Stage current changes, summarize them, and create a simple git commit without the full SKS pipeline.' },
     { name: 'commit-and-push', usage: 'sks commit-and-push [--message "msg"] [--json]', description: 'Stage current changes, create a simple git commit, and push without the full SKS pipeline.' },
     { name: 'dfix', usage: 'sks dfix', description: 'Explain $DFix ultralight direct-fix mode.' },
@@ -1007,6 +1025,8 @@ export function routeReasoning(route, prompt = '') {
     const base = ALLOWED_REASONING_EFFORTS.has(route?.reasoningPolicy) ? route.reasoningPolicy : 'medium';
     if (hasFromChatImgSignal(text))
         return reasoning('xhigh', 'from_chat_img_image_work_order_analysis');
+    if (/(?:^|\s)sks\s+--mad\b|(?:^|\s)--mad\b|\$MAD-SKS\b|\bmad-sks\b|\bmadsks\b/i.test(text))
+        return reasoning('xhigh', 'mad_sks_or_mad_launch_default');
     if (route?.id === 'Team')
         return teamRouteReasoning(text);
     if (route?.id === 'Research' || route?.id === 'AutoResearch')

package/dist/core/safety/mutation-guard.js

@@ -162,6 +162,8 @@ export async function guardedProcessKill(ctx, pid, opts = {}) {
 export async function guardedPackageInstall(ctx, spec, opts) {
     return guard(ctx, 'package_install', spec, opts, async () => {
         const runOpts = { timeoutMs: opts.timeoutMs ?? 600000 };
+        if (opts.cwd !== undefined)
+            runOpts.cwd = opts.cwd;
         if (opts.env !== undefined)
             runOpts.env = opts.env;
         if (opts.maxOutputBytes !== undefined)

package/dist/core/team-live.js

@@ -360,7 +360,13 @@ export function parseTeamSpecArgs(args = []) {
             i++;
             continue;
         }
-        if (arg === '--json' || arg === '--open-zellij' || arg === '--zellij-open' || arg === '--no-open-zellij' || arg === '--no-zellij' || arg === '--no-attach' || arg === '--separate-session' || arg === '--new-session' || arg === '--legacy-team-session')
+        if (/^--(?:ollama-model|local-model-model|ollama-base-url|local-model-base-url)$/.test(arg)) {
+            i++;
+            continue;
+        }
+        if (/^--(?:ollama-model|local-model-model|ollama-base-url|local-model-base-url)=/.test(arg))
+            continue;
+        if (arg === '--json' || arg === '--open-zellij' || arg === '--zellij-open' || arg === '--no-open-zellij' || arg === '--no-zellij' || arg === '--no-attach' || arg === '--separate-session' || arg === '--new-session' || arg === '--legacy-team-session' || arg === '--ollama' || arg === '--local-model' || arg === '--no-ollama' || arg === '--no-local-model')
             continue;
         const consumed = consumeTeamSpecText(arg, { roleCounts, explicitExecutor, explicitSession });
         roleCounts = consumed.roleCounts;