sneakoscope 10.6.2 → 10.7.0

package/dist/core/codex-control/codex-reliability-shield.js

@@ -1,5 +1,9 @@
 import { nowIso } from '../fsx.js';
 export const CODEX_RELIABILITY_SHIELD_SCHEMA = 'sks.codex-reliability-shield.v1';
+const DEFAULT_CAPACITY_BACKOFF_MS = [15_000, 45_000, 90_000];
+const MODEL_CAPACITY_RE = /selected model is at capacity|model(?:\s+[\w.-]+)?\s+is\s+at\s+capacity|try a different model|capacity(?:\s+is)?\s+exhausted|temporarily at capacity/i;
+const USAGE_LIMIT_RE = /hit your usage limit|usage limit (?:has been )?reached/i;
+const NON_WORK_ITEM_TYPES = new Set(['error', 'reasoning']);
 export function codexTimeoutClassForRoute(route, fallback = 'standard') {
     return /^\$?naruto$/i.test(String(route || '').trim()) ? 'long' : fallback;
 }
@@ -7,19 +11,28 @@ export function normalizeCodexReliabilityPolicy(input) {
     const policy = input.reliabilityPolicy || {};
     const timeoutClass = codexTimeoutClassForRoute(input.route, policy.timeoutClass || (input.tier === 'orchestrator' ? 'long' : 'standard'));
     const fallbackIdle = timeoutClass === 'short' ? 20_000 : timeoutClass === 'long' ? 180_000 : 60_000;
+    const backoff = (Array.isArray(policy.capacityBackoffMs) && policy.capacityBackoffMs.length
+        ? policy.capacityBackoffMs
+        : DEFAULT_CAPACITY_BACKOFF_MS).slice(0, 5).map((wait, index) => clampInt(wait, DEFAULT_CAPACITY_BACKOFF_MS[index] ?? 90_000, 0, 10 * 60_000));
     return {
         maxEmptyResultRetries: clampInt(policy.maxEmptyResultRetries, 1, 0, 3),
+        maxCapacityRetries: clampInt(policy.maxCapacityRetries, backoff.length, 0, backoff.length),
+        capacityBackoffMs: backoff,
+        retryCapacityAfterWork: input.sandboxPolicy === 'read-only',
         idleTimeoutMs: clampInt(policy.idleTimeoutMs, fallbackIdle, 1_000, 15 * 60_000),
         timeoutClass
     };
 }
 export async function runWithCodexReliabilityShield(input, runAttempt) {
     const policy = normalizeCodexReliabilityPolicy(input);
+    const deadlineEpochMs = Number(input.reliabilityPolicy?.deadlineEpochMs);
     const attempts = [];
     let selected = null;
     let selectedAttempt = 0;
+    let emptyRetries = 0;
+    let capacityRetries = 0;
     const controls = {};
-    for (let attempt = 1; attempt <= policy.maxEmptyResultRetries + 1; attempt += 1) {
+    for (let attempt = 1;; attempt += 1) {
         const raw = await runAttempt(attempt, controls);
         const continuity = auditToolOutputContinuity(Array.isArray(raw.events) ? raw.events : []);
         const heartbeats = buildKeepaliveHeartbeats(continuity.events);
@@ -37,6 +50,18 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
             missing_tool_result_count: continuity.missingToolResultCount,
             heartbeat_count: heartbeats.length
         };
+        let capacityWaitMs = null;
+        if (report.model_capacity_error) {
+            capacityWaitMs = report.retryable ? nextCapacityWaitMs(policy, capacityRetries, deadlineEpochMs) : null;
+            if (capacityWaitMs === null) {
+                report.retryable = false;
+                report.retry_reason = null;
+                report.blockers = [...report.blockers, 'codex_model_capacity_unavailable'];
+            }
+            else {
+                report.capacity_wait_ms = capacityWaitMs;
+            }
+        }
         attempts.push(report);
         selected = {
             ...raw,
@@ -47,11 +72,20 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
         selectedAttempt = attempt;
         if (report.retryable && report.mcp_auth_error)
             controls.noMcp = true;
-        if (!report.retryable || attempt > policy.maxEmptyResultRetries)
+        if (!report.retryable)
             break;
+        if (capacityWaitMs !== null) {
+            capacityRetries += 1;
+            await new Promise((resolve) => setTimeout(resolve, capacityWaitMs));
+        }
+        else if (emptyRetries < policy.maxEmptyResultRetries) {
+            emptyRetries += 1;
+        }
+        else {
+            break;
+        }
     }
     const blockers = attempts.flatMap((attempt) => attempt.blockers);
-    const modelCapacityRetryCount = attempts.filter((attempt) => attempt.model_capacity_error && attempt.retryable).length;
     const report = {
         schema: CODEX_RELIABILITY_SHIELD_SCHEMA,
         generated_at: nowIso(),
@@ -61,6 +95,7 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
         timeout_class: policy.timeoutClass,
         idle_timeout_ms: policy.idleTimeoutMs,
         max_empty_result_retries: policy.maxEmptyResultRetries,
+        max_capacity_retries: policy.maxCapacityRetries,
         attempts,
         selected_attempt: selectedAttempt,
         retry_count: Math.max(0, selectedAttempt - 1),
@@ -68,8 +103,8 @@ export async function runWithCodexReliabilityShield(input, runAttempt) {
         repaired_tool_result_count: attempts.reduce((sum, attempt) => sum + attempt.repaired_tool_result_count, 0),
         missing_tool_result_count: attempts.reduce((sum, attempt) => sum + attempt.missing_tool_result_count, 0),
         no_duplicate_streamed_output: attempts.slice(0, -1).every((attempt) => attempt.meaningful_event_count === 0),
-        model_capacity_retry_count: modelCapacityRetryCount,
-        selected_model_capacity_fallback: selectedAttempt > 1 && modelCapacityRetryCount > 0,
+        model_capacity_retry_count: capacityRetries,
+        selected_model_capacity_fallback: capacityRetries > 0 && attempts[attempts.length - 1]?.model_capacity_error === false,
         blockers
     };
     const selectedResult = selected || { ok: false, events: [], blockers: ['codex_sdk_attempt_missing'] };
@@ -92,8 +127,6 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
     const blockers = [];
     let retryable = false;
     let retryReason = null;
-    if (modelCapacity)
-        blockers.push('codex_model_capacity_unavailable');
     if (mcpAuth)
         blockers.push('codex_reliability_mcp_auth_error');
     if (!modelCapacity && idle && partial)
@@ -108,11 +141,17 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
         retryable = true;
         retryReason = 'mcp_auth_error_retry_no_mcp';
     }
-    else if (!modelCapacity && !fatal && idle && meaningful.length === 0) {
+    else if (modelCapacity) {
+        if (meaningful.length === 0 || policy.retryCapacityAfterWork) {
+            retryable = true;
+            retryReason = 'model_capacity_backoff_retry';
+        }
+    }
+    else if (!fatal && idle && meaningful.length === 0) {
         retryable = true;
         retryReason = 'stream_idle_before_meaningful_event';
     }
-    else if (!modelCapacity && !fatal && empty) {
+    else if (!fatal && empty) {
         retryable = true;
         retryReason = 'empty_sdk_result_before_meaningful_event';
     }
@@ -128,6 +167,7 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
         fatal_error: fatal,
         mcp_auth_error: mcpAuth,
         model_capacity_error: modelCapacity,
+        capacity_wait_ms: null,
         capacity_fallback_hint: null,
         repaired_tool_result_count: 0,
         missing_tool_result_count: 0,
@@ -136,8 +176,15 @@ export function evaluateCodexReliabilityAttempt(result, events, policy, attempt)
     };
 }
 export function isCodexModelCapacityError(result, events) {
-    const text = collectText(result, events);
-    return /selected model is at capacity|model(?:\s+[\w.-]+)?\s+is\s+at\s+capacity|try a different model|capacity(?:\s+is)?\s+exhausted|temporarily at capacity/i.test(text);
+    return MODEL_CAPACITY_RE.test(collectFailureSignalText(result, events));
+}
+function nextCapacityWaitMs(policy, retriesDone, deadlineEpochMs) {
+    const base = policy.capacityBackoffMs[retriesDone];
+    if (retriesDone >= policy.maxCapacityRetries || base === undefined)
+        return null;
+    const wait = Math.round(base * (0.75 + Math.random() * 0.5));
+    const hasDeadline = Number.isFinite(deadlineEpochMs) && deadlineEpochMs > 0;
+    return hasDeadline && deadlineEpochMs - Date.now() <= wait ? null : wait;
 }
 export function isMissingToolOutputProtocolError(result, events) {
     return /\[No tool output found for (?:custom\s+)?tool call\s+[^\]]+\]/i.test(collectText(result, events));
@@ -175,8 +222,9 @@ export function buildKeepaliveHeartbeats(events) {
 function isMeaningfulEvent(event) {
     const type = String(event?.type || '');
     const itemType = String(event?.item?.type || '');
+    if (type === 'item.completed' && !NON_WORK_ITEM_TYPES.has(itemType))
+        return true;
     return type === 'turn.completed'
-        || type === 'item.completed'
         || itemType === 'agent_message'
         || itemType === 'file_change'
         || itemType === 'command_execution'
@@ -185,8 +233,9 @@ function isMeaningfulEvent(event) {
 function hasFatalError(result, events) {
     if (isMcpAuthError(result, events))
         return false;
-    const text = collectFatalSignalText(result, events);
-    return /\b(?:4\d\d|fatal|unauthorized|forbidden|authrequired|invalid oauth|side-effect applied|partial patch applied)\b/i.test(text);
+    const text = collectFailureSignalText(result, events);
+    return /\b(?:4\d\d|fatal|unauthorized|forbidden|authrequired|invalid oauth|side-effect applied|partial patch applied)\b/i.test(text)
+        || USAGE_LIMIT_RE.test(text);
 }
 function isMcpAuthError(result, events) {
     const text = collectText(result, events);
@@ -206,7 +255,7 @@ function collectText(result, events) {
         ].filter(Boolean).join('\n'))
     ].join('\n');
 }
-function collectFatalSignalText(result, events) {
+function collectFailureSignalText(result, events) {
     return [
         ...(Array.isArray(result.blockers) ? result.blockers : []),
         ...events

package/dist/core/codex-control/codex-sdk-adapter.js

@@ -87,8 +87,24 @@ export async function runRealCodexSdkTask(input, policy) {
         }
     }
     catch (err) {
-        if (!timedOut && controller.signal.aborted !== true && String(err?.name || '') !== 'AbortError')
-            throw err;
+        if (!timedOut && controller.signal.aborted !== true && String(err?.name || '') !== 'AbortError') {
+            const reported = codexReportedFailure(events);
+            if (!reported)
+                throw err;
+            return {
+                ok: false,
+                sdkThreadId: String(thread.id || events.find((event) => event?.type === 'thread.started')?.thread_id || ''),
+                sdkRunId: extractRunId(events),
+                events,
+                finalResponse,
+                structuredOutput: null,
+                blockers: [`codex_sdk_run_failed:${reported.message || 'turn_failed'} (${firstLine(err)})`],
+                liveEventsWritten,
+                runtimeIdentity: runtime.identity,
+                executionPolicy,
+                raw: { failed_event: reported.event, exec_error: String(err?.message || err) }
+            };
+        }
         return {
             ok: false,
             sdkThreadId: String(thread.id || events.find((event) => event?.type === 'thread.started')?.thread_id || ''),
@@ -106,7 +122,7 @@ export async function runRealCodexSdkTask(input, policy) {
     finally {
         clearTimeout(timer);
     }
-    const failed = events.find((event) => event?.type === 'turn.failed' || event?.type === 'error');
+    const failed = codexReportedFailure(events);
     if (failed) {
         return {
             ok: false,
@@ -115,11 +131,11 @@ export async function runRealCodexSdkTask(input, policy) {
             events,
             finalResponse,
             structuredOutput: null,
-            blockers: ['codex_turn_failed'],
+            blockers: [failed.message ? `codex_turn_failed:${failed.message}` : 'codex_turn_failed'],
             liveEventsWritten,
             runtimeIdentity: runtime.identity,
             executionPolicy,
-            raw: { failed_event: failed }
+            raw: { failed_event: failed.event }
         };
     }
     const structuredOutput = parseStructuredOutput(finalResponse, Boolean(input.outputSchema));
@@ -137,6 +153,23 @@ export async function runRealCodexSdkTask(input, policy) {
         raw: { item_count: events.filter((event) => String(event?.type || '').startsWith('item.')).length }
     };
 }
+export function codexReportedFailure(events) {
+    let first = null;
+    for (let index = events.length - 1; index >= 0; index -= 1) {
+        const event = events[index];
+        const type = event?.type;
+        if (type !== 'turn.failed' && type !== 'error')
+            continue;
+        const message = String((type === 'turn.failed' ? event?.error?.message : event?.message) || '').replace(/\s+/g, ' ').trim();
+        if (message)
+            return { event, message: message.slice(0, 300) };
+        first = event;
+    }
+    return first ? { event: first, message: '' } : null;
+}
+function firstLine(err) {
+    return String(err?.message || err).trim().split('\n')[0].trim().slice(0, 200);
+}
 export async function resolveCodexSdkRuntime(_input) {
     return resolveOfficialCodexPackageRuntime({ requestedBy: 'codex-sdk-adapter' });
 }

package/dist/core/commands/agent-bridge-command.js

@@ -90,7 +90,7 @@ export async function inspectAgentBridgeHostCapabilities(root, dependencies, pro
 export function usage() {
     return [
         'Usage: sks agent-bridge setup [--trusted-project] [--json]',
-        '       sks agent-bridge async --prompt "task" [--tools status,stats] [--json]',
+        '       sks agent-bridge async --prompt "task" [--tools status,search] [--json]',
         '',
         'setup: register read-only SKS tools with an external agent host.',
         'async: run native Astra Async tool calling through the registered Codex-LB bridge.',

package/dist/core/commands/basic-cli.js

@@ -1,12 +1,11 @@
 import fsp from 'node:fs/promises';
 import path from 'node:path';
-import { spawnSync } from 'node:child_process';
-import { COMMAND_MANIFEST_LITE } from '../../cli/command-manifest-lite.js';
+import { COMMAND_ALIASES_LITE, COMMAND_MANIFEST_BY_NAME } from '../../cli/command-manifest-lite.js';
 import { flag } from '../../cli/args.js';
 import { printJson, sksTextLogo } from '../../cli/output.js';
 import { ui as cliUi } from '../../cli/cli-theme.js';
-import { PACKAGE_VERSION, ensureDir, nowIso, projectRoot, readJson, rmrf, sksRoot, tmpdir, writeJsonAtomic } from '../fsx.js';
-import { DOLLAR_COMMANDS, USAGE_TOPICS, routePrompt, routeReasoning, reasoningInstruction, sksPrefixedDollarCommand } from '../routes.js';
+import { PACKAGE_VERSION, ensureDir, nowIso, projectRoot, readJson, rmrf, tmpdir, writeJsonAtomic } from '../fsx.js';
+import { DOLLAR_COMMANDS, sksPrefixedDollarCommand } from '../routes.js';
 import { DOLLAR_COMMAND_ALIASES_LITE, DOLLAR_COMMANDS_LITE } from '../routes/dollar-manifest-lite.js';
 import { initProject, normalizeInstallScope, sksCommandPrefix } from '../init.js';
 import { buildFeatureRegistry, validateFeatureRegistry } from '../feature-registry.js';
@@ -18,36 +17,42 @@ import { formatSksUpdateStatusText, runSksUpdateNow, runSksUpdateReview, runSksU
 import { persistSksUpdateNoticeFromVersions } from '../update/update-notice.js';
 import { updateStageFailureDiagnostics } from '../update/update-stage-diagnostics.js';
 import { withSecretPreservationGuard } from '../config/config-migration-journal.js';
-const REMOVED_USAGE_TOPICS = new Set(['db', 'ui']);
 export async function helpCommand(args = []) {
-    const topic = args[0];
-    if (topic)
-        return usageCommand([topic]);
-    console.log(`${sksTextLogo()}\n\nUsage\n`);
-    console.log('  sks');
-    console.log('  sks help [topic]');
-    console.log('  sks commands [--json]');
-    console.log('  sks dollar-commands [--json]');
-    console.log('  sks proof show --json');
-    console.log('');
-    for (const row of commandRows().filter((entry) => entry.maturity !== 'labs')) {
-        console.log(`  ${row.usage.padEnd(58)} ${row.description}`);
+    const topic = args.find((arg) => !arg.startsWith('-'));
+    if (!topic) {
+        const { helpFast } = await import('../../cli/help-fast.js');
+        helpFast();
+        return { ok: true, status: 'help' };
     }
-    console.log('\nThree core promises: Completion Proof for serious routes, Image Voxel TriWiki for visual routes, and release-gated Codex App/Desktop Bridge/hooks/Rust evidence.');
-}
-export function commandsCommand(args = []) {
-    const commands = commandRows();
-    if (flag(args, '--json')) {
-        return printJson({
-            schema: 'sks.command-registry.v1',
-            aliases: ['sks', 'sneakoscope'],
-            commands
-        });
+    if (topic.startsWith('$')) {
+        const wanted = sksPrefixedDollarCommand(topic).toLowerCase();
+        const route = DOLLAR_COMMANDS.find((entry) => entry.command.toLowerCase() === wanted);
+        if (route) {
+            console.log(`${route.command}\n\n${route.route}: ${route.description}`);
+            return { ok: true, status: 'help', topic: route.command };
+        }
+    }
+    else {
+        const name = COMMAND_ALIASES_LITE[topic] || topic;
+        const entry = COMMAND_MANIFEST_BY_NAME[name];
+        if (entry) {
+            const [{ COMMANDS }, { renderManifestHelp }] = await Promise.all([
+                import('../../cli/command-registry.js'),
+                import('../../cli/help.js')
+            ]);
+            const mod = await COMMANDS[name].lazy();
+            console.log(typeof mod.usage === 'function' ? mod.usage(topic) : renderManifestHelp(name, entry));
+            return { ok: true, status: 'help', topic: name };
+        }
     }
-    console.log(`${sksTextLogo()}\n\nCommands\n`);
-    const width = Math.max(...commands.map((entry) => entry.usage.length));
-    for (const entry of commands)
-        console.log(`${entry.usage.padEnd(width)}  ${entry.description}`);
+    console.log(`Unknown help topic: ${topic}`);
+    console.log('Topics: a command from `sks commands`, or a $ route from `sks dollar-commands` (for example `sks help \'$sks-plan\'`).');
+    process.exitCode = 1;
+    return { ok: false, status: 'unknown_topic', topic };
+}
+export async function commandsCommand(args = []) {
+    const { commandsJsonFast, commandsTextFast } = await import('../../cli/commands-fast.js');
+    return flag(args, '--json') ? commandsJsonFast() : commandsTextFast();
 }
 export function dollarCommandsCommand(args = []) {
     const out = { dollar_commands: DOLLAR_COMMANDS_LITE, app_skill_aliases: DOLLAR_COMMAND_ALIASES_LITE };
@@ -58,67 +63,20 @@ export function dollarCommandsCommand(args = []) {
     for (const entry of DOLLAR_COMMANDS_LITE)
         console.log(`${entry.command.padEnd(width)}  ${entry.route}: ${entry.description}`);
     console.log(`\nCanonical Codex App picker skills: ${DOLLAR_COMMAND_ALIASES_LITE.map((entry) => entry.app_skill).join(', ')}`);
-}
-export function aliasesCommand() {
-    console.log('Aliases');
-    console.log('- sks, sneakoscope');
-    console.log('- $ aliases:');
-    for (const entry of DOLLAR_COMMAND_ALIASES_LITE)
-        console.log(`  ${entry.app_skill} -> ${entry.canonical}`);
-}
-export function dfixCommand() {
-    console.log(`SKS Direct Fix Mode
-
-Prompt command:
-  $sks-dfix <tiny direct fix request>
-
-Rules:
-  Apply only the requested tiny copy/config/docs/labels/spacing/translation/simple mechanical edit.
-  Keep verification cheap and explicit.
-  Finish with a DFix completion summary and one Honest check line.`);
-}
-export function usageCommand(args = []) {
-    const topic = args[0] || 'overview';
-    if (topic === 'overview') {
-        console.log(`Usage topics: ${USAGE_TOPICS}`);
-        console.log('Try: sks usage goal, sks usage naruto, sks usage image-ux-review');
-        return;
-    }
-    if (topic === 'seo-geo-optimizer') {
-        console.log('seo-geo-optimizer\n');
-        console.log('Usage: sks seo-geo-optimizer [seo|geo] doctor|audit|plan|apply|verify|status|rollback|fixture [mission|latest] [--mode seo|geo] [--root <path>] [--url <origin>] [--target auto|website|docs|package] [--framework auto|next-app|next-pages|static] [--offline] [--strict] [--json]');
-        console.log('       sks seo-geo-optimizer apply <mission|latest> --mode seo|geo --apply [--include-llms-txt] [--scope <rule-or-path,...>] [--yes] [--json]');
-        console.log('       sks seo-geo-optimizer rollback <mission|latest> --mode seo|geo --apply [--yes] [--json]');
-        console.log('Unified SEO/GEO optimizer audit/plan/apply/verify lifecycle on the search-visibility kernel.');
-        return;
-    }
-    const row = commandRows().find((entry) => entry.name === topic);
-    if (row) {
-        console.log(`${row.name}\n`);
-        console.log(`Usage: ${row.usage}`);
-        console.log(row.description);
-        return;
-    }
-    const route = REMOVED_USAGE_TOPICS.has(String(topic).toLowerCase())
-        ? null
-        : DOLLAR_COMMANDS.find((entry) => entry.command.toLowerCase() === sksPrefixedDollarCommand(topic).toLowerCase());
-    if (route) {
-        console.log(`${sksPrefixedDollarCommand(route.command)}\n`);
-        console.log(`${route.route}: ${route.description}`);
-        return;
-    }
-    console.log(`Unknown usage topic: ${topic}`);
-    console.log(`Known topics: ${USAGE_TOPICS}`);
+    console.log('Command aliases: sks and sneakoscope are the same CLI.');
 }
 export function quickstartCommand() {
     console.log(`Sneakoscope Codex Quickstart
 
-  sks setup --local-only
-  sks doctor
-  sks commands
-  sks dollar-commands
+  sks setup              install hooks and skills (then once per project)
+  sks doctor             check the install; sks doctor --fix repairs it
+  sks commands           every CLI command
+  sks dollar-commands    every Codex App $ route
 
-Ask Codex for ordinary work directly; SKS hooks keep it safe. Use $sks-plan to plan, $sks-naruto or $sks-work to split work across child agents, and $sks-help to see every route.`);
+Then ask Codex for work directly: the main agent does ordinary work itself while
+SKS hooks keep it safe. Use $sks-plan to plan without edits, $sks-naruto or
+$sks-work when you want the work split across child agents, and $sks-help for
+the rest.`);
 }
 export async function updateStatusCommand(args = []) {
     const root = await resolveUpdateProjectRoot(args);
@@ -295,8 +253,21 @@ function applyUpdateCommandExitCode(result) {
         process.exitCode = 1;
 }
 export async function setupCommand(args = []) {
-    if (flag(args, '--help') || flag(args, '-h'))
-        return usageCommand(['setup']);
+    if (flag(args, '--dry-run')) {
+        const refused = {
+            schema: 'sks.setup.v1',
+            ok: false,
+            status: 'dry_run_unsupported',
+            blockers: ['setup_has_no_dry_run'],
+            next_action: '`sks doctor --json` reports what setup would repair without changing anything.'
+        };
+        process.exitCode = 2;
+        if (flag(args, '--json'))
+            printJson(refused);
+        else
+            console.error(`Setup has no dry run; nothing was changed. ${refused.next_action}`);
+        return refused;
+    }
     const root = await projectRoot();
     const { formatHarnessConflictReport, scanHarnessConflicts } = await import('../harness-conflicts.js');
     const conflictScan = await scanHarnessConflicts(root);
@@ -378,48 +349,8 @@ export async function setupCommand(args = []) {
     return result;
 }
 export async function bootstrapCommand(args = []) {
-    if (flag(args, '--help') || flag(args, '-h'))
-        return usageCommand(['bootstrap']);
     return setupCommand(['--local-only', ...args]);
 }
-export async function initCommand(args = []) {
-    if (flag(args, '--help') || flag(args, '-h'))
-        return usageCommand(['init']);
-    return setupCommand(args);
-}
-export async function fixPathCommand(args = []) {
-    const root = await projectRoot();
-    const installScope = installScopeFromArgs(args);
-    let res = null;
-    await withSecretPreservationGuard(root, 'fix-path-command', async () => {
-        res = await initProject(root, { installScope, localOnly: flag(args, '--local-only'), globalCommand: 'sks', force: true });
-    });
-    const readiness = initProjectInstallReadiness(res);
-    const result = {
-        schema: 'sks.fix-path.v1',
-        ok: readiness.ok,
-        status: readiness.status,
-        root,
-        install_scope: installScope,
-        hook_command_prefix: sksCommandPrefix(installScope, { globalCommand: 'sks' }),
-        hooks: path.join(root, '.codex', 'hooks.json'),
-        skill_install: res?.skill_install,
-        blockers: readiness.blockers,
-        warnings: readiness.warnings
-    };
-    if (!result.ok)
-        process.exitCode = 1;
-    if (flag(args, '--json')) {
-        printJson(result);
-        return result;
-    }
-    console.log(`${result.ok ? 'SKS hook path refreshed' : 'SKS hook path refresh blocked'}: ${path.relative(root, result.hooks)}`);
-    for (const warning of readiness.warnings)
-        console.log(`Warning: ${warning}`);
-    for (const blocker of readiness.blockers)
-        console.error(`Blocker: ${blocker}`);
-    return result;
-}
 function initProjectInstallReadiness(res) {
     const manualBlockers = [
         ...(res?.codex_config_install?.manual_blockers || []),
@@ -458,44 +389,6 @@ function initProjectInstallReadiness(res) {
                 : 'completed';
     return { ok, status, blockers, warnings };
 }
-export async function depsCommand(sub = 'check', args = []) {
-    const action = sub || 'check';
-    if (action !== 'check' && action !== 'status') {
-        console.error('Usage: sks deps check [--json] [--yes]');
-        process.exitCode = 1;
-        return;
-    }
-    const npm = whichSync('npm');
-    const nodeOk = Number(process.versions.node.split('.')[0]) >= 20;
-    const root = await sksRoot();
-    const { ensureRelatedCliTools } = await import('../../cli/install-helpers.js');
-    const repairRequested = flag(args, '--yes') || flag(args, '-y');
-    const cliTools = await ensureRelatedCliTools(repairRequested ? args : [...args, '--dry-run']);
-    const codexReady = cliTools.codex.status === 'present' || cliTools.codex.status === 'installed';
-    const result = {
-        schema: 'sks.deps-status.v1',
-        root,
-        ready: Boolean(nodeOk && npm && codexReady),
-        node: { ok: nodeOk, version: process.version },
-        npm: { ok: Boolean(npm), bin: npm },
-        cli_tools: cliTools,
-        next_actions: [
-            ...(!nodeOk ? ['Install Node.js 20.11+.'] : []),
-            ...(!npm ? ['Install npm or a Node.js distribution that includes npm.'] : []),
-            ...(!codexReady ? [`Run sks deps check --yes or npm i -g @openai/codex@latest.`] : [])
-        ]
-    };
-    if (flag(args, '--json'))
-        return printJson(result);
-    console.log('SKS Dependencies');
-    console.log(`Node: ${result.node.ok ? 'ok' : 'missing'} ${result.node.version}`);
-    console.log(`npm:  ${result.npm.ok ? 'ok' : 'missing'} ${result.npm.bin || ''}`.trim());
-    console.log(`Codex CLI: ${cliTools.codex.status}${cliTools.codex.version ? ` ${cliTools.codex.version}` : ''}`);
-    for (const action of result.next_actions)
-        console.log(`Next: ${action}`);
-    if (!result.ready)
-        process.exitCode = 1;
-}
 export async function postinstallCommand(args = []) {
     const { postinstall } = await import('../../cli/install-helpers.js');
     return postinstall({ bootstrap: bootstrapCommand, args });
@@ -584,65 +477,6 @@ export async function selftestRealCommand(args = []) {
     }
     return output;
 }
-export async function reasoningCommand(args = []) {
-    const prompt = args.filter((arg) => !String(arg).startsWith('--')).join(' ').trim();
-    const route = routePrompt(prompt || '$SKS');
-    const info = routeReasoning(route, prompt);
-    const result = {
-        route: route?.command || '$SKS',
-        effort: info.effort,
-        profile: info.profile,
-        reason: info.reason,
-        temporary: true,
-        instruction: reasoningInstruction(info)
-    };
-    if (flag(args, '--json'))
-        return printJson(result);
-    console.log('SKS Reasoning Route');
-    console.log(`Route:   ${result.route}`);
-    console.log(`Effort:  ${result.effort}`);
-    console.log(`Profile: ${result.profile}`);
-}
-export async function autoReviewCommand(sub = 'status', args = []) {
-    const { autoReviewStatus, enableAutoReview, disableAutoReview } = await import('../auto-review.js');
-    const { writeRouteCollaborationArtifacts } = await import('../agents/route-collaboration-ledger.js');
-    const action = sub || 'status';
-    const result = action === 'fixture'
-        ? await reviewNativeAgentFixture()
-        : action === 'enable' || action === 'start'
-            ? await enableAutoReview({ high: flag(args, '--high') })
-            : action === 'disable'
-                ? await disableAutoReview()
-                : await autoReviewStatus();
-    if (flag(args, '--json'))
-        return printJson(result);
-    console.log(JSON.stringify(result, null, 2));
-    async function reviewNativeAgentFixture() {
-        const root = await projectRoot();
-        const { id } = await createMission(root, { mode: 'review', prompt: 'Review native agent collaboration fixture' });
-        const native = await writeRouteCollaborationArtifacts(root, {
-            missionId: id,
-            route: '$Review',
-            routeKey: 'Review',
-            prompt: 'Review route approval safety, verification, and integration through the native agent runtime.',
-            mode: 'REVIEW'
-        });
-        return {
-            schema: 'sks.review-native-agent-fixture.v1',
-            ok: native.ok,
-            mission_id: id,
-            native_agent_collaboration: native
-        };
-    }
-}
-function commandRows() {
-    return COMMAND_MANIFEST_LITE.map((entry) => ({
-        name: entry.name,
-        usage: `sks ${entry.name}`,
-        description: entry.summary,
-        maturity: entry.maturity
-    })).sort((a, b) => a.name.localeCompare(b.name));
-}
 function installScopeFromArgs(args = [], fallback = 'global') {
     if (flag(args, '--project'))
         return 'project';
@@ -651,13 +485,6 @@ function installScopeFromArgs(args = [], fallback = 'global') {
     const index = args.indexOf('--install-scope');
     return normalizeInstallScope(index >= 0 && args[index + 1] ? args[index + 1] : fallback);
 }
-function whichSync(command) {
-    const result = spawnSync(process.platform === 'win32' ? 'where' : 'command', process.platform === 'win32' ? [command] : ['-v', command], {
-        encoding: 'utf8',
-        shell: process.platform !== 'win32'
-    });
-    return result.status === 0 ? String(result.stdout || '').trim().split(/\r?\n/)[0] : null;
-}
 function valueAfter(args = [], name) {
     const index = args.findIndex((arg) => String(arg) === name);
     if (index < 0)

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

@@ -3,7 +3,7 @@ import { DOLLAR_SKILL_NAMES, RECOMMENDED_SKILLS } from '../routes.js';
 export const flag = (args = [], name) => args.includes(name);
 const KNOWN_BOOLEAN_FLAGS = new Set([
     '--json', '--mock', '--execute', '--auto', '--visual', '--research', '--db',
-    '--legacy-goal-runtime', '--help', '-h', '--quiet'
+    '--help', '-h', '--quiet'
 ]);
 export function promptOf(args = [], knownFlags = KNOWN_BOOLEAN_FLAGS) {
     return args.filter((x) => !knownFlags.has(String(x))).join(' ').trim();