sneakoscope 2.0.1 → 2.0.2

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

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

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

@@ -47,6 +47,8 @@ export function buildDoctorReadinessMatrix(input = {}) {
         warnings.add('codex_app_needs_setup_optional_for_cli');
     if (input.codex_app_ui?.fast_selector === 'manual_action_required')
         warnings.add('codex_app_fast_selector_manual_action_required');
+    if (input.codex_app_ui?.requires_confirmation === true)
+        blockers.add('codex_app_fast_ui_repair_requires_confirmation');
     if (input.codex_app_ui?.fast_selector === 'repaired')
         warnings.add('codex_app_fast_selector_repaired_restart_app_if_needed');
     if (input.codex_lb?.ok === false)
@@ -58,6 +60,8 @@ export function buildDoctorReadinessMatrix(input = {}) {
     const nextActions = normalizeList(input.operator_actions || codexConfig.operator_actions);
     if (!nextActions.length && blockers.size)
         nextActions.push('Run `sks doctor --fix`, then run `sks mad repair-config --apply` if config-load still fails.');
+    if (input.codex_app_ui?.requires_confirmation === true)
+        nextActions.push(input.codex_app_ui.next_action || 'Run `sks doctor --fix --repair-codex-app-ui` after reviewing the repair plan.');
     if (!zellijReadyForInteractive)
         nextActions.push('Install Zellij for `sks --mad` and interactive lane UI. On macOS: `brew install zellij`.');
     return {

package/dist/core/feature-fixtures.js

@@ -111,6 +111,7 @@ const FIXTURES = Object.freeze({
     'route-fast-mode': fixture('execute', 'sks fast-mode status --json', [], 'pass'),
     'route-fast-on': fixture('mock', '$Fast-On covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
     'route-fast-off': fixture('mock', '$Fast-Off covered by hermetic fast-mode blackbox toggle test', [], 'pass'),
+    'route-local-model': fixture('execute', 'sks with-local-llm status --json', [], 'pass'),
     'route-help': fixture('mock', '$Help lightweight route', [], 'pass'),
     'route-commit': fixture('mock', '$Commit git route', ['completion-proof.json'], 'pass'),
     'route-commit-and-push': fixture('mock', '$Commit-And-Push git route', ['completion-proof.json'], 'pass'),

package/dist/core/fsx.js

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

package/dist/core/hooks-runtime.js

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

package/dist/core/init.js

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

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/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;

package/dist/core/update-check.js

@@ -1,3 +1,4 @@
+import os from 'node:os';
 import path from 'node:path';
 import { PACKAGE_VERSION, packageRoot, readJson, runProcess, which } from './fsx.js';
 const DEFAULT_REGISTRY = 'https://registry.npmjs.org/';
@@ -62,6 +63,132 @@ export async function runSksUpdateCheck(options = {}) {
         npmBin
     });
 }
+export async function runSksUpdateNow(options = {}) {
+    const packageName = options.packageName || 'sneakoscope';
+    const registry = options.registry || DEFAULT_REGISTRY;
+    const env = options.env || process.env;
+    const npmBin = options.npmBin === undefined ? await which('npm') : options.npmBin;
+    const cwd = os.homedir();
+    const check = await runSksUpdateCheck({
+        ...options,
+        packageName,
+        registry,
+        npmBin,
+        env
+    });
+    const requestedVersion = parseVersionText(options.version || '') || null;
+    const installVersion = requestedVersion || check.latest;
+    const npmArgs = installVersion ? sksGlobalInstallArgs(packageName, installVersion, registry) : [];
+    const command = npmBin && npmArgs.length ? [npmBin, ...npmArgs].join(' ') : null;
+    const globalRoot = npmBin ? await detectNpmGlobalRoot(npmBin, env, options).catch(() => null) : null;
+    if (!npmBin) {
+        return buildUpdateNowResult({
+            packageName,
+            from: check.current,
+            latest: check.latest,
+            requestedVersion,
+            installVersion,
+            npmBin: null,
+            npmArgs,
+            command,
+            cwd,
+            registry,
+            globalRoot,
+            status: 'unavailable',
+            ok: false,
+            installCode: null,
+            error: 'npm not found on PATH'
+        });
+    }
+    if (!installVersion) {
+        return buildUpdateNowResult({
+            packageName,
+            from: check.current,
+            latest: check.latest,
+            requestedVersion,
+            installVersion,
+            npmBin,
+            npmArgs,
+            command,
+            cwd,
+            registry,
+            globalRoot,
+            status: 'unavailable',
+            ok: false,
+            installCode: null,
+            error: check.error || 'latest version unavailable'
+        });
+    }
+    if (!requestedVersion && check.latest && !check.update_available) {
+        return buildUpdateNowResult({
+            packageName,
+            from: check.current,
+            latest: check.latest,
+            requestedVersion,
+            installVersion,
+            npmBin,
+            npmArgs,
+            command,
+            cwd,
+            registry,
+            globalRoot,
+            status: 'current',
+            ok: true,
+            installCode: null,
+            error: null
+        });
+    }
+    if (options.dryRun) {
+        return buildUpdateNowResult({
+            packageName,
+            from: check.current,
+            latest: check.latest,
+            requestedVersion,
+            installVersion,
+            npmBin,
+            npmArgs,
+            command,
+            cwd,
+            registry,
+            globalRoot,
+            status: 'dry_run',
+            ok: true,
+            installCode: null,
+            error: null
+        });
+    }
+    const install = await runProcess(npmBin, npmArgs, {
+        cwd,
+        env,
+        timeoutMs: options.timeoutMs ?? 10 * 60 * 1000,
+        maxOutputBytes: options.maxOutputBytes ?? 128 * 1024
+    }).catch((err) => ({
+        code: 1,
+        stdout: '',
+        stderr: err instanceof Error ? err.message : String(err)
+    }));
+    const ok = install.code === 0;
+    return buildUpdateNowResult({
+        packageName,
+        from: check.current,
+        latest: check.latest,
+        requestedVersion,
+        installVersion,
+        npmBin,
+        npmArgs,
+        command,
+        cwd,
+        registry,
+        globalRoot,
+        status: ok ? 'updated' : 'failed',
+        ok,
+        installCode: install.code,
+        error: ok ? null : `${install.stderr || install.stdout || 'npm global install failed'}`.trim()
+    });
+}
+export function sksGlobalInstallArgs(packageName, version, registry = DEFAULT_REGISTRY) {
+    return ['install', '--global', `${packageName}@${version}`, '--registry', registry];
+}
 export async function detectEffectiveSksVersion(options = {}) {
     const packageName = options.packageName || 'sneakoscope';
     const env = options.env || process.env;
@@ -183,12 +310,40 @@ function buildResult(input) {
         mode: 'function',
         route_required: false,
         pipeline_required: false,
-        command: updateAvailable ? `npm i -g ${input.packageName}@${input.latest} --registry ${input.registry}` : null,
+        command: updateAvailable ? `sks update now --version ${input.latest}` : null,
         npm_bin: input.npmBin,
         registry: input.registry,
         error: input.error || null
     };
 }
+function buildUpdateNowResult(input) {
+    return {
+        schema: 'sks.update-now.v1',
+        ok: input.ok,
+        status: input.status,
+        package: input.packageName,
+        from: input.from,
+        latest: input.latest,
+        requested_version: input.requestedVersion,
+        install_version: input.installVersion,
+        npm_bin: input.npmBin,
+        npm_args: input.npmArgs,
+        command: input.command,
+        cwd: input.cwd,
+        registry: input.registry,
+        global_root: input.globalRoot,
+        install_code: input.installCode,
+        error: input.error
+    };
+}
+async function detectNpmGlobalRoot(npmBin, env, opts = {}) {
+    const result = await runProcess(npmBin, ['root', '--global', '--silent'], {
+        env,
+        timeoutMs: opts.timeoutMs ?? 2500,
+        maxOutputBytes: opts.maxOutputBytes ?? 4096
+    }).catch(() => ({ code: 1, stdout: '', stderr: '' }));
+    return result.code === 0 ? String(result.stdout || '').trim().split(/\r?\n/).pop() || null : null;
+}
 function versionOverrideEnvName(packageName) {
     return `SKS_NPM_VIEW_${packageName.replace(/[^A-Za-z0-9]+/g, '_').toUpperCase()}_VERSION`;
 }

package/dist/core/verification/verification-worker-pool.js

@@ -87,6 +87,7 @@ export async function runVerificationTask(task, opts = {}) {
         let timedOut = false;
         const timeoutMs = task.timeout_ms || 10 * 60 * 1000;
         let killTimeout = null;
+        let exitFallback = null;
         const finish = (payload) => {
             if (settled)
                 return;
@@ -94,6 +95,8 @@ export async function runVerificationTask(task, opts = {}) {
             clearTimeout(timeout);
             if (killTimeout)
                 clearTimeout(killTimeout);
+            if (exitFallback)
+                clearTimeout(exitFallback);
             resolve(payload);
         };
         const timeout = setTimeout(() => {
@@ -113,6 +116,15 @@ export async function runVerificationTask(task, opts = {}) {
         child.on('error', (err) => {
             finish({ code: null, error: err.message });
         });
+        child.on('exit', (code) => {
+            if (settled)
+                return;
+            exitFallback = setTimeout(async () => {
+                if (timedOut)
+                    await waitForProcessTreeExit(child.pid, 2_000);
+                finish({ code, ...(timedOut ? { error: `timeout:${timeoutMs}` } : {}) });
+            }, 1_000);
+        });
         child.on('close', async (code) => {
             if (timedOut)
                 await waitForProcessTreeExit(child.pid, 2_000);

package/dist/core/version.js

@@ -1,2 +1,2 @@
-export const PACKAGE_VERSION = '2.0.1';
+export const PACKAGE_VERSION = '2.0.2';
 //# sourceMappingURL=version.js.map

package/dist/core/zellij/zellij-worker-pane-manager.js

@@ -57,6 +57,8 @@ export function buildWorkerPaneArtifact(input) {
         opened_at: now,
         closed_at: null,
         close: null,
+        direction_requested: 'right',
+        direction_applied: input.directionApplied || 'not_applied',
         sdk_thread_id: input.sdkThreadId || null,
         sdk_run_id: input.sdkRunId || null,
         stream_event_count: Number(input.streamEventCount || 0),
@@ -81,13 +83,25 @@ export async function openWorkerPane(input) {
         optional: false
     });
     const paneName = buildWorkerPaneTitle(input.slotId, input.generationIndex, providerContext, input.serviceTier);
-    const launch = createSession.ok
-        ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
+    let launch = createSession.ok
+        ? await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--direction', 'right', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
             cwd,
             timeoutMs: 5000,
             optional: false
         })
         : null;
+    let directionApplied = launch?.ok ? 'right' : 'not_applied';
+    if (createSession.ok && launch && !launch.ok) {
+        const fallback = await runZellij(['--session', input.sessionName, 'action', 'new-pane', '--name', paneName, '--', 'sh', '-lc', input.workerCommand], {
+            cwd,
+            timeoutMs: 5000,
+            optional: false
+        });
+        if (fallback.ok) {
+            launch = fallback;
+            directionApplied = 'unknown';
+        }
+    }
     const stdoutPaneId = launch?.ok ? extractZellijPaneIdFromOutput(launch.stdout_tail) : null;
     const reconciledPane = stdoutPaneId ? null : launch?.ok ? await reconcileZellijWorkerPaneId(input.sessionName, paneName, path.join(root, input.resultPath), cwd) : null;
     const paneId = stdoutPaneId || reconciledPane?.pane_id || null;
@@ -110,6 +124,7 @@ export async function openWorkerPane(input) {
         createSession,
         launch,
         paneReconciliation: reconciledPane,
+        directionApplied,
         status: blockers.length ? 'failed' : 'running',
         providerContext,
         serviceTier: input.serviceTier || providerContext.service_tier,
@@ -139,6 +154,8 @@ export async function openWorkerPane(input) {
         provider: record.provider,
         service_tier: record.service_tier,
         provider_context: record.provider_context,
+        direction_requested: record.direction_requested,
+        direction_applied: record.direction_applied,
         command: '<native-cli-worker-command>',
         worker_artifact_dir: input.workerArtifactDir,
         worker_result_path: input.resultPath,

package/dist/scripts/agent-ast-aware-work-graph-check.js

@@ -20,6 +20,6 @@ assertGate(Object.keys(graph.command_to_module_ownership).length > 0, 'AST-aware
 assertGate(graph.test_ownership_confidence >= 0, 'AST-aware work graph must record test ownership confidence', graph);
 assertGate(['proven', 'partial', 'blocked'].includes(graph.proof_level), 'AST-aware work graph must report an honest proof level', graph);
 fs.mkdirSync(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
-fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', `agent-intelligent-work-graph-v2-${releaseVersion}.json`), `${JSON.stringify(graph, null, 2)}\n`);
+fs.writeFileSync(path.join(root, '.sneakoscope', 'reports', `agent-intelligent-work-graph-v2-${releaseVersion}.json`), `${JSON.stringify(graphMod.compactIntelligentWorkGraph(graph), null, 2)}\n`);
 emitGate('agent:ast-aware-work-graph', { score: graph.work_graph_quality_score, ast_coverage: graph.ast_coverage, proof_level: graph.proof_level });
 //# sourceMappingURL=agent-ast-aware-work-graph-check.js.map