sneakoscope 3.1.8 → 3.1.9

package/dist/core/qa-loop.js

@@ -1,12 +1,16 @@
 import path from 'node:path';
 import { exists, nowIso, readJson, readText, writeJsonAtomic, writeTextAtomic, PACKAGE_VERSION } from './fsx.js';
-import { CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE, CODEX_WEB_VERIFICATION_POLICY, evidenceMentionsForbiddenBrowserAutomation, evidenceMentionsForbiddenWebComputerUseEvidence } from './routes.js';
+import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_IMAGEGEN_REQUIRED_POLICY, CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE, CODEX_WEB_VERIFICATION_POLICY, evidenceMentionsForbiddenBrowserAutomation, evidenceMentionsForbiddenWebComputerUseEvidence } from './routes.js';
 import { appendAgentLedgerEvent, initializeAgentCentralLedger } from './agents/agent-central-ledger.js';
 import { resolveCodexAppExecutionProfile } from './codex-app/codex-app-execution-profile.js';
 import { resolveCodexNativeInvocationPlan } from './codex-native/codex-native-invocation-router.js';
+import { imageDimensions, sha256File } from './wiki-image/image-hash.js';
 export const QA_LOOP_ROUTE = 'QALoop';
+export const QA_LOOP_VISUAL_EVIDENCE_ARTIFACT = 'qa-loop/visual-evidence.json';
 const QA_REPORT_SUFFIX = 'qa-report.md';
 const UI_CHROME_EXTENSION_FIRST_ACK = 'use_codex_chrome_extension_first_no_computer_use_for_web_ui_or_mark_unverified';
+const GPT_IMAGE_2_ANNOTATED_REVIEW_REQUIRED_ACK = 'yes_gpt_image_2_annotated_review';
+const IMAGE_FILE_RE = /\.(png|jpe?g|webp|gif)$/i;
 export const QA_NATIVE_AGENT_PERSONAS = Object.freeze([
     {
         id: 'qa_verifier_ui',
@@ -108,6 +112,9 @@ function promptText(prompt = '') {
 function lowerPrompt(prompt = '') {
     return promptText(prompt).toLowerCase();
 }
+function qaPromptWantsGptImage2AnnotatedReview(prompt = '') {
+    return /(gpt-image-2|gpt\s*image\s*2|imagegen|\$imagegen|annotated\s+review|annotated\s+image|callout|generated\s+review\s+image|이미지\s*리뷰|생성\s*이미지|주석\s*이미지|콜아웃)/i.test(promptText(prompt));
+}
 function firstUrl(prompt = '') {
     return promptText(prompt).match(/https?:\/\/[^\s)\]}>,]+/i)?.[0] || '';
 }
@@ -152,6 +159,16 @@ export function inferQaLoopAnswers(prompt = '') {
     const local = environment === 'local_dev_server';
     const login = loginPolicyFromPrompt(text);
     const scope = qaScopeFromPrompt(text);
+    const wantsGptImage2Review = isUiScope(scope) && qaPromptWantsGptImage2AnnotatedReview(text);
+    const acceptance = [
+        '앱 첫 화면 또는 지정된 대상이 정상 로드된다.',
+        '주요 내비게이션과 핵심 화면 진입에서 콘솔/화면상 치명 오류가 없다.',
+        '검증하지 못한 UI/API 범위는 통과로 주장하지 않고 QA 리포트에 남긴다.'
+    ];
+    if (isUiScope(scope))
+        acceptance.push('UI E2E 통과 증거는 실제 Codex Chrome Extension screenshot artifact path와 sha256을 기록해야 한다.');
+    if (wantsGptImage2Review)
+        acceptance.push('gpt-image-2 annotated review image가 필요한 경우 실제 Codex App $imagegen/gpt-image-2 출력 파일 path, sha256, model, provider를 기록해야 한다.');
     return {
         GOAL_PRECISE: text ? `현재 요청 범위에서 QA-LOOP를 안전하게 실행한다: ${text}` : '현재 로컬 개발 환경에서 핵심 사용자 흐름을 안전하게 QA한다.',
         QA_SCOPE: scope,
@@ -165,13 +182,10 @@ export function inferQaLoopAnswers(prompt = '') {
         ...login,
         CREDENTIAL_STORAGE_ACK: 'never_store_credentials_in_artifacts_or_wiki',
         UI_CHROME_EXTENSION_ACK: UI_CHROME_EXTENSION_FIRST_ACK,
+        QA_VISUAL_REVIEW_IMAGEGEN_REQUIRED: wantsGptImage2Review ? GPT_IMAGE_2_ANNOTATED_REVIEW_REQUIRED_ACK : 'not_required',
         TEAM_MODE_ALLOWED: 'no_parent_only',
         MAX_QA_CYCLES: '1',
-        ACCEPTANCE_CRITERIA: [
-            '앱 첫 화면 또는 지정된 대상이 정상 로드된다.',
-            '주요 내비게이션과 핵심 화면 진입에서 콘솔/화면상 치명 오류가 없다.',
-            '검증하지 못한 UI/API 범위는 통과로 주장하지 않고 QA 리포트에 남긴다.'
-        ],
+        ACCEPTANCE_CRITERIA: acceptance,
         NON_GOALS: [
             '결제, 실제 이메일/SMS 발송, 관리자 권한 변경, 데이터 삭제, 프로덕션 데이터 변경은 테스트하지 않는다.'
         ],
@@ -290,10 +304,22 @@ export function qaUiRequired(a = {}) {
 export function qaApiRequired(a = {}) {
     return a.QA_SCOPE === 'all_available' ? hasApiTarget(a) : isApiScope(a.QA_SCOPE);
 }
+export function qaGptImage2AnnotatedReviewRequired(contractOrAnswers = {}, prompt = '') {
+    const answers = contractOrAnswers?.answers || contractOrAnswers || {};
+    if (!qaUiRequired(answers))
+        return false;
+    const explicit = String(answers.QA_VISUAL_REVIEW_IMAGEGEN_REQUIRED || answers.GPT_IMAGE_2_ANNOTATED_REVIEW_REQUIRED || '').trim();
+    if (/^(yes|true|required|yes_gpt_image_2_annotated_review)$/i.test(explicit))
+        return true;
+    if (/^(no|false|not_required|none)$/i.test(explicit))
+        return false;
+    return qaPromptWantsGptImage2AnnotatedReview(`${prompt || ''}\n${answers.GOAL_PRECISE || ''}\n${JSON.stringify(answers.ACCEPTANCE_CRITERIA || [])}`);
+}
 export function defaultQaGate(contract = {}, opts = {}) {
     const a = contract.answers || {};
     const uiRequired = qaUiRequired(a);
     const apiRequired = qaApiRequired(a);
+    const gptImage2ReviewRequired = qaGptImage2AnnotatedReviewRequired(contract, contract.prompt);
     const reportFile = opts.reportFile || qaReportFilename();
     const corrective = a.QA_CORRECTIVE_POLICY !== 'report_only_no_code_changes';
     return {
@@ -311,6 +337,17 @@ export function defaultQaGate(contract = {}, opts = {}) {
         ui_chrome_extension_evidence: !uiRequired,
         ui_computer_use_evidence: false,
         ui_evidence_source: uiRequired ? null : 'not_required',
+        ui_chrome_extension_screenshot_required: uiRequired,
+        ui_chrome_extension_screenshot_captured: !uiRequired,
+        ui_chrome_extension_screenshot_artifact: null,
+        ui_chrome_extension_screenshot_sha256: null,
+        gpt_image_2_annotated_review_required: gptImage2ReviewRequired,
+        gpt_image_2_annotated_review_generated: !gptImage2ReviewRequired,
+        gpt_image_2_annotated_review_artifact: null,
+        gpt_image_2_annotated_review_sha256: null,
+        gpt_image_2_annotated_review_model: gptImage2ReviewRequired ? null : 'not_required',
+        gpt_image_2_annotated_review_provider: gptImage2ReviewRequired ? null : 'not_required',
+        qa_visual_evidence_artifact: QA_LOOP_VISUAL_EVIDENCE_ARTIFACT,
         desktop_app_handoff_required: false,
         desktop_app_handoff_status: 'not_requested',
         desktop_app_handoff_artifact: null,
@@ -360,13 +397,48 @@ export async function writeQaLoopArtifacts(dir, mission, contract) {
         codex_app_execution_profile: executionProfile ? compactExecutionProfile(executionProfile) : null,
         codex_native_invocation: codexNativeInvocation,
         target: { scope: a.QA_SCOPE, environment: a.TARGET_ENVIRONMENT, base_url: a.TARGET_BASE_URL, api_base_url: a.API_BASE_URL },
-        safety: { mutation_policy: a.QA_MUTATION_POLICY, deployed_destructive_tests_allowed: 'never', credentials: 'temp_only_never_saved', ui_evidence: 'codex_chrome_extension_first_required_for_web_ui_e2e' },
+        safety: { mutation_policy: a.QA_MUTATION_POLICY, deployed_destructive_tests_allowed: 'never', credentials: 'temp_only_never_saved', ui_evidence: 'codex_chrome_extension_first_required_for_web_ui_e2e', visual_review: 'gpt_image_2_annotated_review_required_when_contract_requests_it' },
         checklist
     });
+    await writeJsonAtomic(path.join(dir, QA_LOOP_VISUAL_EVIDENCE_ARTIFACT), buildQaLoopVisualEvidenceArtifact(mission, contract));
     await writeJsonAtomic(path.join(dir, 'qa-gate.json'), defaultQaGate(contract, { reportFile, executionProfile, codexNativeInvocation }));
     await writeTextAtomic(path.join(dir, reportFile), qaReportTemplate(mission, contract, checklist));
     return { checklist_count: checklist.length, report_file: reportFile };
 }
+export async function ensureQaLoopVisualEvidenceContract(dir, mission = {}, contract = {}) {
+    const visualPath = path.join(dir, QA_LOOP_VISUAL_EVIDENCE_ARTIFACT);
+    if (!(await exists(visualPath))) {
+        await writeJsonAtomic(visualPath, buildQaLoopVisualEvidenceArtifact(mission, contract));
+    }
+    const gatePath = path.join(dir, 'qa-gate.json');
+    const gate = await readJson(gatePath, null);
+    if (!gate)
+        return;
+    const defaults = defaultQaGate(contract, { reportFile: qaReportFileFromGate(gate) || qaReportFilename() });
+    const keys = [
+        'ui_chrome_extension_screenshot_required',
+        'ui_chrome_extension_screenshot_captured',
+        'ui_chrome_extension_screenshot_artifact',
+        'ui_chrome_extension_screenshot_sha256',
+        'gpt_image_2_annotated_review_required',
+        'gpt_image_2_annotated_review_generated',
+        'gpt_image_2_annotated_review_artifact',
+        'gpt_image_2_annotated_review_sha256',
+        'gpt_image_2_annotated_review_model',
+        'gpt_image_2_annotated_review_provider',
+        'qa_visual_evidence_artifact'
+    ];
+    const next = { ...gate };
+    let changed = false;
+    for (const key of keys) {
+        if (next[key] === undefined) {
+            next[key] = defaults[key];
+            changed = true;
+        }
+    }
+    if (changed)
+        await writeJsonAtomic(gatePath, next);
+}
 export async function evaluateQaGate(dir) {
     const gate = await readJson(path.join(dir, 'qa-gate.json'), {});
     const reportFile = qaReportFileFromGate(gate);
@@ -400,6 +472,10 @@ export async function evaluateQaGate(dir) {
             reasons.push('forbidden_browser_automation_evidence');
         if (evidenceMentionsForbiddenWebComputerUseEvidence({ evidence: gate.evidence, ui_evidence_source: gate.ui_evidence_source }))
             reasons.push('computer_use_web_evidence_forbidden');
+        reasons.push(...await missingQaLoopVisualEvidence(dir, gate));
+    }
+    else if (gate.gpt_image_2_annotated_review_required === true) {
+        reasons.push(...await missingQaLoopVisualEvidence(dir, gate));
     }
     if (gate.desktop_app_handoff_required === true) {
         if (!['pending', 'launched_pending_confirmation', 'completed'].includes(String(gate.desktop_app_handoff_status || '')))
@@ -424,8 +500,9 @@ export async function evaluateQaGate(dir) {
         reasons.push('qa_report_missing');
     if (!(await exists(path.join(dir, 'qa-ledger.json'))))
         reasons.push('qa_ledger_missing');
-    const passed = gate.passed === true && reasons.length === 0;
-    const result = { checked_at: nowIso(), passed, reasons, gate };
+    const uniqueReasons = [...new Set(reasons)];
+    const passed = gate.passed === true && uniqueReasons.length === 0;
+    const result = { checked_at: nowIso(), passed, reasons: uniqueReasons, gate };
     await writeJsonAtomic(path.join(dir, 'qa-gate.evaluated.json'), result);
     return result;
 }
@@ -514,12 +591,19 @@ ARTIFACTS: update qa-ledger.json, ${report}, qa-gate.json, and qa-loop/cycle-${c
 CONTRACT:
 ${JSON.stringify(contract, null, 2)}
 ${imageContractText}${appHandoffText}${executionProfileText}
+VISUAL EVIDENCE CONTRACT:
+- For web UI QA, do not set chrome_extension_preflight_passed/ui_chrome_extension_evidence to true unless the Codex Chrome Extension path is ready and ${QA_LOOP_VISUAL_EVIDENCE_ARTIFACT} records a real saved Chrome Extension screenshot artifact with path, sha256, and dimensions.
+- If decision-contract.json answers set QA_VISUAL_REVIEW_IMAGEGEN_REQUIRED=${GPT_IMAGE_2_ANNOTATED_REVIEW_REQUIRED_ACK}, use Codex App $imagegen/gpt-image-2 (${CODEX_APP_IMAGE_GENERATION_DOC_URL}) to produce a real generated annotated review image from the Chrome Extension screenshot. Record its path, sha256, model=gpt-image-2, provider=Codex App $imagegen, and source_screenshot_artifact in ${QA_LOOP_VISUAL_EVIDENCE_ARTIFACT} and qa-gate.json.
+- Do not substitute prose-only critique, Playwright/Selenium/Puppeteer/Browser Use screenshots, Computer Use browser screenshots, placeholder images, fake fixtures, or direct API fallback as full web UI visual evidence.
 Previous tail:
 ${String(previous || '').slice(-2500)}
 `;
 }
 export async function qaStatus(dir) {
-    const gate = await readJson(path.join(dir, 'qa-gate.evaluated.json'), await readJson(path.join(dir, 'qa-gate.json'), null));
+    const mission = await readJson(path.join(dir, 'mission.json'), {});
+    const contract = await readJson(path.join(dir, 'decision-contract.json'), { prompt: mission.prompt, answers: {}, sealed_hash: null });
+    await ensureQaLoopVisualEvidenceContract(dir, mission, contract).catch(() => undefined);
+    const gate = await evaluateQaGate(dir).catch(async () => await readJson(path.join(dir, 'qa-gate.evaluated.json'), await readJson(path.join(dir, 'qa-gate.json'), null)));
     const ledger = await readJson(path.join(dir, 'qa-ledger.json'), null);
     const appHandoff = await readJson(path.join(dir, 'qa-loop', 'app-handoff.json'), null);
     const appConfirmation = await readJson(path.join(dir, 'qa-loop', 'app-handoff-confirmation.json'), null);
@@ -545,6 +629,138 @@ function qaChecklist(a) {
     cases.push(['report.evidence', 'Record pass/fail/blocked/skipped with evidence.'], ['report.corrective_loop', 'Record fixes, rechecks, unresolved findings, deferred blockers.'], ['report.honest', 'Run Honest Mode.']);
     return cases.map(([id, title]) => ({ id, title, status: 'pending', evidence: [] }));
 }
+export function buildQaLoopVisualEvidenceArtifact(mission = {}, contract = {}) {
+    const answers = contract.answers || {};
+    const uiRequired = qaUiRequired(answers);
+    const gptImage2ReviewRequired = qaGptImage2AnnotatedReviewRequired(contract, contract.prompt || mission.prompt);
+    return {
+        schema: 'sks.qa-loop-visual-evidence.v1',
+        generated_at: nowIso(),
+        mission_id: mission.id || contract.mission_id || null,
+        contract_hash: contract.sealed_hash || null,
+        required: uiRequired || gptImage2ReviewRequired,
+        chrome_extension_screenshot: {
+            required: uiRequired,
+            status: uiRequired ? 'pending' : 'not_required',
+            evidence_source: CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE,
+            artifact_path: null,
+            sha256: null,
+            width: null,
+            height: null,
+            privacy: 'local-only'
+        },
+        gpt_image_2_annotated_review: {
+            required: gptImage2ReviewRequired,
+            status: gptImage2ReviewRequired ? 'pending' : 'not_required',
+            model: gptImage2ReviewRequired ? 'gpt-image-2' : 'not_required',
+            provider: gptImage2ReviewRequired ? 'Codex App $imagegen' : 'not_required',
+            source_screenshot_artifact: null,
+            artifact_path: null,
+            sha256: null,
+            width: null,
+            height: null,
+            required_output: gptImage2ReviewRequired ? 'generated_annotated_review_image_with_numbered_callouts_severity_labels_and_visual_marks' : 'not_required',
+            docs_url: CODEX_APP_IMAGE_GENERATION_DOC_URL,
+            privacy: 'local-only'
+        },
+        blockers: uiRequired ? ['chrome_extension_screenshot_missing'] : [],
+        notes: [
+            'QA-LOOP web visual evidence must be backed by real saved local image files.',
+            CODEX_WEB_VERIFICATION_POLICY,
+            CODEX_IMAGEGEN_REQUIRED_POLICY
+        ]
+    };
+}
+async function missingQaLoopVisualEvidence(dir, gate = {}) {
+    const visual = await readJson(path.join(dir, QA_LOOP_VISUAL_EVIDENCE_ARTIFACT), null);
+    const reasons = [];
+    const uiRequired = gate.ui_e2e_required === true;
+    if (uiRequired) {
+        const screenshot = visual?.chrome_extension_screenshot || {};
+        if (gate.ui_chrome_extension_screenshot_captured !== true && !positiveVisualStatus(screenshot.status, ['captured', 'attached', 'verified']))
+            reasons.push('ui_chrome_extension_screenshot_missing');
+        const screenshotPath = firstNonEmpty(gate.ui_chrome_extension_screenshot_artifact, gate.chrome_extension_screenshot_artifact, gate.ui_chrome_extension_screenshot?.path, gate.chrome_extension_screenshot?.path, screenshot.artifact_path, screenshot.path);
+        const screenshotSha = firstNonEmpty(gate.ui_chrome_extension_screenshot_sha256, gate.chrome_extension_screenshot_sha256, gate.ui_chrome_extension_screenshot?.sha256, gate.chrome_extension_screenshot?.sha256, screenshot.sha256);
+        const screenshotDims = {
+            width: firstNonEmpty(gate.ui_chrome_extension_screenshot_width, gate.ui_chrome_extension_screenshot?.width, gate.chrome_extension_screenshot?.width, screenshot.width),
+            height: firstNonEmpty(gate.ui_chrome_extension_screenshot_height, gate.ui_chrome_extension_screenshot?.height, gate.chrome_extension_screenshot?.height, screenshot.height)
+        };
+        if (!screenshotPath)
+            reasons.push('ui_chrome_extension_screenshot_artifact_missing');
+        else
+            reasons.push(...await imageEvidenceFileReasons(dir, screenshotPath, screenshotSha, 'ui_chrome_extension_screenshot', screenshotDims));
+        const screenshotSource = firstNonEmpty(gate.ui_chrome_extension_screenshot_source, screenshot.evidence_source, gate.ui_evidence_source);
+        if (screenshotSource !== CODEX_WEB_VERIFICATION_EVIDENCE_SOURCE)
+            reasons.push('ui_chrome_extension_screenshot_source_not_codex_chrome_extension');
+    }
+    const review = visual?.gpt_image_2_annotated_review || {};
+    const gptImage2ReviewRequired = gate.gpt_image_2_annotated_review_required === true || review.required === true;
+    if (gptImage2ReviewRequired) {
+        if (gate.gpt_image_2_annotated_review_generated !== true && !positiveVisualStatus(review.status, ['generated', 'attached', 'verified']))
+            reasons.push('gpt_image_2_annotated_review_image_missing');
+        const reviewPath = firstNonEmpty(gate.gpt_image_2_annotated_review_artifact, gate.imagegen_annotated_review_artifact, gate.gpt_image_2_annotated_review?.path, gate.gpt_image_2_annotated_review_image?.path, review.artifact_path, review.path);
+        const reviewSha = firstNonEmpty(gate.gpt_image_2_annotated_review_sha256, gate.gpt_image_2_annotated_review?.sha256, gate.gpt_image_2_annotated_review_image?.sha256, review.sha256);
+        const reviewDims = {
+            width: firstNonEmpty(gate.gpt_image_2_annotated_review_width, gate.gpt_image_2_annotated_review?.width, gate.gpt_image_2_annotated_review_image?.width, review.width),
+            height: firstNonEmpty(gate.gpt_image_2_annotated_review_height, gate.gpt_image_2_annotated_review?.height, gate.gpt_image_2_annotated_review_image?.height, review.height)
+        };
+        if (!reviewPath)
+            reasons.push('gpt_image_2_annotated_review_artifact_missing');
+        else
+            reasons.push(...await imageEvidenceFileReasons(dir, reviewPath, reviewSha, 'gpt_image_2_annotated_review', reviewDims));
+        const model = firstNonEmpty(gate.gpt_image_2_annotated_review_model, gate.gpt_image_2_annotated_review?.model, gate.gpt_image_2_annotated_review_image?.model, review.model, review.provider?.model);
+        if (model !== 'gpt-image-2')
+            reasons.push('gpt_image_2_annotated_review_model_missing');
+        const provider = firstNonEmpty(gate.gpt_image_2_annotated_review_provider, gate.gpt_image_2_annotated_review?.provider, gate.gpt_image_2_annotated_review_image?.provider, review.provider, review.provider_surface);
+        if (!provider || !/codex\s+app|\$imagegen|codex_app_imagegen/i.test(String(provider)))
+            reasons.push('gpt_image_2_annotated_review_provider_not_codex_app_imagegen');
+        if (/mock|fake|fixture|placeholder|text[-_ ]?only|direct\s+api|openai_images_api|responses_image_generation/i.test(String(provider)))
+            reasons.push('gpt_image_2_annotated_review_provider_forbidden');
+        const sourceScreenshot = firstNonEmpty(gate.gpt_image_2_source_screenshot_artifact, gate.gpt_image_2_annotated_review?.source_screenshot_artifact, gate.gpt_image_2_annotated_review_image?.source_screenshot_artifact, review.source_screenshot_artifact, gate.ui_chrome_extension_screenshot_artifact);
+        if (!sourceScreenshot)
+            reasons.push('gpt_image_2_source_screenshot_artifact_missing');
+    }
+    return [...new Set(reasons)];
+}
+function positiveVisualStatus(status, accepted) {
+    return accepted.includes(String(status || '').trim().toLowerCase());
+}
+function firstNonEmpty(...values) {
+    for (const value of values) {
+        if (typeof value === 'string' && value.trim())
+            return value.trim();
+        if (value && typeof value !== 'string')
+            return value;
+    }
+    return null;
+}
+async function imageEvidenceFileReasons(dir, artifactPath, declaredSha, prefix, declaredDims = {}) {
+    const reasons = [];
+    const resolved = resolveEvidencePath(dir, artifactPath);
+    if (!resolved)
+        return [`${prefix}_artifact_path_invalid`];
+    if (!IMAGE_FILE_RE.test(resolved))
+        reasons.push(`${prefix}_artifact_not_image_file`);
+    if (!(await exists(resolved)))
+        return [...reasons, `${prefix}_artifact_file_missing`];
+    const sha = await sha256File(resolved).catch(() => null);
+    if (!declaredSha)
+        reasons.push(`${prefix}_sha256_missing`);
+    else if (sha && String(declaredSha) !== sha)
+        reasons.push(`${prefix}_sha256_mismatch`);
+    const dims = await imageDimensions(resolved).catch(() => null);
+    const width = Number(dims?.width ?? declaredDims?.width);
+    const height = Number(dims?.height ?? declaredDims?.height);
+    if (!Number.isFinite(width) || !Number.isFinite(height) || width <= 0 || height <= 0)
+        reasons.push(`${prefix}_dimensions_missing`);
+    return reasons;
+}
+function resolveEvidencePath(dir, artifactPath) {
+    const value = String(artifactPath || '').trim().replace(/^file:\/\//i, '');
+    if (!value || /^https?:\/\//i.test(value))
+        return null;
+    return path.isAbsolute(value) ? value : path.resolve(dir, value);
+}
 function missionRootFromDir(dir) {
     const normalized = path.resolve(String(dir || ''));
     const marker = `${path.sep}.sneakoscope${path.sep}missions${path.sep}`;
@@ -564,7 +780,7 @@ function compactExecutionProfile(profile) {
 }
 function qaReportTemplate(mission, contract, checklist) {
     const a = contract.answers || {};
-    return `# QA-LOOP Report\n\nMission: ${mission.id}\nTarget: ${a.TARGET_BASE_URL || 'unset'}\nScope: ${a.QA_SCOPE || 'unset'}\nEnvironment: ${a.TARGET_ENVIRONMENT || 'unset'}\n\n## Safety\n\n- Deployed destructive tests: never\n- Credentials: temp-only, never saved\n- UI evidence: ${CODEX_WEB_VERIFICATION_POLICY}\n\n## Checklist\n\n${checklist.map((item) => `- [ ] ${item.id}: ${item.title}`).join('\n')}\n\n## Findings\n\nTBD\n\n## Corrections And Rechecks\n\nTBD\n\n## Honest Mode\n\nTBD\n`;
+    return `# QA-LOOP Report\n\nMission: ${mission.id}\nTarget: ${a.TARGET_BASE_URL || 'unset'}\nScope: ${a.QA_SCOPE || 'unset'}\nEnvironment: ${a.TARGET_ENVIRONMENT || 'unset'}\n\n## Safety\n\n- Deployed destructive tests: never\n- Credentials: temp-only, never saved\n- UI evidence: ${CODEX_WEB_VERIFICATION_POLICY}\n- Visual evidence ledger: ${QA_LOOP_VISUAL_EVIDENCE_ARTIFACT}\n\n## Checklist\n\n${checklist.map((item) => `- [ ] ${item.id}: ${item.title}`).join('\n')}\n\n## Findings\n\nTBD\n\n## Corrections And Rechecks\n\nTBD\n\n## Honest Mode\n\nTBD\n`;
 }
 function positiveCount(value) {
     const n = Number(value || 0);

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');