sneakoscope 3.1.7 → 3.1.9

package/dist/core/questions.js

@@ -1,7 +1,8 @@
 import path from 'node:path';
-import { writeJsonAtomic, writeTextAtomic } from './fsx.js';
+import { nowIso, sha256, writeJsonAtomic, writeTextAtomic } from './fsx.js';
 import { buildQaLoopQuestionSchema } from './qa-loop.js';
 import { CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_WEB_VERIFICATION_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, hasFromChatImgSignal } from './routes.js';
+export const REQUEST_INTAKE_ARTIFACT = 'request-intake.json';
 export function buildQuestionSchemaForRoute(route, prompt) {
     if (String(route?.id || '') === 'QALoop')
         return buildQaLoopQuestionSchema(prompt);
@@ -222,6 +223,8 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
     const versionWork = /버전|version|bump|release|publish:dry|npm\s+pack/.test(lower);
     const installWork = /bootstrap|postinstall|doctor|deps|tmux|homebrew|first install|최초\s*설치|설치\s*ux|셋업|setup/.test(lower);
     const questionGateWork = /모호|ambiguity|clarification|질문|triwiki|추론|infer|predict|예측|answers?\.json|decision-contract/.test(lower);
+    const requestIntakeWork = /(모호|ambiguity|ambiguous|vague|rough|의도|intent|요청사항|requirements?|프롬프트|prompt|triwiki|위키|wiki)/.test(lower)
+        && /(파이프라인|pipeline|변환|transform|rewrite|compile|리스트|list|누락|missing|의도|intent|request[- ]?intake|intake)/.test(lower);
     const uiuxWork = /\b(ui|modal|screen|button|visual|design|layout|component|prototype|frontend)\b|화면|버튼|모달|디자인|레이아웃|컴포넌트|프론트|시각|발표자료|디자인\s*시스템/.test(lower);
     const presentationWork = looksLikePresentationArtifactPrompt(lower);
     const dbWork = new RegExp(["\\bdb\\b", "database", "schema", "migration", "tab" + "le", "col" + "umn", "rls", "supabase", "postgres", "sql", "테이블", "마이그레이션", "스키마", "컬럼", "열", "행", "데이터베이스"].join("|")).test(lower);
@@ -247,12 +250,13 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
         && !versionWork
         && !presentationWork
         && !chatCaptureWork;
-    const kind = versionWork ? 'version' : chatCaptureWork ? 'chat_capture' : triwikiAuditWork ? 'triwiki_audit' : effectivePrioritySignalWork ? 'priority' : questionGateWork ? 'questions' : installWork ? 'install' : null;
+    const kind = versionWork ? 'version' : chatCaptureWork ? 'chat_capture' : triwikiAuditWork ? 'triwiki_audit' : effectivePrioritySignalWork ? 'priority' : requestIntakeWork ? 'request_intake' : questionGateWork ? 'questions' : installWork ? 'install' : null;
     const goals = {
         version: version ? `sneakoscope 버전을 ${version}로 올린다` : 'sneakoscope 버전을 다음 patch 버전으로 올린다',
         chat_capture: 'From-Chat-IMG로 채팅 요구사항과 첨부 원본 이미지를 매칭해 고객사 작업 지시서를 만들고 반영한다',
         triwiki_audit: 'TriWiki가 반복 실수를 막는지 검수하고, 실패 경로를 코드와 검증으로 개선한다',
         priority: '강한 불만과 반복 요청을 TriWiki 우선순위 신호로 기록한다',
+        request_intake: '모호한 사용자 요청을 TriWiki 기반 request-intake로 해석하고, 누락 없는 요구사항 목록과 실행용 변환 프롬프트를 pipeline에 전달한다',
         questions: '예측 가능한 답은 추론하고 실제 모호한 항목만 질문한다',
         presentation: '청중과 STP 전략에 맞는 HTML 기반 발표자료/PDF 산출물을 만든다',
         install: 'SKS 최초 설치와 bootstrap을 한 번에 준비 상태까지 연결한다'
@@ -262,6 +266,7 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
         chat_capture: ['From-Chat-IMG activates chat-image intake only here', 'all visible chat requirements are listed before implementation', `${FROM_CHAT_IMG_COVERAGE_ARTIFACT} maps every customer request, screenshot region, and attachment to work-order item(s)`, `${FROM_CHAT_IMG_CHECKLIST_ARTIFACT} is updated as each request, image match, work item, scoped QA-LOOP, and verification step is completed`, `${FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT} records temporary TriWiki-backed session context with retention metadata`, `${FROM_CHAT_IMG_QA_LOOP_ARTIFACT} proves QA-LOOP ran over the exact customer-request work-order range after implementation`, 'unresolved_items is empty before Team completion', 'scoped_qa_loop_completed is true with zero unresolved QA findings', 'Web/browser visual inspection uses Codex Chrome Extension readiness first; native Mac/non-web visual inspection uses Codex Computer Use when available', CODEX_WEB_VERIFICATION_POLICY, CODEX_COMPUTER_USE_ONLY_POLICY, 'client requests follow normal SKS gates and verification'],
         triwiki_audit: ['TriWiki ingestion, voxel attention, and contract consumption paths are inspected against current code', 'repeat-mistake prevention gaps are fixed in the relevant code path or blocked with evidence', 'regression coverage proves fresh/high-weight mistake memory can influence future missions', 'final status separates supported behavior from anything still unverified'],
         priority: ['strong feedback raises required_weight', 'request topics are counted in wiki packs', 'future inference uses priority signals'],
+        request_intake: ['request-intake.json records original prompt, interpreted intent, source-order requirements, wiki context used, and transformed prompt', 'pipeline-plan.json attaches request_intake metadata and execution_prompt from request-intake.transformed_prompt', 'decision-contract.json preserves the same request-intake artifact when a contract is sealed'],
         questions: ['predictable answers are inferred', 'partial answers can seal contracts', 'only unresolved changing slots remain visible'],
         presentation: ['audience profile and STP strategy are explicit before artifact creation', 'target pain points map to proposed solution moments', 'decision context and likely objections are sealed before storyboarding', 'presentation format, device, and delivery context are fixed before design work'],
         install: ['bootstrap/deps initialize readiness', 'missing runtime deps show repair actions', 'readiness output is concrete']
@@ -381,6 +386,222 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
     }
     return { answers: inferred, notes };
 }
+export function buildRequestIntake(prompt, explicitAnswers = {}, opts = {}) {
+    const originalPrompt = String(prompt || '').trim();
+    const inferred = inferAnswersForPrompt(originalPrompt, explicitAnswers);
+    const answers = { ...(inferred.answers || {}), ...(explicitAnswers || {}) };
+    const ambiguity = buildAmbiguityAssessment(originalPrompt, explicitAnswers);
+    const wikiContext = summarizeWikiContext(opts.wikiContext);
+    const promptRequirements = promptRequirementItems(originalPrompt);
+    const semanticRequirements = semanticRequirementItems(originalPrompt);
+    const acceptance = toStringList(answers.ACCEPTANCE_CRITERIA);
+    const constraints = toStringList(answers.RISK_BOUNDARY);
+    const nonGoals = toStringList(answers.NON_GOALS);
+    const requirements = dedupeRequirementItems([
+        ...promptRequirements,
+        ...semanticRequirements,
+        ...acceptance.map((text, index) => requirementItem('acceptance', index + 1, text, 'inferred_acceptance_criteria')),
+        ...constraints.map((text, index) => requirementItem('constraint', index + 1, text, 'inferred_safety_constraint'))
+    ]);
+    const goal = String(answers.GOAL_PRECISE || originalPrompt || '사용자 요청을 현재 코드 기준으로 구현한다').trim();
+    const targetSignals = extractTargetSignals(originalPrompt);
+    const riskSignals = extractRiskSignals(originalPrompt, constraints);
+    const transformedPrompt = buildTransformedPrompt({
+        originalPrompt,
+        goal,
+        wikiContext,
+        requirements,
+        constraints,
+        acceptance,
+        nonGoals,
+        targetSignals,
+        riskSignals,
+        ambiguity
+    });
+    return {
+        schema: 'sks.request-intake.v1',
+        generated_at: nowIso(),
+        prompt_hash: sha256(originalPrompt).slice(0, 16),
+        original_prompt: originalPrompt,
+        interpreted_intent: {
+            goal,
+            source: 'prompt_plus_triwiki_current_code_defaults',
+            confidence: ambiguity.ready_for_contract ? 'high' : ambiguity.overall_score <= 0.35 ? 'medium' : 'needs_human_only_if_scope_changes'
+        },
+        ambiguity_assessment: ambiguity,
+        wiki_context_used: wikiContext,
+        request_items: requirements,
+        requirements,
+        constraints,
+        acceptance_criteria: acceptance,
+        non_goals: nonGoals,
+        target_signals: targetSignals,
+        risk_signals: riskSignals,
+        transformed_prompt: transformedPrompt,
+        pipeline_usage: {
+            artifact: REQUEST_INTAKE_ARTIFACT,
+            read_before_pipeline_stage: true,
+            use_transformed_prompt_for_execution: true,
+            preserve_original_prompt: true,
+            ask_user_only_for_scope_safety_behavior_or_acceptance_changes: true
+        }
+    };
+}
+function summarizeWikiContext(wikiContext = null) {
+    const claims = Array.isArray(wikiContext?.claims) ? wikiContext.claims : [];
+    const useFirstIds = new Set((wikiContext?.attention?.use_first || []).map((row) => Array.isArray(row) ? row[0] : row?.id).filter(Boolean));
+    const hydrateFirstIds = new Set((wikiContext?.attention?.hydrate_first || []).map((row) => Array.isArray(row) ? row[0] : row?.id).filter(Boolean));
+    return {
+        source: wikiContext ? '.sneakoscope/wiki/context-pack.json' : 'unavailable',
+        attention_mode: wikiContext?.attention?.mode || null,
+        use_first_ids: [...useFirstIds].slice(0, 8),
+        hydrate_first_ids: [...hydrateFirstIds].slice(0, 8),
+        claims: claims.slice(0, 8).map((claim) => ({
+            id: claim.id || claim.claim_id || null,
+            trust: claim.trust_score || claim.trust || null,
+            source: claim.source || claim.source_path || null,
+            summary: String(claim.claim || claim.summary || claim.text || '').slice(0, 320)
+        }))
+    };
+}
+function promptRequirementItems(prompt) {
+    const cleaned = prompt
+        .replace(/(?:^|\s)\$[A-Za-z0-9_-]+(?:\s|$)/g, ' ')
+        .replace(/\s+/g, ' ')
+        .trim();
+    if (!cleaned)
+        return [];
+    const sourceChunks = cleaned
+        .split(/\n+|(?:^|\s)[-*]\s+/)
+        .flatMap((chunk) => splitLooseClauses(chunk))
+        .map((chunk) => chunk.trim())
+        .filter(Boolean);
+    const chunks = sourceChunks.length ? sourceChunks : [cleaned];
+    return chunks.slice(0, 12).map((text, index) => requirementItem('prompt', index + 1, text, 'source_prompt_order'));
+}
+function splitLooseClauses(text) {
+    const compact = String(text || '').trim();
+    if (compact.length < 80)
+        return [compact].filter(Boolean);
+    const pieces = compact.split(/\s+(?=(?:그리고|또|또한|그걸로|해당|이거는|이건|너가|우리|다음|then|and)\b)/i);
+    return pieces.length > 1 ? pieces : [compact];
+}
+function semanticRequirementItems(prompt) {
+    const text = String(prompt || '');
+    const lower = text.toLowerCase();
+    const items = [];
+    const add = (text, confidence = 0.88) => items.push({
+        id: `REQ-S${String(items.length + 1).padStart(2, '0')}`,
+        kind: 'semantic_requirement',
+        source: 'semantic_prompt_signal',
+        text,
+        required: true,
+        confidence
+    });
+    if (/모호|ambiguous|rough|대충|애매/.test(lower))
+        add('모호한 사용자 입력을 그대로 실행하지 말고 intent intake 단계에서 명확한 실행 요청으로 해석한다.');
+    if (/위키|triwiki|wiki|memory|기억/.test(lower))
+        add('TriWiki/context-pack과 현재 코드 기본값을 참고해 사용자 의도와 반복 선호를 보강한다.');
+    if (/의도|intent|목적/.test(lower) && /명확|파악|extract|understand/.test(lower))
+        add('사용자 의도를 Goal, Context, Constraints, Done-when 형태로 명확히 정리한다.');
+    if (/리스트|list|누락|빠짐|requirements?|요청사항/.test(lower))
+        add('요청사항을 source order 기준으로 누락 없이 리스트업하고 각 항목을 실행 작업으로 매핑한다.');
+    if (/프롬프트|prompt/.test(lower) && /변환|바꿔|rewrite|transform|compile|최적/.test(lower))
+        add('원문 요청을 파이프라인 실행에 적합한 transformed prompt로 변환한다.');
+    if (/파이프라인|pipeline/.test(lower) && /(태워|전달|route|run|execute|투입)/.test(lower))
+        add('변환된 prompt와 request-intake artifact를 실제 route pipeline에 전달한다.');
+    return items;
+}
+function requirementItem(kind, index, text, source) {
+    return {
+        id: `REQ-${String(index).padStart(3, '0')}`,
+        kind,
+        source,
+        text: String(text || '').trim(),
+        required: true,
+        confidence: source === 'source_prompt_order' ? 1 : 0.86
+    };
+}
+function dedupeRequirementItems(items = []) {
+    const seen = new Set();
+    const out = [];
+    for (const item of items) {
+        const text = String(item.text || '').replace(/\s+/g, ' ').trim();
+        if (!text)
+            continue;
+        const key = text.toLowerCase();
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        out.push({ ...item, id: `REQ-${String(out.length + 1).padStart(3, '0')}`, text });
+    }
+    return out;
+}
+function toStringList(value) {
+    if (Array.isArray(value))
+        return value.map((item) => String(item || '').trim()).filter(Boolean);
+    const text = String(value || '').trim();
+    if (!text)
+        return [];
+    return text.split(/\n+/).map((item) => item.trim()).filter(Boolean);
+}
+function extractTargetSignals(prompt) {
+    const text = String(prompt || '');
+    const paths = [...text.matchAll(/(?:src|test|tests|scripts|docs|README|CHANGELOG|package\.json|\.sneakoscope|\.agents|\.codex)\/?[A-Za-z0-9._/\-]*/g)].map((m) => m[0]);
+    const commands = [...text.matchAll(/\$[A-Za-z0-9_-]+/g)].map((m) => m[0]);
+    const urls = [...text.matchAll(/https?:\/\/[^\s)\]}>,]+/g)].map((m) => m[0]);
+    return {
+        paths: [...new Set(paths)].slice(0, 12),
+        dollar_commands: [...new Set(commands)].slice(0, 12),
+        urls: [...new Set(urls)].slice(0, 8)
+    };
+}
+function extractRiskSignals(prompt, constraints = []) {
+    const lower = String(prompt || '').toLowerCase();
+    const risks = [];
+    if (promptHasRisk(lower))
+        risks.push('high_risk_surface_detected');
+    if (promptNeedsExplicitRiskBoundary(lower))
+        risks.push('explicit_risk_boundary_required');
+    if (/db|database|supabase|postgres|sql|schema|migration|데이터베이스|스키마|마이그레이션/.test(lower))
+        risks.push('database_safety');
+    if (/browser|webapp|localhost|chrome|스크린샷|화면|ui|ux|visual|웹/.test(lower))
+        risks.push('visual_or_browser_evidence');
+    if (/publish|release|version|배포|릴리즈|버전/.test(lower))
+        risks.push('release_surface');
+    return {
+        risks: [...new Set(risks)],
+        constraints
+    };
+}
+function buildTransformedPrompt(input) {
+    const requirementLines = (input.requirements || []).map((item, index) => `${index + 1}. ${item.text}`);
+    const wikiLines = (input.wikiContext?.claims || []).slice(0, 5).map((claim) => `- ${claim.id || 'wiki-claim'}: ${claim.summary}`);
+    return [
+        '# SKS Wiki-Informed Execution Prompt',
+        '',
+        '## Goal',
+        input.goal,
+        '',
+        '## Original Prompt',
+        input.originalPrompt || '(empty)',
+        '',
+        '## Wiki Context To Use First',
+        ...(wikiLines.length ? wikiLines : ['- No current TriWiki claims were available; rely on current code and conservative SKS defaults.']),
+        '',
+        '## Requirements',
+        ...(requirementLines.length ? requirementLines : ['1. Implement the user request using current code context.']),
+        '',
+        '## Constraints',
+        ...((input.constraints || []).length ? input.constraints.map((row) => `- ${row}`) : ['- Preserve existing behavior unless the request explicitly changes it.', '- Do not create unrequested fallback implementation code.', '- Do not run destructive or live-data mutation commands.']),
+        '',
+        '## Done When',
+        ...((input.acceptance || []).length ? input.acceptance.map((row) => `- ${row}`) : ['- Relevant implementation is complete.', '- Focused verification passes or unavailable checks are explicitly justified.', '- Final response states changed, verified, and unverified items.']),
+        '',
+        '## Pipeline Instruction',
+        'Read request-intake.json first, execute this transformed prompt through the selected SKS route, refresh/validate TriWiki after findings or artifact changes, and finish with SKS Honest Mode.'
+    ].join('\n');
+}
 export function buildQuestionSchema(prompt) {
     const lower = String(prompt || '').toLowerCase();
     const domainHints = [];
@@ -438,6 +659,7 @@ export function buildQuestionSchema(prompt) {
         slots.push({ id: 'DB_MIGRATION_APPLY_ALLOWED', question: 'migration 적용이 필요할 경우 어디까지 허용하나요?', required: true, type: 'enum', options: ['no', 'local_only', 'preview_branch_only'] }, { id: 'DB_READ_ONLY_QUERY_LIMIT', question: 'MCP/SQL read-only 조회 시 기본 LIMIT를 몇으로 둘까요?', required: true, type: 'string' });
     }
     const inferred = inferAnswersForPrompt(prompt);
+    const requestIntake = buildRequestIntake(prompt, inferred.answers);
     const inferredSlots = new Set(Object.keys(inferred.answers));
     const askedSlots = [];
     return {
@@ -446,6 +668,7 @@ export function buildQuestionSchema(prompt) {
         prompt,
         domain_hints: domainHints,
         ambiguity_assessment: ambiguity,
+        request_intake: requestIntake,
         inferred_answers: inferred.answers,
         inference_notes: inferred.notes,
         slots: askedSlots
@@ -478,6 +701,20 @@ export function questionsMarkdown(schema) {
         lines.push(`- unresolved dimensions: ${(schema.ambiguity_assessment.unresolved_dimensions || []).join(', ') || 'none'}`);
         lines.push(`- legacy question budget ignored: ${schema.ambiguity_assessment.question_budget}`);
     }
+    if (schema.request_intake) {
+        const intake = schema.request_intake;
+        lines.push('');
+        lines.push('## Request Intake');
+        lines.push('');
+        lines.push(`- artifact: ${REQUEST_INTAKE_ARTIFACT}`);
+        lines.push(`- interpreted goal: ${intake.interpreted_intent?.goal || '(none)'}`);
+        lines.push(`- requirement count: ${(intake.requirements || []).length}`);
+        lines.push(`- wiki context: ${intake.wiki_context_used?.source || 'unavailable'}`);
+        lines.push('');
+        lines.push('```markdown');
+        lines.push(intake.transformed_prompt || '');
+        lines.push('```');
+    }
     if (schema.inferred_answers && Object.keys(schema.inferred_answers).length) {
         lines.push('');
         lines.push('## Inferred Answers');

package/dist/core/routes.js

@@ -30,7 +30,7 @@ export const FROM_CHAT_IMG_CHECKLIST_ARTIFACT = 'from-chat-img-checklist.md';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT = 'from-chat-img-temp-triwiki.json';
 export const FROM_CHAT_IMG_QA_LOOP_ARTIFACT = 'from-chat-img-qa-loop.json';
 export const FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS = 5;
-export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|goal|fast-mode|research|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust';
+export const USAGE_TOPICS = 'install|setup|bootstrap|root|deps|zellij|tmux|auto-review|team|qa-loop|ppt|image-ux-review|computer-use|goal|fast-mode|research|db|git|codex|codex-app|codex-native|hooks|features|all-features|dfix|commit|commit-and-push|design|imagegen|dollar|context7|xai|pipeline|reasoning|guard|conflicts|versioning|eval|harness|hproof|gx|wiki|wrongness|code-structure|proof-field|skill-dream|rust';
 export const CODEX_COMPUTER_USE_EVIDENCE_SOURCE = 'codex_computer_use';
 export const CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE = 'codex_chrome_extension';
 export const CODEX_IMAGEGEN_EVIDENCE_SOURCE = 'codex_app_imagegen_gpt_image_2';
@@ -636,10 +636,9 @@ export const COMMAND_CATALOG = [
     { 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: 'auth', usage: 'sks auth status|health|repair|setup --host <domain> --api-key <key>', description: 'Shortcut for codex-lb provider auth status, health, repair, and setup commands.' },
     { name: 'zellij', usage: 'sks zellij status|repair [--json] | sks naruto dashboard latest | sks --mad', description: 'Inspect Zellij runtime status, explain repair (no auto-install), and open the SKS Zellij runtime used by MAD and Naruto lane UI.' },
     { name: 'tmux', usage: 'sks tmux [--json]', description: 'Show the removed-runtime migration notice and point operators to Zellij.' },
-    { name: 'mad', usage: 'sks --mad [--high]', description: 'Open a one-shot Zellij Codex CLI workspace with the SKS MAD full-access auto-review profile.' },
+    { name: 'mad-sks', usage: 'sks mad-sks plan|run|status|proof ... | sks --mad [--high]', description: 'Open or inspect MAD-SKS scoped permission workflows 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: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DFix and $Naruto.' },
     { 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.' },
@@ -650,6 +649,7 @@ export const COMMAND_CATALOG = [
     { name: 'qa-loop', usage: 'sks qa-loop prepare|answer|run|status ...', description: 'Dogfood UI/API as human proxy with safety gates, safe fixes, rechecks, Codex Chrome Extension-first web UI evidence, report.' },
     { name: 'ppt', usage: 'sks ppt build|status <mission-id|latest> [--json]', description: 'Build or inspect $PPT HTML/PDF artifacts from a sealed presentation decision contract.' },
     { name: 'image-ux-review', usage: 'sks ux-review run --image <path> --fix --json | sks image-ux-review status <mission-id|latest> [--json]', description: 'Run or inspect $Image-UX-Review gpt-image-2/imagegen annotated UI/UX review artifacts, issue ledgers, safe fix loops, recapture, and proof gates.' },
+    { name: 'computer-use', usage: 'sks computer-use import|status|smoke|require ... [--json]', description: 'Record native Mac/non-web Computer Use visual evidence while keeping web verification on the Chrome Extension path.' },
     { name: 'context7', usage: 'sks context7 check|setup|tools|resolve|docs|evidence ...', description: 'Check, configure, and call the local Context7 MCP requirement.' },
     { name: 'xai', usage: 'sks xai check|setup|status|docs [--scope project|global] [--url <u>|--command <c>] ...', description: 'Set up and check the optional xAI/Grok Live Search MCP provider for source intelligence.' },
     { name: 'recallpulse', usage: 'sks recallpulse run|status|eval|governance|checklist <mission-id|latest>', description: 'Run report-only RecallPulse active recall, durable status, proof capsule, evidence envelope, and governance checks.' },
@@ -691,7 +691,6 @@ export const COMMAND_CATALOG = [
     { 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.' },
     { name: 'gc', usage: 'sks gc [--dry-run] [--json]', description: 'Compact oversized logs and prune stale runtime artifacts.' },
-    { name: 'memory', usage: 'sks memory [--dry-run] [--json]', description: 'Alias for SKS garbage collection and retention handling.' },
     { name: 'stats', usage: 'sks stats [--json]', description: 'Show package and .sneakoscope storage size.' }
 ];
 export function routeById(id) {

package/dist/core/version.js

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

package/dist/scripts/agent-native-release-gate.js

@@ -206,25 +206,34 @@ function assertReleaseScripts() {
     for (const name of required) {
         assertGate(Boolean(pkg.scripts?.[name]), `package script missing ${name}`);
     }
-    assertGate(String(pkg.scripts?.['release:check'] || '').includes('release:check:parallel'), 'release:check must delegate to the parallel P0 DAG');
+    const releaseCheck = String(pkg.scripts?.['release:check'] || '');
+    const affectedReleaseCheck = String(pkg.scripts?.['release:check:affected'] || '');
+    const delegatesToParallel = releaseCheck.includes('release:check:parallel');
+    const delegatesToAffectedDag = releaseCheck.includes('release:check:affected')
+        && affectedReleaseCheck.includes('release-gate-dag-runner')
+        && /--preset\s+affected/.test(affectedReleaseCheck);
+    const delegatesDirectlyToDag = releaseCheck.includes('release-gate-dag-runner')
+        && /--preset\s+(?:release|affected)/.test(releaseCheck);
+    assertGate(delegatesToParallel || delegatesToAffectedDag || delegatesDirectlyToDag, 'release:check must delegate to the parallel P0 DAG or v2 affected/release DAG', { release_check: releaseCheck, release_check_affected: affectedReleaseCheck });
 }
 function assertRouteNativeBlackbox(routeName) {
+    const routeFixtureArgs = ['--agents', '5', '--work-items', '8', '--target-active-slots', '5', '--minimum-work-items', '5', '--max-queue-expansion', '10', '--mock', '--json'];
     if (routeName === 'team') {
-        const result = runSksJson(['team', 'native backend fixture', '--mock', '--json']);
+        const result = runSksJson(['team', 'native backend fixture', ...routeFixtureArgs, '--no-open-zellij']);
         assertGate(result.mock === true, 'Team mock blackbox did not execute', result);
         assertGate(result.native_agent_run?.proof?.ok === true, 'Team blackbox missing native agent proof', result.native_agent_run?.proof);
         assertGate(!JSON.stringify(result).includes('analysis_scout'), 'Team runtime artifact leaked legacy analysis_scout');
     }
     if (routeName === 'research') {
         const prepared = runSksJson(['research', 'prepare', 'native backend fixture', '--json']);
-        const result = runSksJson(['research', 'run', prepared.mission_id, '--mock', '--json']);
+        const result = runSksJson(['research', 'run', prepared.mission_id, ...routeFixtureArgs, '--native-proof-only']);
         assertGate(result.ok === true, 'Research mock blackbox did not pass', result);
         assertGate(result.gate?.gate?.native_agent_proof === true || result.gate?.native_agent_proof === true || result.proof?.ok === true, 'Research proof missing native agent evidence artifact', result);
         assertGate(!JSON.stringify(result).includes('scout-ledger'), 'Research runtime artifact leaked scout-ledger as SSOT');
     }
     if (routeName === 'qa') {
         const prepared = runSksJson(['qa-loop', 'prepare', 'native backend API fixture', '--json']);
-        const result = runSksJson(['qa-loop', 'run', prepared.mission_id, '--mock', '--json']);
+        const result = runSksJson(['qa-loop', 'run', prepared.mission_id, ...routeFixtureArgs, '--native-proof-only']);
         assertGate(result.ok === true, 'QA mock blackbox did not pass', result);
         assertGate(result.gate?.gate?.native_agent_proof === true || result.gate?.native_agent_proof === true || result.proof?.ok === true, 'QA proof missing native agent evidence artifact', result);
     }

package/dist/scripts/sizecheck.js

@@ -7,11 +7,15 @@ import path from 'node:path';
 import { fileURLToPath } from 'node:url';
 const root = path.resolve(path.dirname(fileURLToPath(import.meta.url)), '..', '..');
 const limits = {
-    packedBytes: Number(process.env.SKS_MAX_PACK_BYTES || 1024 * 1024),
-    unpackedBytes: Number(process.env.SKS_MAX_UNPACKED_BYTES || 5 * 1024 * 1024),
+    packedBytes: Number(process.env.SKS_MAX_PACK_BYTES || 1536 * 1024),
+    unpackedBytes: Number(process.env.SKS_MAX_UNPACKED_BYTES || 6 * 1024 * 1024),
     packFiles: Number(process.env.SKS_MAX_PACK_FILES || 1200),
     trackedFileBytes: Number(process.env.SKS_MAX_TRACKED_FILE_BYTES || 384 * 1024)
 };
+const trackedFileSizeAllowlist = new Set([
+    // Historical source documentation export; not included in the npm package payload.
+    'docs/sks-local-llm-mode/exports/sks-local-llm-mode-deck.pdf'
+]);
 const npmBin = process.platform === 'win32' ? 'npm.cmd' : 'npm';
 function fail(message, detail = '') {
     console.error(`Size check failed: ${message}`);
@@ -40,6 +44,8 @@ function checkTrackedFiles() {
     const files = result.stdout.toString('utf8').split('\0').filter(Boolean);
     const oversized = [];
     for (const file of files) {
+        if (trackedFileSizeAllowlist.has(file))
+            continue;
         let stat;
         try {
             stat = fs.statSync(path.join(root, file));

package/dist/scripts/sks-3-1-8-check-lib.js

@@ -0,0 +1,30 @@
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import path from 'node:path';
+import { assertGate, emitGate } from './sks-1-18-gate-lib.js';
+import { renderCoreSkillTemplate } from '../core/codex-native/core-skill-manifest.js';
+export { assertGate, emitGate };
+export async function makeTempRoot(prefix) {
+    const root = await fs.mkdtemp(path.join(os.tmpdir(), prefix));
+    await fs.mkdir(path.join(root, '.sneakoscope', 'reports'), { recursive: true });
+    await fs.mkdir(path.join(root, '.sneakoscope', 'locks'), { recursive: true });
+    return root;
+}
+export async function writeText(file, text) {
+    await fs.mkdir(path.dirname(file), { recursive: true });
+    await fs.writeFile(file, text, 'utf8');
+}
+export async function readJson(file) {
+    return JSON.parse(await fs.readFile(file, 'utf8'));
+}
+export async function writeManagedCoreSkill(root, relRoot, name) {
+    const file = path.join(root, relRoot, name, 'SKILL.md');
+    await writeText(file, renderCoreSkillTemplate(name));
+    return file;
+}
+export async function writeUserSkill(root, relRoot, name, display = name) {
+    const file = path.join(root, relRoot, name, 'SKILL.md');
+    await writeText(file, `---\nname: ${display}\ndescription: user-authored fixture\n---\n\nUser skill fixture.\n`);
+    return file;
+}
+//# sourceMappingURL=sks-3-1-8-check-lib.js.map

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "3.1.7",
+  "version": "3.1.9",
   "description": "Sneakoscope Codex: fast proof-first Codex trust layer with image-based Voxel TriWiki.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -617,6 +617,32 @@
     "naruto:zellij-dynamic-right-column": "node ./dist/scripts/naruto-zellij-dynamic-right-column-check.js",
     "git:worktree-integration-primary-runtime": "node ./dist/scripts/git-worktree-integration-primary-runtime-check.js",
     "agent:role-config-repair": "node ./dist/scripts/agent-role-config-repair-check.js",
+    "core-skill:manifest": "node ./dist/scripts/core-skill-manifest-check.js",
+    "core-skill:immutable-sync": "node ./dist/scripts/core-skill-immutable-sync-check.js",
+    "core-skill:no-drift": "node ./dist/scripts/core-skill-no-drift-check.js",
+    "core-skill:integrity-blackbox": "node ./dist/scripts/core-skill-integrity-blackbox.js",
+    "skill:name-canonicalizer": "node ./dist/scripts/skill-name-canonicalizer-check.js",
+    "skill:registry-ledger": "node ./dist/scripts/skill-registry-ledger-check.js",
+    "skill:dedupe": "node ./dist/scripts/project-skill-dedupe-check.js",
+    "skill:sync-atomic": "node ./dist/scripts/skill-sync-atomic-check.js",
+    "skill:dedupe-blackbox": "node ./dist/scripts/project-skill-dedupe-blackbox.js",
+    "native-capability:repair-matrix": "node ./dist/scripts/native-capability-repair-matrix-check.js",
+    "native-capability:repair": "node ./dist/scripts/native-capability-repair-check.js",
+    "native-capability:postcheck": "node ./dist/scripts/native-capability-postcheck-check.js",
+    "native:image-generation-repair": "node ./dist/scripts/native-image-generation-repair-check.js",
+    "native:computer-use-repair": "node ./dist/scripts/native-computer-use-repair-check.js",
+    "native:chrome-web-review-repair": "node ./dist/scripts/native-chrome-web-review-repair-check.js",
+    "native:app-screenshot-repair": "node ./dist/scripts/native-app-screenshot-repair-check.js",
+    "doctor:native-capability-repair": "node ./dist/scripts/doctor-native-capability-repair-check.js",
+    "doctor:native-repair-output": "node ./dist/scripts/doctor-native-repair-output-check.js",
+    "doctor:native-capability-repair-blackbox": "node ./dist/scripts/doctor-native-capability-repair-blackbox.js",
+    "secret:preservation": "node ./dist/scripts/secret-preservation-check.js",
+    "config:managed-merge": "node ./dist/scripts/managed-config-merge-check.js",
+    "secret:preservation-guard": "node ./dist/scripts/secret-preservation-guard-check.js",
+    "secret:supabase-preservation-blackbox": "node ./dist/scripts/supabase-secret-preservation-blackbox.js",
+    "update:preserves-supabase-keys": "node ./dist/scripts/update-preserves-supabase-keys-blackbox.js",
+    "update:secret-preservation-guard": "node ./dist/scripts/update-secret-preservation-guard-check.js",
+    "update:secret-migration-journal": "node ./dist/scripts/update-secret-migration-journal-check.js",
     "release:dag-full-coverage": "node ./dist/scripts/release-dag-full-coverage-check.js",
     "release:cache-glob-hashing": "node ./dist/scripts/release-cache-glob-hashing-check.js",
     "release:check:affected": "npm run build --silent && node ./dist/scripts/release-gate-dag-runner.js --preset affected --changed-since auto",