sneakoscope 8.0.2 → 8.0.4

package/dist/core/routes.js

@@ -5,7 +5,7 @@ import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_ONLY_POLICY, COD
 import { getdesignReferencePolicyText, imageUxReviewPipelinePolicyText } from './routes/design-policy.js';
 import { PPT_PIPELINE_SKILL_ALLOWLIST, pptPipelineAllowlistPolicyText } from './routes/ppt-policy.js';
 import { normalizeDollarSkillName, prefixKnownSksDollarReferences, sksPrefixedDollarCommand, sksPrefixedSkillName, unprefixedSksSkillName } from './routes/dollar-prefix.js';
-import { classifyTaskProfile, looksLikeDatabaseWorkRequest } from './runtime/task-profile.js';
+import { classifyTaskProfile, isTaskProfile, looksLikeDatabaseWorkRequest } from './runtime/task-profile.js';
 import { legacyCoreSkillNames } from './codex-native/core-skill-manifest.js';
 export * from './routes/constants.js';
 export * from './routes/design-policy.js';
@@ -249,7 +249,7 @@ export const ROUTES = [
         command: '$Naruto',
         mode: 'NARUTO',
         route: 'Codex official subagent workflow',
-        description: '$Naruto prepares a lightweight Codex official subagent workflow. The Sol Max parent owns decomposition, delegates only defensible direct-child slices, reuses bounded query-aware TriWiki attention anchors, waits for every requested thread, integrates the results, and reports scoped verification. Automatic fan-out starts at four for bounded work, six for explicit parallel work, eight for large-scale work, and sixteen for mass cheap-model fan-out on the Luna/Terra lanes; normal expansion is capped at twelve, while the mass lane may expand to sixty-four. The default max_threads of twelve remains a frame budget (cap), never a target; the absolute hard frame cap is two hundred fifty-six, and multi-wave scheduling reuses capacity for requested counts beyond the first wave. Luna Max handles tiny mechanical shards, Terra Medium handles broad search and exploration shards, and Sol handles implementation and judgment; explicit --agents remains authoritative.',
+        description: '$Naruto prepares a lightweight Codex official subagent workflow. The Sol Max parent owns decomposition, delegates only defensible direct-child slices, reuses bounded query-aware TriWiki attention anchors, waits for every requested thread, integrates the results, and reports scoped verification. Automatic fan-out starts at four for bounded work, six for explicit parallel work, eight for large-scale work, and sixteen for mass cheap-model fan-out on the Luna/Terra lanes; normal expansion is capped at twelve, while the mass lane may expand to sixty-four. The default max_threads of twelve remains a frame budget (cap), never a target; the absolute hard frame cap is two hundred fifty-six, and multi-wave scheduling reuses capacity for requested counts beyond the first wave. Luna Max handles tiny mechanical shards, Terra Max handles broad search and exploration shards, and Sol handles implementation and judgment; explicit --agents remains authoritative.',
         requiredSkills: ['naruto', 'pipeline-runner', 'prompt-pipeline', 'honest-mode'],
         dollarAliases: ['$Work'],
         appSkillAliases: ['work', 'from-chat-img'],
@@ -640,20 +640,19 @@ export const COMMAND_CATALOG = [
     { name: 'review', usage: 'sks review [--staged|--diff <ref>] [--fix] [--json]', description: 'Review a diff with machine-evidence findings sorted above LLM review notes.' },
     { name: 'usage', usage: `sks usage [${USAGE_TOPICS}]`, description: 'Print copy-ready workflows for common tasks.' },
     { 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: '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/Codex CLI, 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 status|check|review|now|rollback [--refresh] [--version <version>] [--json] [--dry-run]', description: 'Inspect update-status.v3, review the exact staged operation, update the global package, or run guarded rollback.' },
     { name: 'uninstall', usage: 'sks uninstall [--dry-run] [--yes] [--keep-config] [--keep-data] [--purge-projects] [--json]', description: 'Remove SKS global skills, hooks, menu bar, state, temp files, and optional project residue while preserving user-owned content by default.' },
-    { 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: 'deps', usage: 'sks deps check [--json] [--yes]', description: 'Check Node/npm and Codex CLI readiness; pass --yes to repair missing Codex CLI tooling when supported.' },
     { name: 'codex', usage: 'sks codex compatibility|version|update-status [--refresh]|update|doctor|schema|0.144 [--json]', description: 'Check Codex CLI compatibility/version/update status, run the official `codex update`, and inspect current manifest, capability, and hook-schema evidence.' },
     { name: 'codex-app', usage: 'sks codex-app [check|set-openrouter-key --api-key-stdin|use-openrouter --model <id>|openrouter-status|product-design|chrome-extension|pat status|remote-control]', description: 'Check Codex App install, OpenRouter provider activation, codex-lb key-entry guidance, Product Design plugin readiness, Codex Chrome Extension web verification readiness, PAT-safe status, first-party MCP/plugin readiness, and Codex CLI remote-control availability.' },
     { name: 'codex-native', usage: 'sks codex-native status|feature-broker|invocation-plan|init-deep [--json]', description: 'Inspect Codex Native feature broker readiness, invocation routing, pattern evidence, and managed memory setup.' },
     { name: 'hooks', usage: 'sks hooks explain|status|trust-report|replay|codex-validate|warning-check ... [--json]', description: 'Explain Codex hook events, validate vendored latest 10-event output schemas, replay fixtures, and enforce warning-zero SKS hook policies under the 0.134 compatibility matrix.' },
-    { name: 'codex-lb', usage: 'sks codex-lb status|health|metrics|doctor|circuit|repair|setup ...', description: 'Configure, health-check, repair, and record circuit evidence for codex-lb provider auth without confusing ChatGPT OAuth and proxy keys.' },
+    { name: 'codex-lb', usage: 'sks codex-lb status|connect-test|health|metrics|doctor|circuit|repair|setup ...', description: 'Configure, run a one-request connection proof, health-check, repair, and record circuit evidence for codex-lb provider auth without confusing ChatGPT OAuth and proxy keys.' },
     { name: 'remote', usage: 'sks remote readiness|machines|worker ... [--json]', description: 'Inspect official Codex Remote readiness and the allowlisted proof-aware SSH stdio worker surface.' },
-    { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD. Zellij panes are not official Naruto subagent evidence.' },
-    { name: 'mad-sks', usage: 'sks mad-sks plan|run|apply|sql|apply-migration|status|close|rollback-apply ... | sks --mad [--high]', description: 'Open or inspect MAD-SKS scoped permission workflows, merged SQL-plane execution, and the Zellij permission launcher.' },
-    { 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: 'mad-sks', usage: 'sks mad-sks plan|run|apply|sql|apply-migration|status|close|rollback-apply ... | sks --mad [--high]', description: 'Open or inspect MAD-SKS scoped permission workflows, merged SQL-plane execution, and the native Codex permission launcher.' },
+    { name: 'auto-review', usage: 'sks auto-review status|enable|start [--high] | sks --Auto-review --high', description: 'Enable Codex automatic approval review and launch the native Codex session with the auto-review profile.' },
     { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $sks-dfix and $sks-naruto.' },
     { name: 'fast-mode', usage: 'sks fast-mode on|off|status|clear [--project] [--json]', description: 'Toggle the global Codex Desktop GPT-5.6 Fast default used by $sks-fast-on/$sks-fast-off and keep project worker preference in sync; pass --project for project-local only.' },
     { 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 $sks-with-local-llm-on/$sks-with-local-llm-off and eligible simple worker slices.' },
@@ -688,7 +687,7 @@ export const COMMAND_CATALOG = [
     { name: 'seo-geo-optimizer', usage: 'sks seo-geo-optimizer [seo|geo] doctor|audit|research|strategy|plan|apply|verify|status|rollback|fixture [mission|latest] [--mode seo|geo] [--target auto|website|docs|package] [--include-marketing] [--json]', description: 'Run the unified SEO/GEO optimizer on the shared search-visibility kernel with mode-specific gates, marketing research/strategy, safe apply, and proof.' },
     { name: 'research', usage: 'sks research prepare|run|status ...', description: 'Run long-form real research missions with xhigh agent Eureka ideas, debate, layered sources, paper, novelty, and falsification gates.' },
     { name: 'eval', usage: 'sks eval run|compare|thresholds ...', description: 'Run deterministic context-quality and performance evidence checks.' },
-    { name: 'harness', usage: 'sks harness fixture|review [--json]', description: 'Run Harness Growth Factory fixtures for forgetting, skills, experiments, tool taxonomy, permissions, MultiAgentV2, and Zellij views.' },
+    { name: 'harness', usage: 'sks harness fixture|review [--json]', description: 'Run Harness Growth Factory fixtures for forgetting, skills, experiments, tool taxonomy, permissions, and MultiAgentV2.' },
     { name: 'perf', usage: 'sks perf run|workflow|cold-start [--json] [--iterations N]', description: 'Measure structured GPT-5.6/SKS performance budgets, including cold-start, Proof Field workflow decisions, and fast-lane evidence.' },
     { name: 'bench', usage: 'sks bench core|route-fixtures|blackbox|trust-kernel [--json]', description: 'Measure core trust-kernel hot paths and write performance budget artifacts.' },
     { name: 'proof', usage: 'sks proof show|latest|validate|export|smoke [--json|--md]', description: 'Show, validate, export, or smoke-write the unified Completion Proof Engine surface.' },
@@ -702,7 +701,7 @@ export const COMMAND_CATALOG = [
     { name: 'wiki', usage: 'sks wiki coords|pack|refresh|publish|rebuild-index|validate|validate-shared|wrongness ...', description: 'Build, refresh, publish shared shards, rebuild ignored indexes, validate, and attach wrongness-memory context to RGBA/trig LLM Wiki packs with attention.use_first and attention.hydrate_first for compact recall plus source hydration.' },
     { name: 'memory', usage: 'sks memory build [--json] | sks memory gc [--dry-run]', description: 'Project TriWiki context-pack memory into managed AGENTS.md blocks or run bounded memory cleanup.' },
     { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
-    { name: 'naruto', usage: 'sks naruto run \"task\" [--agents N] [--max-threads N] [--trusted-project] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json] | sks naruto parent-summary --mission M-... --stdin [--json]', description: 'Run or inspect the Codex official subagent workflow with a Sol Max parent and fixed Luna Max mechanical, Sol High implementation, Sol Max judgment, and Terra Medium long-context/tool profiles, max_depth=1, and structured parent-thread completion evidence.' },
+    { name: 'naruto', usage: 'sks naruto run \"task\" [--agents N] [--max-threads N] [--trusted-project] [--json] | sks naruto status|subagents|proof [latest|M-...] [--json] | sks naruto parent-summary --mission M-... --stdin [--json]', description: 'Run or inspect the Codex official subagent workflow with a Sol Max parent and fixed Luna Max mechanical, Sol High implementation, Sol Max judgment, and Terra Max long-context/tool profiles, max_depth=1, and structured parent-thread completion evidence.' },
     { name: 'reasoning', usage: 'sks reasoning ["prompt"] [--json]', description: 'Show SKS temporary reasoning-effort routing: medium for simple tasks, high for logic, xhigh for research.' },
     { name: 'gx', usage: 'sks gx init|render|validate|drift|snapshot [name]', description: 'Create and verify deterministic SVG/HTML visual context cartridges.' },
     { name: 'profile', usage: 'sks profile show|set <model>', description: 'Inspect or set the current SKS model profile metadata.' },
@@ -1213,7 +1212,10 @@ export function narutoDecisionForRoute(route, prompt = '', profile = classifyTas
     if (profile === 'passthrough' || profile === 'answer' || profile === 'tiny-change') {
         return narutoRouteDecision('none', routeId, profile, `task_profile_${profile}_bypass`, true);
     }
-    if (profile === 'bounded-work' || profile === 'parallel-read' || profile === 'parallel-write' || profile === 'high-risk') {
+    if (profile === 'bounded-work') {
+        return narutoRouteDecision('none', routeId, profile, 'task_profile_bounded_work_parent_owned', false);
+    }
+    if (profile === 'parallel-read' || profile === 'parallel-write' || profile === 'high-risk') {
         return narutoRouteDecision('generic_naruto', routeId, profile, `task_profile_${profile}_default_parallel`, false);
     }
     return narutoRouteDecision('none', routeId, profile, `task_profile_${profile}_bypass`, true);
@@ -1262,6 +1264,24 @@ export function looksLikeCodeChangingWork(prompt = '') {
     return /\b(implement|build|make|add|edit|modify|change|fix|refactor|rewrite|migrate|create|delete|remove|rename|update|patch)\b/i.test(text)
         || /(코드|구현|개발|수정|변경|추가|삭제|해결|고쳐|바꿔|리팩터|마이그레이션)/i.test(text);
 }
+export function classifyPromptExecutionEffect(prompt = '') {
+    const text = String(prompt || '').trim();
+    const action = /(해줘|해라|진행|실행|적용|바꿔|수정|설치|삭제|배포|인증|로그인)/i.test(text)
+        || /\b(configure|execute|apply|change|modify|install|delete|remove|deploy|publish|authenticate)\b|\blog\s*in\b|\bsign\s*in\b/i.test(text);
+    if (!action)
+        return 'read';
+    if (/(삭제|제거|지워|delete|remove|uninstall|purge)/i.test(text))
+        return 'delete';
+    if (/(배포|출시|게시|deploy|publish|release)/i.test(text))
+        return 'deploy';
+    if (/(인증|로그인|로그아웃|재연결|authenticate|log\s*(?:in|out)|sign\s*(?:in|out)|reconnect)/i.test(text))
+        return 'auth';
+    if (/(보안|권한|서명|키\s*회전|security|permission|signing|rotate\s+key)/i.test(text))
+        return 'security';
+    if (/(설치|업그레이드|의존성|install|upgrade|dependenc)/i.test(text))
+        return 'dependency';
+    return 'write';
+}
 export function looksLikeExecutionWork(prompt = '') {
     const text = String(prompt || '');
     return looksLikeCodeChangingWork(text)
@@ -1284,7 +1304,7 @@ export function subagentExecutionPolicyText(route, prompt = '') {
     return [
         'Codex subagent workflow: required for this explicit Naruto or parallel task.',
         'The parent agent owns decomposition, integration, scoped verification, and the final answer.',
-        'Delegate only genuinely independent slices. Use Luna Max only for tiny short-context mechanical work, Sol High for ordinary implementation, Sol Max for review/debug/planning/architecture/integration/risk judgment, and Terra Medium for long-context or Computer Use, Browser/Chrome, and image-generation execution.',
+        'Delegate only genuinely independent slices. Use Luna Max only for tiny short-context mechanical work, Sol High for ordinary implementation, Sol Max for review/debug/planning/architecture/integration/risk judgment, and Terra Max for long-context or Computer Use, Browser/Chrome, and image-generation execution.',
         'Parallel writes require disjoint paths; serialize overlapping paths, prohibit nested delegation, avoid duplicate work, wait for all requested agent threads, and close completed threads after collecting results.',
         'Completion evidence comes from official SubagentStart/SubagentStop events plus the parent integration summary, not process counts or PID evidence.'
     ].join(' ');
@@ -1297,7 +1317,7 @@ export function routeReasoning(route, prompt = '') {
     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 === 'Naruto')
-        return narutoRouteReasoning(text);
+        return narutoRouteReasoning(route, text);
     if (route?.id === 'Research' || route?.id === 'AutoResearch')
         return reasoning('xhigh', 'research_or_experiment_route');
     if (route?.id === 'SuperSearch')
@@ -1316,8 +1336,19 @@ export function routeReasoning(route, prompt = '') {
         return reasoning('low', 'route_policy_low');
     return reasoning('medium', 'simple_fulfillment');
 }
-function narutoRouteReasoning(_text = '') {
-    return reasoning('max', 'naruto_parent_sol_max');
+function narutoRouteReasoning(route, text = '') {
+    if (route?.explicit_invocation !== false)
+        return reasoning('max', 'explicit_naruto_parent_sol_max');
+    const profile = isTaskProfile(route?.task_profile)
+        ? route.task_profile
+        : classifyTaskProfile(text);
+    if (profile === 'parallel-read' || profile === 'parallel-write' || profile === 'high-risk') {
+        return reasoning('max', `implicit_naruto_${profile}_sol_max`);
+    }
+    if (profile === 'tiny-change' || profile === 'passthrough' || profile === 'answer') {
+        return reasoning('low', `implicit_naruto_${profile}_lightweight`);
+    }
+    return reasoning('medium', 'implicit_naruto_bounded_parent_medium');
 }
 export function reasoningProfileName(effort) {
     if (effort === 'low')

package/dist/core/runtime/execution-control.js

@@ -0,0 +1,226 @@
+import { nowIso, sha256 } from '../fsx.js';
+export const EXECUTION_CONTROL_SCHEMA = 'sks.execution-control.v1';
+const MAX_TRACKED_IDEMPOTENCY_KEYS = 128;
+export function normalizeExecutionControlBudget(input = {}) {
+    return {
+        max_attempts: boundedInteger(input.max_attempts, 1, 10_000, 1),
+        max_elapsed_ms: boundedInteger(input.max_elapsed_ms, 1, 7 * 24 * 60 * 60 * 1000, 30 * 60 * 1000),
+        max_tool_calls: nullableBoundedInteger(input.max_tool_calls, 1, 1_000_000),
+        max_tokens: nullableBoundedInteger(input.max_tokens, 1, Number.MAX_SAFE_INTEGER),
+        max_no_progress: boundedInteger(input.max_no_progress, 1, 100, 2)
+    };
+}
+export function normalizeExecutionControlState(value, at = nowIso()) {
+    const row = record(value);
+    if (row?.schema !== EXECUTION_CONTROL_SCHEMA)
+        return newExecutionControlState(at);
+    const status = row.status === 'completed' || row.status === 'stopped' ? row.status : 'running';
+    const stopReason = isExecutionStopReason(row.stop_reason) ? row.stop_reason : null;
+    return {
+        schema: EXECUTION_CONTROL_SCHEMA,
+        status,
+        stop_reason: status === 'running' ? null : stopReason,
+        stop_detail: status === 'running' ? null : nonEmptyString(row.stop_detail),
+        created_at: nonEmptyString(row.created_at) || at,
+        updated_at: nonEmptyString(row.updated_at) || at,
+        attempts: nonNegativeInteger(row.attempts),
+        elapsed_ms: nonNegativeInteger(row.elapsed_ms),
+        tool_calls: nonNegativeInteger(row.tool_calls),
+        tokens: nonNegativeInteger(row.tokens),
+        no_progress_streak: nonNegativeInteger(row.no_progress_streak),
+        last_progress_fingerprint: nonEmptyString(row.last_progress_fingerprint),
+        seen_idempotency_keys: uniqueStrings(row.seen_idempotency_keys).slice(-MAX_TRACKED_IDEMPOTENCY_KEYS)
+    };
+}
+export function preflightExecutionControl(current, rawBudget, at = nowIso()) {
+    const budget = normalizeExecutionControlBudget(rawBudget);
+    let state = normalizeExecutionControlState(current, at);
+    if (state.status !== 'running')
+        return decision(false, state, budget);
+    if (state.elapsed_ms >= budget.max_elapsed_ms)
+        state = stopExecutionControl(state, 'time_budget_exhausted', null, at);
+    else if (budget.max_tool_calls !== null && state.tool_calls >= budget.max_tool_calls)
+        state = stopExecutionControl(state, 'tool_budget_exhausted', null, at);
+    else if (budget.max_tokens !== null && state.tokens >= budget.max_tokens)
+        state = stopExecutionControl(state, 'token_budget_exhausted', null, at);
+    else if (state.attempts >= budget.max_attempts)
+        state = stopExecutionControl(state, 'attempt_budget_exhausted', null, at);
+    return decision(state.status === 'running', state, budget);
+}
+export function recordExecutionObservation(current, rawBudget, observation, at = nowIso()) {
+    const budget = normalizeExecutionControlBudget(rawBudget);
+    const state = normalizeExecutionControlState(current, at);
+    if (state.status !== 'running')
+        return state;
+    const fingerprint = executionProgressFingerprint(observation.fingerprint);
+    const idempotencyKey = nonEmptyString(observation.idempotencyKey);
+    const duplicate = Boolean(idempotencyKey && state.seen_idempotency_keys.includes(idempotencyKey));
+    const fingerprintChanged = state.last_progress_fingerprint === null || state.last_progress_fingerprint !== fingerprint;
+    const madeProgress = observation.madeProgress === true
+        || (observation.madeProgress !== false && fingerprintChanged && !duplicate);
+    const noProgressStreak = madeProgress ? 0 : state.no_progress_streak + 1;
+    const seenIdempotencyKeys = idempotencyKey && !duplicate
+        ? [...state.seen_idempotency_keys, idempotencyKey].slice(-MAX_TRACKED_IDEMPOTENCY_KEYS)
+        : [...state.seen_idempotency_keys];
+    let next = {
+        ...state,
+        updated_at: at,
+        attempts: state.attempts + (observation.countAttempt === false ? 0 : 1),
+        elapsed_ms: state.elapsed_ms + nonNegativeInteger(observation.elapsedMs),
+        tool_calls: state.tool_calls + nonNegativeInteger(observation.toolCalls),
+        tokens: state.tokens + nonNegativeInteger(observation.tokens),
+        no_progress_streak: noProgressStreak,
+        last_progress_fingerprint: fingerprint,
+        seen_idempotency_keys: seenIdempotencyKeys
+    };
+    if (observation.userInputRequired === true) {
+        return stopExecutionControl(next, 'user_input_required', 'execution cannot advance without user input', at);
+    }
+    if (next.no_progress_streak >= budget.max_no_progress) {
+        return stopExecutionControl(next, 'no_progress', `same semantic result repeated ${next.no_progress_streak} time(s)`, at);
+    }
+    if (next.elapsed_ms >= budget.max_elapsed_ms)
+        return stopExecutionControl(next, 'time_budget_exhausted', null, at);
+    if (budget.max_tool_calls !== null && next.tool_calls >= budget.max_tool_calls)
+        return stopExecutionControl(next, 'tool_budget_exhausted', null, at);
+    if (budget.max_tokens !== null && next.tokens >= budget.max_tokens)
+        return stopExecutionControl(next, 'token_budget_exhausted', null, at);
+    if (next.attempts >= budget.max_attempts)
+        return stopExecutionControl(next, 'attempt_budget_exhausted', null, at);
+    return next;
+}
+export function completeExecutionControl(current, verified, detail = null, at = nowIso()) {
+    const state = normalizeExecutionControlState(current, at);
+    if (!verified)
+        return stopExecutionControl(state, 'unverified_completion', detail || 'completion lacked applicable runtime proof', at);
+    return {
+        ...state,
+        status: 'completed',
+        stop_reason: 'completed',
+        stop_detail: detail,
+        no_progress_streak: 0,
+        updated_at: at
+    };
+}
+export function stopExecutionControl(current, reason, detail = null, at = nowIso()) {
+    const state = normalizeExecutionControlState(current, at);
+    return {
+        ...state,
+        status: reason === 'completed' ? 'completed' : 'stopped',
+        stop_reason: reason,
+        stop_detail: detail,
+        updated_at: at
+    };
+}
+export function resumeExecutionControl(current, rawBudget, currentFingerprint, at = nowIso()) {
+    const budget = normalizeExecutionControlBudget(rawBudget);
+    const state = normalizeExecutionControlState(current, at);
+    if (state.status === 'completed')
+        return state;
+    const hasBudget = state.attempts < budget.max_attempts
+        && state.elapsed_ms < budget.max_elapsed_ms
+        && (budget.max_tool_calls === null || state.tool_calls < budget.max_tool_calls)
+        && (budget.max_tokens === null || state.tokens < budget.max_tokens);
+    if (!hasBudget)
+        return state;
+    const fingerprintChanged = state.last_progress_fingerprint !== executionProgressFingerprint(currentFingerprint);
+    const budgetExpanded = ['attempt_budget_exhausted', 'tool_budget_exhausted', 'token_budget_exhausted'].includes(String(state.stop_reason || ''));
+    if (!fingerprintChanged && !budgetExpanded)
+        return state;
+    return {
+        ...state,
+        status: 'running',
+        stop_reason: null,
+        stop_detail: null,
+        no_progress_streak: fingerprintChanged ? 0 : state.no_progress_streak,
+        updated_at: at
+    };
+}
+export function executionProgressFingerprint(value) {
+    return `sha256:${sha256(stableJson(value))}`;
+}
+function newExecutionControlState(at) {
+    return {
+        schema: EXECUTION_CONTROL_SCHEMA,
+        status: 'running',
+        stop_reason: null,
+        stop_detail: null,
+        created_at: at,
+        updated_at: at,
+        attempts: 0,
+        elapsed_ms: 0,
+        tool_calls: 0,
+        tokens: 0,
+        no_progress_streak: 0,
+        last_progress_fingerprint: null,
+        seen_idempotency_keys: []
+    };
+}
+function decision(allowed, state, budget) {
+    return {
+        allowed,
+        state,
+        stop_reason: state.stop_reason,
+        remaining_time_ms: Math.max(0, budget.max_elapsed_ms - state.elapsed_ms),
+        remaining_attempts: Math.max(0, budget.max_attempts - state.attempts)
+    };
+}
+function stableJson(value) {
+    if (value === undefined)
+        return '"__undefined__"';
+    if (typeof value === 'number' && !Number.isFinite(value))
+        return JSON.stringify(String(value));
+    if (Array.isArray(value))
+        return `[${value.map(stableJson).join(',')}]`;
+    if (value && typeof value === 'object') {
+        const row = value;
+        return `{${Object.keys(row).sort().map((key) => `${JSON.stringify(key)}:${stableJson(row[key])}`).join(',')}}`;
+    }
+    const encoded = JSON.stringify(value);
+    return encoded === undefined ? '"__unserializable__"' : encoded;
+}
+function record(value) {
+    return value && typeof value === 'object' && !Array.isArray(value) ? value : null;
+}
+function nonNegativeInteger(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return 0;
+    return Math.min(Number.MAX_SAFE_INTEGER, Math.floor(parsed));
+}
+function boundedInteger(value, min, max, fallback) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return fallback;
+    return Math.max(min, Math.min(max, Math.floor(parsed)));
+}
+function nullableBoundedInteger(value, min, max) {
+    if (value === null || value === undefined || value === '')
+        return null;
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed))
+        return null;
+    return Math.max(min, Math.min(max, Math.floor(parsed)));
+}
+function nonEmptyString(value) {
+    const text = String(value || '').trim();
+    return text || null;
+}
+function uniqueStrings(value) {
+    if (!Array.isArray(value))
+        return [];
+    return [...new Set(value.map(nonEmptyString).filter((item) => Boolean(item)))];
+}
+function isExecutionStopReason(value) {
+    return new Set([
+        'completed',
+        'attempt_budget_exhausted',
+        'time_budget_exhausted',
+        'tool_budget_exhausted',
+        'token_budget_exhausted',
+        'no_progress',
+        'user_input_required',
+        'unverified_completion',
+        'explicit_stop'
+    ]).has(String(value || ''));
+}

package/dist/core/runtime/progress-recovery/progress-recovery.js

@@ -0,0 +1,89 @@
+import { randomBytes } from 'node:crypto';
+import { sha256 } from '../../fsx.js';
+export function initialProgressRecoveryState(integritySnapshotHash) {
+    if (!/^[a-f0-9]{64}$/.test(integritySnapshotHash))
+        throw new Error('progress_integrity_snapshot_invalid');
+    return {
+        schema: 'sks.progress-recovery-state.v1', status: 'running', progress: [], last_progress_at: null,
+        warning_time_budget_exceeded: false, pause_cause: null, pause_reason: null, retry_count: 0,
+        integrity_snapshot_hash: integritySnapshotHash, resume_token_hash: null
+    };
+}
+export function recordProgress(state, signal) {
+    if (state.status !== 'running')
+        throw new Error('progress_signal_requires_running_state');
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(signal.id))
+        throw new Error('progress_signal_id_invalid');
+    if (!/^[a-f0-9]{64}$/.test(signal.digest) || !Number.isFinite(Date.parse(signal.observed_at)))
+        throw new Error('progress_signal_invalid');
+    const byIdentity = new Map(state.progress.map((entry) => [`${entry.kind}:${entry.id}:${entry.digest}`, entry]));
+    byIdentity.set(`${signal.kind}:${signal.id}:${signal.digest}`, signal);
+    return { ...state, progress: [...byIdentity.values()], last_progress_at: signal.observed_at };
+}
+export function applyTimeBudgetWarning(state, input) {
+    if (input.budgetMs <= 0)
+        throw new Error('progress_time_budget_invalid');
+    return { ...state, warning_time_budget_exceeded: input.nowMs - input.startedAtMs > input.budgetMs };
+}
+export function classifyRecoveryCause(error) {
+    const code = safeCode(error);
+    if (/^(?:econnreset|econnrefused|etimedout|enotfound|network_|upstream_network_)/.test(code))
+        return { cause: 'network', reason: code };
+    if (/^(?:auth_|credential_|unauthorized|forbidden)/.test(code))
+        return { cause: 'auth', reason: code };
+    if (/^mode_/.test(code))
+        return { cause: 'mode', reason: code };
+    if (/^account_/.test(code))
+        return { cause: 'account', reason: code };
+    if (/^(?:external_config_|catalog_)/.test(code))
+        return { cause: 'external-config', reason: code };
+    if (/^integrity_/.test(code))
+        return { cause: 'integrity', reason: code };
+    return { cause: 'unknown', reason: 'unknown_failure' };
+}
+export async function runWithProgressRecovery(input) {
+    const maxRetries = Math.max(0, Math.min(2, input.maxNetworkRetries ?? 2));
+    let state = input.state;
+    let firstNetworkReason = null;
+    for (let attempt = 0; attempt <= maxRetries; attempt += 1) {
+        try {
+            const value = await input.port.run(attempt);
+            return { value, state: { ...state, status: 'completed', pause_cause: null, pause_reason: null, resume_token_hash: null } };
+        }
+        catch (error) {
+            const failure = input.port.classify(error);
+            const sameNetworkCause = failure.cause === 'network' && (firstNetworkReason === null || firstNetworkReason === failure.reason);
+            if (failure.cause === 'network' && firstNetworkReason === null)
+                firstNetworkReason = failure.reason;
+            if (sameNetworkCause && attempt < maxRetries) {
+                state = { ...state, retry_count: attempt + 1 };
+                continue;
+            }
+            return { value: null, state: pauseState(state, failure.cause, failure.reason, attempt) };
+        }
+    }
+    return { value: null, state: pauseState(state, 'unknown', 'retry_loop_exhausted', maxRetries) };
+}
+export function issueManualResume(state) {
+    if (state.status !== 'paused')
+        throw new Error('progress_resume_requires_paused_state');
+    const token = randomBytes(24).toString('base64url');
+    return { state: { ...state, resume_token_hash: sha256(token) }, token };
+}
+export function confirmManualResume(state, token) {
+    if (state.status !== 'paused' || !state.resume_token_hash || sha256(token) !== state.resume_token_hash) {
+        throw new Error('progress_resume_token_invalid');
+    }
+    return { ...state, status: 'running', pause_cause: null, pause_reason: null, resume_token_hash: null };
+}
+function pauseState(state, cause, reason, retryCount) {
+    return { ...state, status: 'paused', pause_cause: cause, pause_reason: safeReason(reason), retry_count: retryCount, resume_token_hash: null };
+}
+function safeCode(error) {
+    const raw = error instanceof Error ? error.message : String(error || '');
+    const normalized = raw.trim().toLowerCase();
+    return /^[a-z][a-z0-9_]{1,99}$/.test(normalized) ? normalized : 'unknown_failure';
+}
+function safeReason(value) {
+    return /^[a-z][a-z0-9_]{1,99}$/.test(value) ? value : 'unknown_failure';
+}

package/dist/core/runtime/task-profile.js

@@ -15,9 +15,11 @@ const STRONG_DATABASE_DOMAIN_RE = /\b(?:SQL|Supabase|Postgres|PostgreSQL|RLS|Pri
 const GENERIC_DATABASE_DOMAIN_RE = /\bDB\b|디비/i;
 const DATABASE_WORK_RE = /\b(?:apply|execute|run|fix|change|modify|migrate|audit|review|inspect|analy[sz]e|query|seed|backfill|optimi[sz]e|create|alter|drop|truncate|update|delete|repair)\b|적용|실행|수정|변경|검수|검토|점검|분석|조회|쿼리|시드|백필|최적화|생성|추가|삭제|복구|만들어/i;
 const DATABASE_CONTROL_SURFACE_META_RE = /\bsks\s+db\b|\b(?:db|database|migrate|migrations?)\b[\s\S]{0,48}\b(?:command|cli|route|routing|parser|classifier|regex|help|usage|topic|docs?|documentation|constant|keyword|alias)\b|\b(?:command|cli|route|routing|parser|classifier|regex|help|usage|topic|docs?|documentation|constant|keyword|alias)\b[\s\S]{0,48}\b(?:db|database|migrate|migrations?)\b|(?:db|디비|데이터베이스|migration|migrate|마이그레이션)\s*(?:커맨드|명령|명령어|CLI|라우트|라우팅|파서|분류기|정규식|도움말|헬프|사용법|토픽|문서|상수|키워드|별칭)|(?:커맨드|명령|명령어|CLI|라우트|라우팅|파서|분류기|정규식|도움말|헬프|사용법|토픽|문서|상수|키워드|별칭)[\s\S]{0,32}(?:db|디비|데이터베이스|migration|migrate|마이그레이션)/i;
-const PARALLEL_CUE_RE = /\b(parallel|subagents?|one agent per|fan out|multiple files|audit all|all files|independent slices?|naruto|runtime)\b|병렬|하위\s*에이전트|서브\s*에이전트|여러\s*파일|모든\s*파일|전체\s*검토|나루토|분담/i;
+const PARALLEL_CUE_RE = /\b(parallel|subagents?|one agent per|fan out|independent slices?|naruto)\b|병렬|하위\s*에이전트|서브\s*에이전트|나루토|분담/i;
 const CHANGE_RE = /\b(fix|implement|implementation|change|edit|add|remove|delete|drop|modify|refactor|build|create|write|update|rename|rewrite|patch|apply|execute|repair|resolve|solve|publish|release|deploy|migrate)\b|\bwork\s+on\b|고쳐|고치|수정|변경|추가|삭제|구현|리팩터|작성|생성|만들어|업데이트|적용|실행|해결|이름\s*변경|배포|출시|마이그레이션/i;
+const BOUNDED_READ_WORK_RE = /\b(audit|review|inspect|analy[sz]e|diagnose|trace|map|verify|test|check|investigate|evaluate)\b|감사|검토|점검|분석|진단|추적|매핑|검증|테스트|조사|평가/i;
 const TINY_CHANGE_RE = /\b(typo|copy|wording|label|spacing|whitespace|punctuation|spelling|one[-\s]?line|single[-\s]?(?:line|word)|rename only)\b|오타|문구|라벨|띄어쓰기|공백|맞춤법|구두점|한\s*줄|단어\s*하나|이름만\s*변경/i;
+const NON_RUNTIME_TINY_SURFACE_RE = /\b(copy|wording|label|spacing|whitespace|punctuation|spelling|readme|docs?|documentation|comment)\b|문구|라벨|띄어쓰기|공백|맞춤법|구두점|문서|주석/i;
 const EXPLANATION_QUESTION_RE = /^(how\s+(?:do|can|should|would)\s+(?:i|we|you)\b|what\b|why\b|when\b|where\b|which\b|explain\b|tell me how\b)|(?:어떻게|무엇|뭐가|왜|언제|어디|방법|설명)(?:.*(?:인가요|일까요|하나요|해요|할까|\?))?$/i;
 const DIRECT_REQUEST_RE = /^(please\s+|can you\s+|could you\s+|would you\s+)|(?:해줘|해주세요|해\s*주세요|바꿔줘|고쳐줘|수정해줘|구현해줘)/i;
 const EXPLANATION_REQUEST_RE = /^(?:can|could|would) you explain\b|(?:설명|알려)\s*(?:해\s*줘|해\s*주세요|해달라|줘)\s*[.!?]*$/i;
@@ -27,7 +29,11 @@ export function classifyTaskProfile(prompt) {
         return 'passthrough';
     if (looksLikeExplanationQuestion(text))
         return 'answer';
-    if (looksLikeDatabaseWorkRequest(text) || (CHANGE_RE.test(text) && NON_DATABASE_HIGH_RISK_RE.test(text)))
+    const databaseWork = looksLikeDatabaseWorkRequest(text);
+    const highRiskMutation = databaseWork || (CHANGE_RE.test(text) && NON_DATABASE_HIGH_RISK_RE.test(text));
+    if (looksLikeTinyChange(text) && (!highRiskMutation || NON_RUNTIME_TINY_SURFACE_RE.test(text)))
+        return 'tiny-change';
+    if (highRiskMutation)
         return 'high-risk';
     if (PARALLEL_CUE_RE.test(text) && CHANGE_RE.test(text))
         return 'parallel-write';
@@ -35,10 +41,10 @@ export function classifyTaskProfile(prompt) {
         return 'parallel-read';
     if (DATABASE_CONTROL_SURFACE_META_RE.test(text) && DATABASE_WORK_RE.test(text))
         return 'bounded-work';
-    if (looksLikeTinyChange(text))
-        return 'tiny-change';
     if (CHANGE_RE.test(text))
         return 'bounded-work';
+    if (BOUNDED_READ_WORK_RE.test(text))
+        return 'bounded-work';
     return 'answer';
 }
 export function gateProfileForTask(profileOrPrompt) {

package/dist/core/runtime/verification-budget.js

@@ -1,11 +1,20 @@
 export function chooseVerificationBudget(input) {
+    const changedFiles = input.changedFiles.map((file) => String(file || '').replace(/\\/g, '/'));
+    const failedChecks = (input.failedChecks || []).filter(Boolean);
+    const releaseSurface = changedFiles.some((file) => /(?:^|\/)(?:package(?:-lock)?\.json|CHANGELOG\.md|\.github\/workflows\/|src\/core\/release\/|src\/scripts\/(?:prepublish|publish|release))/.test(file));
     if (input.taskProfile === 'passthrough')
         return 'none';
     if (input.taskProfile === 'answer')
         return 'none';
+    if (releaseSurface)
+        return 'release';
+    if (failedChecks.length > 0)
+        return input.taskProfile === 'high-risk' ? 'release' : 'confidence';
     if (input.taskProfile === 'tiny-change')
-        return 'single-check';
+        return changedFiles.length > 1 ? 'affected' : 'single-check';
     if (input.taskProfile === 'high-risk')
         return 'confidence';
+    if (changedFiles.length >= 8)
+        return 'confidence';
     return 'affected';
 }

package/dist/core/safety/intent-contract/intent-contract.js

@@ -0,0 +1,94 @@
+import { createHash } from 'node:crypto';
+import { canonicalJson } from '../../json/canonical.js';
+export function buildIntentContract(input) {
+    const highRiskEffect = ['auth', 'security', 'delete', 'deploy', 'dependency'].includes(input.effect);
+    let risk = highRiskEffect ? 'HEAVY' : 'FAST';
+    if (input.requestedRisk === 'HEAVY')
+        risk = 'HEAVY';
+    if (input.requestedRisk === 'ULTRA') {
+        if (!input.explicitUltraOptIn)
+            throw new Error('intent_ultra_requires_explicit_opt_in');
+        risk = 'ULTRA';
+    }
+    const base = {
+        schema: 'sks.intent-contract.v1',
+        natural_language_effect: normalizeEffectText(input.naturalLanguageEffect),
+        effect: input.effect,
+        observed_changed_paths: [...new Set((input.observedChangedPaths || []).map(normalizeRelativePath))].sort(),
+        canonical_command: normalizeCommand(input.canonicalCommand),
+        target_hashes: [...new Set(input.targetHashes)].sort(),
+        policy_version: safeIdentifier(input.policyVersion, 'intent_policy_version_invalid'),
+        mode_snapshot: input.modeSnapshot,
+        evidence_state: input.evidenceState,
+        retry_budget: Math.max(0, Math.min(2, input.retryBudget ?? 0)),
+        risk,
+        risk_reason: highRiskEffect ? `effect_${input.effect}_requires_heavy` : risk === 'FAST' ? 'effect_is_fast_eligible' : 'user_requested_risk_raise',
+        force: input.force === true
+    };
+    if (!base.target_hashes.length || base.target_hashes.some((hash) => !/^[a-f0-9]{64}$/.test(hash)))
+        throw new Error('intent_target_hash_invalid');
+    const contract = { ...base, contract_hash: stableHash(base) };
+    return deepFreeze(contract);
+}
+export function decideIntentReplay(previous, current) {
+    const reasons = [];
+    if (previous.policy_version !== current.policy_version)
+        reasons.push('policy_version_changed');
+    if (previous.mode_snapshot !== current.mode_snapshot)
+        reasons.push('mode_snapshot_changed');
+    if (JSON.stringify(previous.target_hashes) !== JSON.stringify(current.target_hashes))
+        reasons.push('target_hash_changed');
+    if (previous.effect !== current.effect || previous.canonical_command !== current.canonical_command)
+        reasons.push('intent_effect_changed');
+    if (reasons.length)
+        return { action: 'replan', reasons };
+    if (current.evidence_state !== 'valid') {
+        if (current.risk === 'FAST')
+            return { action: 'refresh_direct_evidence', reasons: ['evidence_expired_or_missing'] };
+        return { action: 'blocked', reasons: ['heavy_evidence_required'] };
+    }
+    return { action: 'reuse', reasons: [] };
+}
+export function terminalStateForVerification(input) {
+    if (input.paused)
+        return 'paused';
+    if (!input.executionOk)
+        return 'failed';
+    if (input.verificationOk !== true)
+        return 'unverified';
+    return 'completed';
+}
+function normalizeEffectText(value) {
+    const text = String(value || '').trim().replace(/\s+/g, ' ');
+    if (!text || text.length > 1000)
+        throw new Error('intent_effect_text_invalid');
+    return text;
+}
+function normalizeRelativePath(value) {
+    const normalized = String(value || '').replace(/\\/g, '/').replace(/^\.\//, '');
+    if (!normalized || normalized.startsWith('/') || normalized.split('/').includes('..'))
+        throw new Error('intent_changed_path_invalid');
+    return normalized;
+}
+function normalizeCommand(value) {
+    const command = String(value || '').trim().replace(/\s+/g, ' ');
+    if (!/^sks(?:\s|$)/.test(command))
+        throw new Error('intent_canonical_command_invalid');
+    return command;
+}
+function safeIdentifier(value, code) {
+    if (!/^[A-Za-z0-9][A-Za-z0-9._:-]{0,199}$/.test(String(value || '')))
+        throw new Error(code);
+    return value;
+}
+function stableHash(value) {
+    return createHash('sha256').update(canonicalJson(value)).digest('hex');
+}
+function deepFreeze(value) {
+    if (value && typeof value === 'object' && !Object.isFrozen(value)) {
+        Object.freeze(value);
+        for (const child of Object.values(value))
+            deepFreeze(child);
+    }
+    return value;
+}

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

@@ -63,8 +63,6 @@ function scopeForKind(kind) {
             return 'codex_app_process';
         case 'codex_lb_auth_change':
             return 'codex_lb_auth';
-        case 'zellij_install':
-            return 'zellij_install';
         case 'skill_snapshot_promotion':
             return 'skill_snapshot_promotion';
         default: