sneakoscope 0.7.45 → 0.7.46

package/README.md

@@ -183,10 +183,11 @@ Bare `sks` asks this before opening Codex when codex-lb is not configured:
 Authenticate and route Codex through codex-lb? [y/N]
 ```
 
-Answering `y` asks for the hosted domain and API key, writes `~/.codex/config.toml`, stores the key in `~/.codex/sks-codex-lb.env` with mode `0600`, syncs Codex CLI API-key auth through `codex login --with-api-key`, and sources that env file before launching Codex in tmux. When codex-lb is configured from this prompt, SKS opens a fresh tmux session for that launch so the new key is loaded by the Codex process immediately. SKS keeps Codex App Fast mode selection visible by avoiding legacy top-level `model`, `model_reasoning_effort`, and `service_tier` locks in `~/.codex/config.toml`; route-specific reasoning stays in named profiles or explicit tmux launch args. The generated provider config follows the codex-lb README's Codex CLI API-key setup:
+Answering `y` asks for the hosted domain and API key, writes `~/.codex/config.toml`, stores the key in `~/.codex/sks-codex-lb.env` with mode `0600`, syncs Codex CLI API-key auth through `codex login --with-api-key`, and sources that env file before launching Codex in tmux. When codex-lb is configured from this prompt, SKS opens a fresh tmux session for that launch so the new key is loaded by the Codex process immediately. SKS keeps Codex App Fast mode visible and defaulted by writing `service_tier = "fast"`, `[features].fast_mode = true`, and the `sks-fast-high` profile while removing only legacy top-level `model` and `model_reasoning_effort` locks; route-specific reasoning stays in named profiles or explicit tmux launch args. The generated provider config follows the codex-lb README's Codex CLI API-key setup:
 
 ```toml
 model_provider = "codex-lb"
+service_tier = "fast"
 
 [model_providers.codex-lb]
 name = "OpenAI"

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.7.45",
+  "version": "0.7.46",
   "description": "Sneakoscope Codex: database-safe Codex CLI/App harness with Team, Goal, AutoResearch, TriWiki, and Honest Mode.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",

package/src/cli/install-helpers.mjs

@@ -248,17 +248,25 @@ export async function ensureGlobalCodexFastModeDuringInstall(opts = {}) {
 
 export function normalizeCodexFastModeUiConfig(text = '') {
   let next = removeLegacyTopLevelCodexModeLocks(text);
+  next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
+  next = upsertTopLevelTomlString(next, 'service_tier', 'fast');
+  next = upsertTomlTableKey(next, 'features', 'fast_mode = true');
   next = upsertTomlTableKey(next, 'features', 'fast_mode_ui = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'visible = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'enabled = true');
+  next = upsertTomlTableKey(next, 'user.fast_mode', 'default_profile = "sks-fast-high"');
+  next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'model = "gpt-5.5"');
+  next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'service_tier = "fast"');
+  next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'approval_policy = "on-request"');
+  next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'sandbox_mode = "workspace-write"');
+  next = upsertTomlTableKey(next, 'profiles.sks-fast-high', 'model_reasoning_effort = "high"');
   return ensureTrailingNewline(next);
 }
 
 function removeLegacyTopLevelCodexModeLocks(text = '') {
   const legacy = {
     model: new Set(['gpt-5.5']),
-    model_reasoning_effort: new Set(['high']),
-    service_tier: new Set(['fast'])
+    model_reasoning_effort: new Set(['high'])
   };
   const lines = String(text || '').split('\n');
   const firstTable = lines.findIndex((x) => /^\s*\[.+\]\s*$/.test(x));
@@ -271,6 +279,23 @@ function removeLegacyTopLevelCodexModeLocks(text = '') {
   }).join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n');
 }
 
+function removeTomlTableKey(text, table, key) {
+  const lines = String(text || '').trimEnd().split('\n');
+  if (lines.length === 1 && lines[0] === '') return '';
+  const header = `[${table}]`;
+  const start = lines.findIndex((x) => x.trim() === header);
+  if (start === -1) return String(text || '');
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\s*\[.+\]\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  const keyPattern = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=`);
+  return lines.filter((line, index) => index <= start || index >= end || !keyPattern.test(line)).join('\n').replace(/\n{3,}/g, '\n\n');
+}
+
 function upsertTomlTableKey(text, table, line) {
   const key = String(line).split('=')[0].trim();
   const lines = String(text || '').trimEnd().split('\n');

package/src/cli/main.mjs

@@ -3,7 +3,7 @@ import os from 'node:os';
 import fsp from 'node:fs/promises';
 import readline from 'node:readline/promises';
 import { stdin as input, stdout as output } from 'node:process';
-import { projectRoot, readJson, writeJsonAtomic, writeTextAtomic, appendJsonlBounded, nowIso, exists, ensureDir, tmpdir, packageRoot, dirSize, formatBytes, which, runProcess, PACKAGE_VERSION, sksRoot, globalSksRoot, findProjectRoot } from '../core/fsx.mjs';
+import { projectRoot, readJson, writeJsonAtomic, writeTextAtomic, appendJsonlBounded, nowIso, exists, ensureDir, tmpdir, packageRoot, dirSize, formatBytes, which, runProcess, PACKAGE_VERSION, sksRoot, globalSksRoot, findProjectRoot, readStdin } from '../core/fsx.mjs';
 import { initProject, installSkills, normalizeInstallScope, sksCommandPrefix } from '../core/init.mjs';
 import { getCodexInfo, runCodexExec } from '../core/codex-adapter.mjs';
 import { createMission, loadMission, findLatestMission, missionDir, setCurrent, stateFile } from '../core/mission.mjs';
@@ -168,7 +168,7 @@ Usage:
   sks ppt status <mission-id|latest> [--json]
   sks context7 check|setup|tools|resolve|docs|evidence ...
   sks pipeline status|resume|plan [--json] [--proof-field]
-  sks pipeline answer <mission-id|latest> <answers.json>
+  sks pipeline answer <mission-id|latest> <answers.json|--stdin|--text "...">
   sks guard check [--json]
   sks conflicts check|prompt [--json]
   sks versioning status|bump|pre-commit [--json]
@@ -591,9 +591,14 @@ function printPipelinePlan(root, id, plan) {
 async function pipelineAnswer(root, args = []) {
   const [missionArg, answerFile] = args;
   const id = await resolveMissionId(root, missionArg);
-  if (!id || !answerFile) throw new Error('Usage: sks pipeline answer <mission-id|latest> <answers.json>');
+  if (!id || !answerFile) throw new Error('Usage: sks pipeline answer <mission-id|latest> <answers.json|--stdin|--text "...">');
   const { dir, mission } = await loadMission(root, id);
-  const answers = await readJson(path.resolve(answerFile));
+  const schema = await readJson(path.join(dir, 'required-answers.schema.json'));
+  const answers = answerFile === '--stdin'
+    ? parseAnswersText(schema, await readStdin())
+    : answerFile === '--text'
+      ? parseAnswersText(schema, args.slice(2).join(' '))
+      : await readJson(path.resolve(answerFile));
   await writeJsonAtomic(path.join(dir, 'answers.json'), answers);
   const result = await sealContract(dir, mission);
   if (!result.ok) {
@@ -645,6 +650,48 @@ async function pipelineAnswer(root, args = []) {
   console.log('Next: continue the original route lifecycle using decision-contract.json.');
 }
 
+function parseAnswersText(schema = {}, text = '') {
+  const body = String(text || '').trim();
+  const slots = Array.isArray(schema.slots) ? schema.slots : [];
+  const slotById = new Map(slots.map((slot) => [slot.id, slot]));
+  const answers = {};
+  let currentId = null;
+  let currentLines = [];
+  const flush = () => {
+    if (!currentId) return;
+    answers[currentId] = normalizeTextAnswerValue(slotById.get(currentId), currentLines.join('\n').trim());
+    currentId = null;
+    currentLines = [];
+  };
+  for (const line of body.split(/\r?\n/)) {
+    const match = line.match(/^\s*([A-Z][A-Z0-9_]{2,})\s*[:：]\s*(.*)$/);
+    if (match && slotById.has(match[1])) {
+      flush();
+      currentId = match[1];
+      currentLines = [match[2] || ''];
+      continue;
+    }
+    if (currentId) currentLines.push(line);
+  }
+  flush();
+  if (!Object.keys(answers).length && slots.length === 1 && body) {
+    answers[slots[0].id] = normalizeTextAnswerValue(slots[0], body.replace(new RegExp(`^\\s*${slots[0].id}\\s*`, 'i'), '').trim());
+  }
+  return answers;
+}
+
+function normalizeTextAnswerValue(slot = {}, raw = '') {
+  const value = String(raw || '').trim();
+  if (slot.type === 'array') {
+    return value.split(/\r?\n|,/).map((x) => x.replace(/^\s*[-*]\s*/, '').trim()).filter(Boolean);
+  }
+  if (slot.type === 'array_or_string') {
+    const bulletLines = value.split(/\r?\n/).map((x) => x.trim()).filter(Boolean);
+    if (bulletLines.length > 1 && bulletLines.every((line) => /^[-*]\s+/.test(line))) return bulletLines.map((line) => line.replace(/^[-*]\s+/, '').trim());
+  }
+  return value;
+}
+
 async function materializeAfterPipelineAnswer(root, id, dir, mission, route, routeContext = {}, contract = {}) {
   const madSksState = await materializeMadSksAuthorization(dir, id, route, routeContext, contract);
   if (route?.id === 'MadSKS') {
@@ -1781,7 +1828,7 @@ function hasTopLevelCodexModeLock(text = '') {
   const lines = String(text || '').split('\n');
   const firstTable = lines.findIndex((x) => /^\s*\[.+\]\s*$/.test(x));
   const top = (firstTable === -1 ? lines : lines.slice(0, firstTable)).join('\n');
-  return /^model\s*=|^model_reasoning_effort\s*=|^service_tier\s*=/m.test(top);
+  return /^model\s*=|^model_reasoning_effort\s*=/m.test(top);
 }
 
 async function resolveMissionId(root, arg) { return (!arg || arg === 'latest') ? findLatestMission(root) : arg; }
@@ -1847,7 +1894,7 @@ async function selftest() {
     if (stop?.decision !== 'block' || !String(stop.reason || '').includes('waiting for mandatory ambiguity-removal answers')) throw new Error('selftest failed: clarification gate did not hard-pause without visible questions');
   }
   if (await exists(path.join(clarificationMission.dir, 'hard-blocker.json'))) throw new Error('selftest failed: clarification gate used compliance hard-blocker instead of waiting for answers');
-  const visibleQuestionStop = await evaluateStop(tmp, clarificationState, { last_assistant_message: 'Required questions still pending:\n1. GOAL_PRECISE: What should be changed?\n\nUse sks pipeline answer latest answers.json.' });
+  const visibleQuestionStop = await evaluateStop(tmp, clarificationState, { last_assistant_message: 'Required questions still pending:\n1. GOAL_PRECISE: What should be changed?\n\nReply by slot id; I will seal the contract with sks pipeline answer latest --stdin.' });
   if (visibleQuestionStop?.continue !== true) throw new Error('selftest failed: visible clarification question block did not allow the question-only turn to stop');
   await setCurrent(tmp, loopState);
   const dfixPromptHook = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs'), 'hook', 'user-prompt-submit'], {
@@ -2027,7 +2074,7 @@ async function selftest() {
   if (defaultFastHighPlan.codexArgs.join(' ') !== '--model gpt-5.5 -c model_reasoning_effort="high"') throw new Error('selftest failed: default sks tmux launch is not fast-high');
   const codexLbHome = path.join(tmp, 'codex-lb-home');
   await ensureDir(path.join(codexLbHome, '.codex'));
-  await writeTextAtomic(path.join(codexLbHome, '.codex', 'config.toml'), 'model = "gpt-5.5"\nmodel_reasoning_effort = "high"\nservice_tier = "fast"\n');
+  await writeTextAtomic(path.join(codexLbHome, '.codex', 'config.toml'), 'model = "gpt-5.5"\nmodel_reasoning_effort = "high"\nservice_tier = "fast"\n\n[notice]\nfast_default_opt_out = true\n');
   const codexLbSetup = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs'), 'codex-lb', 'setup', '--host', 'lb.example.test', '--api-key', 'sk-test', '--json'], {
     cwd: tmp,
     env: { HOME: codexLbHome, SKS_GLOBAL_ROOT: path.join(tmp, 'codex-lb-global') },
@@ -2040,7 +2087,7 @@ async function selftest() {
   const codexLbEnv = await safeReadText(path.join(codexLbHome, '.codex', 'sks-codex-lb.env'));
   const codexLbAuth = await safeReadText(path.join(codexLbHome, '.codex', 'auth.json'));
   if (!codexLbSetupJson.ok || codexLbSetupJson.base_url !== 'https://lb.example.test/backend-api/codex' || !codexLbConfig.includes('model_provider = "codex-lb"') || !codexLbConfig.includes('[model_providers.codex-lb]') || !codexLbEnv.includes("CODEX_LB_API_KEY='sk-test'") || !codexLbAuth.includes('"auth_mode": "apikey"')) throw new Error('selftest failed: codex-lb setup did not write provider config, env key, and Codex API-key auth');
-  if (!codexLbConfig.includes('fast_mode_ui = true') || !codexLbConfig.includes('[user.fast_mode]') || hasTopLevelCodexModeLock(codexLbConfig)) throw new Error('selftest failed: codex-lb setup did not preserve Codex App Fast mode UI');
+  if (!codexLbConfig.includes('service_tier = "fast"') || !codexLbConfig.includes('fast_mode = true') || !codexLbConfig.includes('fast_mode_ui = true') || !codexLbConfig.includes('[user.fast_mode]') || !codexLbConfig.includes('visible = true') || !codexLbConfig.includes('enabled = true') || !codexLbConfig.includes('default_profile = "sks-fast-high"') || !/\[profiles\.sks-fast-high\][\s\S]*?service_tier = "fast"/.test(codexLbConfig) || codexLbConfig.includes('fast_default_opt_out = true') || hasTopLevelCodexModeLock(codexLbConfig)) throw new Error('selftest failed: codex-lb setup did not preserve Codex App Fast mode defaults');
   const codexLbLaunch = codexLaunchCommand(tmp, 'codex', []);
   if (!codexLbLaunch.includes('sks-codex-lb.env')) throw new Error('selftest failed: tmux launch command does not source codex-lb env file');
   if (!codexLbLaunch.includes('SKS_TMUX_LOGO_ANIMATION') || !codexLbLaunch.includes('SNEAKOSCOPE CODEX')) throw new Error('selftest failed: tmux launch command does not include the animated SKS logo intro');
@@ -2295,6 +2342,23 @@ async function selftest() {
   if (routePrompt('$MAD-SKS Supabase MCP main 작업')?.id !== 'MadSKS') throw new Error('selftest failed: $MAD-SKS route did not resolve');
   if (routePrompt('$MAD-SKS $Team Supabase MCP main 작업')?.id !== 'Team') throw new Error('selftest failed: $MAD-SKS did not compose with $Team');
   if (routePrompt('$DB Supabase 점검 $MAD-SKS')?.id !== 'DB') throw new Error('selftest failed: trailing $MAD-SKS changed primary route');
+  const madStandaloneTmp = tmpdir();
+  await initProject(madStandaloneTmp, {});
+  const madStandalonePayload = JSON.stringify({ cwd: madStandaloneTmp, prompt: '$MAD-SKS main 권한 열어줘' });
+  const madStandaloneResult = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs'), 'hook', 'user-prompt-submit'], { cwd: madStandaloneTmp, input: madStandalonePayload, env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
+  if (madStandaloneResult.code !== 0) throw new Error(`selftest failed: standalone MAD-SKS hook exited ${madStandaloneResult.code}: ${madStandaloneResult.stderr}`);
+  const madStandaloneState = await readJson(stateFile(madStandaloneTmp), {});
+  if (madStandaloneState.mode !== 'MADSKS' || madStandaloneState.mad_sks_active !== true || madStandaloneState.mad_sks_gate_file !== 'mad-sks-gate.json') throw new Error('selftest failed: standalone MAD-SKS auto-seal did not activate scoped permissions');
+  const madStandaloneWrite = 'cre' + 'ate table mad_selftest (id uuid primary key);';
+  const madStandaloneCreateDecision = await checkDbOperation(madStandaloneTmp, madStandaloneState, { ['tool' + '_name']: 'mcp__data' + 'base__execute_' + 'sql', ['s' + 'ql']: madStandaloneWrite }, { duringNoQuestion: false });
+  if (madStandaloneCreateDecision.action !== 'allow') throw new Error('selftest failed: standalone MAD-SKS did not allow ordinary DDL');
+  const madModifierTmp = tmpdir();
+  await initProject(madModifierTmp, {});
+  const madModifierPayload = JSON.stringify({ cwd: madModifierTmp, prompt: '$MAD-SKS $Team 회전 아스키 아트는 제일 처음 인증 안됐을때만 codex cli처럼 애니메이션으로 보이게 하고 tmux에서는 정적 3d 아스키 아트로 보여줘' });
+  const madModifierResult = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs'), 'hook', 'user-prompt-submit'], { cwd: madModifierTmp, input: madModifierPayload, env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
+  if (madModifierResult.code !== 0) throw new Error(`selftest failed: MAD-SKS Team hook exited ${madModifierResult.code}: ${madModifierResult.stderr}`);
+  const madModifierState = await readJson(stateFile(madModifierTmp), {});
+  if (madModifierState.mode !== 'TEAM' || madModifierState.mad_sks_active !== true || madModifierState.mad_sks_gate_file !== 'team-gate.json') throw new Error('selftest failed: MAD-SKS Team auto-seal did not activate scoped permissions');
   if (routePrompt('위키 갱신해줘')?.id !== 'Wiki') throw new Error('selftest failed: wiki refresh text did not route to Wiki');
   const koreanReadmeInstallPrompt = '리드미에 Codex App에서도 $ 표기 쓰는 법을 알려줘야지. 설치단계에서 바로 보이게 해줘야지';
   if (routePrompt(koreanReadmeInstallPrompt)?.id !== 'Team') throw new Error('selftest failed: Korean README implementation prompt did not route to Team by default');
@@ -2499,7 +2563,8 @@ async function selftest() {
   const hookTeamPendingState = await readJson(stateFile(hookTeamTmp), {});
   const hookTeamPendingContext = hookTeamPendingJson.hookSpecificOutput?.additionalContext || '';
   if (hookTeamPendingState.mission_id !== hookTeamState.mission_id) throw new Error('selftest failed: pending clarification allowed a new route mission to replace the visible question sheet');
-  if (!hookTeamPendingContext.includes('Required questions still pending') || !hookTeamPendingContext.includes('VISIBLE RESPONSE CONTRACT') || !hookTeamPendingContext.includes('PRESENTATION_DELIVERY_CONTEXT')) throw new Error('selftest failed: pending clarification did not re-expose the question sheet');
+  if (!hookTeamPendingContext.includes('Required questions still pending') || !hookTeamPendingContext.includes('PRESENTATION_DELIVERY_CONTEXT')) throw new Error('selftest failed: pending clarification did not re-expose the question sheet');
+  if (hookTeamPendingContext.includes('VISIBLE RESPONSE CONTRACT') || hookTeamPendingContext.includes('Codex plan-tool interaction')) throw new Error('selftest failed: pending clarification reprinted verbose guidance instead of a compact retry');
   if (hookTeamPendingContext.includes('MANDATORY ambiguity-removal gate activated')) throw new Error('selftest failed: pending clarification prepared a new ambiguity gate instead of reusing the active one');
   const hookTeamStopResult = await runProcess(process.execPath, [hookBin, 'hook', 'stop'], { cwd: hookTeamTmp, input: JSON.stringify({ cwd: hookTeamTmp, last_assistant_message: 'I need three decisions before implementation, but I will not paste the Required questions block.' }), env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 128 * 1024 });
   if (hookTeamStopResult.code !== 0) throw new Error(`selftest failed: Team stop hook exited ${hookTeamStopResult.code}: ${hookTeamStopResult.stderr}`);
@@ -2508,13 +2573,12 @@ async function selftest() {
   if (!String(hookTeamStopJson.reason || '').includes('Required questions') || !String(hookTeamStopJson.reason || '').includes('PRESENTATION_DELIVERY_CONTEXT')) throw new Error('selftest failed: missing Team stop presentation question');
   if (String(hookTeamStopJson.reason || '').includes('GOAL_PRECISE: 이번 작업의 최종 목표')) throw new Error('selftest failed: static Team stop goal');
   if (!String(hookTeamStopJson.reason || '').includes('sks pipeline answer')) throw new Error('selftest failed: Stop hook did not provide pipeline answer command');
-  if (!String(hookTeamStopJson.reason || '').includes('Codex plan-tool interaction')) throw new Error('selftest failed: Stop hook did not reprint plan-tool guidance');
-  if (!String(hookTeamStopJson.reason || '').includes('VISIBLE RESPONSE CONTRACT')) throw new Error('selftest failed: Stop hook did not force visible clarification response');
+  if (String(hookTeamStopJson.reason || '').includes('Codex plan-tool interaction') || String(hookTeamStopJson.reason || '').includes('VISIBLE RESPONSE CONTRACT')) throw new Error('selftest failed: Stop hook reprinted verbose clarification guidance');
   const hookTeamSchema = await readJson(path.join(missionDir(hookTeamTmp, hookTeamState.mission_id), 'required-answers.schema.json'));
   const visibleQuestionsBlock = [
     'Required questions',
     ...hookTeamSchema.slots.map((slot, idx) => `${idx + 1}. ${slot.id}: ${slot.question}`),
-    'Reply by slot id, then I will write answers.json and run sks pipeline answer latest answers.json.'
+    'Reply by slot id, then I will seal the contract with sks pipeline answer latest --stdin.'
   ].join('\n');
   const visibleQuestionDecision = await evaluateStop(hookTeamTmp, hookTeamState, { last_assistant_message: visibleQuestionsBlock }, { noQuestion: false });
   if (!visibleQuestionDecision?.continue) throw new Error('selftest failed: visible Required questions block was not accepted by clarification stop gate');
@@ -2522,13 +2586,17 @@ async function selftest() {
   if (hookTeamPreToolBlocked.code !== 0) throw new Error(`selftest failed: pending clarification pre-tool hook exited ${hookTeamPreToolBlocked.code}: ${hookTeamPreToolBlocked.stderr}`);
   const hookTeamPreToolBlockedJson = JSON.parse(hookTeamPreToolBlocked.stdout);
   if (hookTeamPreToolBlockedJson.decision !== 'block' || !String(hookTeamPreToolBlockedJson.reason || '').includes('ambiguity gate is paused')) throw new Error('selftest failed: pending clarification allowed implementation tool use before answers');
-  const hookTeamAnswerToolAllowed = await runProcess(process.execPath, [hookBin, 'hook', 'pre-tool'], { cwd: hookTeamTmp, input: JSON.stringify({ cwd: hookTeamTmp, command: 'node ./bin/sks.mjs pipeline answer latest answers.json' }), env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
+  const hookTeamAnswerToolAllowed = await runProcess(process.execPath, [hookBin, 'hook', 'pre-tool'], { cwd: hookTeamTmp, input: JSON.stringify({ cwd: hookTeamTmp, command: 'node ./bin/sks.mjs pipeline answer latest --stdin' }), env: { SKS_DISABLE_UPDATE_CHECK: '1' }, timeoutMs: 15000, maxOutputBytes: 64 * 1024 });
   if (hookTeamAnswerToolAllowed.code !== 0) throw new Error(`selftest failed: pipeline-answer pre-tool hook exited ${hookTeamAnswerToolAllowed.code}: ${hookTeamAnswerToolAllowed.stderr}`);
   const hookTeamAnswerToolAllowedJson = JSON.parse(hookTeamAnswerToolAllowed.stdout);
   if (hookTeamAnswerToolAllowedJson.decision === 'block') throw new Error('selftest failed: pending clarification blocked the pipeline answer command');
   const nonGoalsSlot = hookTeamSchema.slots.find((s) => s.id === 'NON_GOALS');
   if (nonGoalsSlot && !nonGoalsSlot.allow_empty) throw new Error('selftest failed: NON_GOALS does not allow an empty array answer');
   if (!nonGoalsSlot && !Array.isArray(hookTeamSchema.inferred_answers?.NON_GOALS)) throw new Error('selftest failed: NON_GOALS was neither asked nor inferred');
+  const textParsedAnswers = parseAnswersText({ slots: [{ id: 'INTENT_TARGET', type: 'string', required: true }] }, 'INTENT_TARGET: compact contract sealing');
+  if (textParsedAnswers.INTENT_TARGET !== 'compact contract sealing') throw new Error('selftest failed: text answer parser did not parse slot-id answers');
+  const textParsedImplicitAnswer = parseAnswersText({ slots: [{ id: 'INTENT_TARGET', type: 'string', required: true }] }, 'compact contract sealing');
+  if (textParsedImplicitAnswer.INTENT_TARGET !== 'compact contract sealing') throw new Error('selftest failed: text answer parser did not infer the only missing slot');
   const hookTeamAnswers = {};
   for (const s of hookTeamSchema.slots) hookTeamAnswers[s.id] = s.options ? (s.type === 'array' ? [s.options[0]] : s.options[0]) : (s.type.includes('array') ? ['selftest'] : (s.id === 'DB_MAX_BLAST_RADIUS' ? 'no_live_dml' : 'selftest'));
   hookTeamAnswers.NON_GOALS = [];
@@ -2690,12 +2758,13 @@ async function selftest() {
   if (!codexConfigText.includes('[agents.team_consensus]')) throw new Error('selftest failed: team_consensus agent not configured');
   const preservedConfigTmp = tmpdir();
   await ensureDir(path.join(preservedConfigTmp, '.codex'));
-  await writeTextAtomic(path.join(preservedConfigTmp, '.codex', 'config.toml'), 'model = "gpt-5.5"\nmodel_reasoning_effort = "high"\nservice_tier = "fast"\n\n[features]\nfast_mode_ui = true\n\n[user.fast_mode]\nvisible = true\n');
+  await writeTextAtomic(path.join(preservedConfigTmp, '.codex', 'config.toml'), 'model = "gpt-5.5"\nmodel_reasoning_effort = "high"\nservice_tier = "fast"\n\n[notice]\nfast_default_opt_out = true\nkeep = true\n\n[features]\nfast_mode_ui = true\n\n[user.fast_mode]\nvisible = true\n');
   await initProject(preservedConfigTmp, {});
   const preservedConfig = await safeReadText(path.join(preservedConfigTmp, '.codex', 'config.toml'));
-  if (!preservedConfig.includes('fast_mode_ui = true') || !preservedConfig.includes('[user.fast_mode]') || !preservedConfig.includes('visible = true') || !preservedConfig.includes('enabled = true') || !preservedConfig.includes('default_profile = "sks-fast-high"')) throw new Error('selftest failed: Codex config merge dropped or failed to enable Fast mode settings');
+  if (!preservedConfig.includes('service_tier = "fast"') || !preservedConfig.includes('fast_mode = true') || !preservedConfig.includes('fast_mode_ui = true') || !preservedConfig.includes('[user.fast_mode]') || !preservedConfig.includes('visible = true') || !preservedConfig.includes('enabled = true') || !preservedConfig.includes('default_profile = "sks-fast-high"') || !/\[profiles\.sks-fast-high\][\s\S]*?service_tier = "fast"/.test(preservedConfig)) throw new Error('selftest failed: Codex config merge dropped or failed to enable Fast mode defaults');
+  if (preservedConfig.includes('fast_default_opt_out = true') || !preservedConfig.includes('keep = true')) throw new Error('selftest failed: Codex config merge did not remove stale Fast opt-out notice while preserving other notice keys');
   if (!preservedConfig.includes('codex_hooks = true') || !preservedConfig.includes('[profiles.sks-fast-high]')) throw new Error('selftest failed: Codex config merge did not add SKS managed settings');
-  if (hasTopLevelCodexModeLock(preservedConfig)) throw new Error('selftest failed: Codex config merge left top-level legacy mode locks that hide Fast mode UI');
+  if (hasTopLevelCodexModeLock(preservedConfig)) throw new Error('selftest failed: Codex config merge left top-level legacy model/reasoning locks that hide Fast mode UI');
   const autoReviewHome = path.join(tmp, 'auto-review-home');
   const autoReviewEnv = { HOME: autoReviewHome };
   const autoReviewEnabled = await enableAutoReview({ env: autoReviewEnv, high: true });
@@ -3056,6 +3125,7 @@ async function selftest() {
   const vagueSchema = buildQuestionSchema('뭔가 개선해줘');
   const vagueSlotIds = vagueSchema.slots.map((s) => s.id);
   if (!vagueSlotIds.includes('INTENT_TARGET') || vagueSlotIds.includes('GOAL_PRECISE') || vagueSlotIds.includes('ACCEPTANCE_CRITERIA')) throw new Error(`selftest failed: vague work should ask dynamic intent questions only, got ${vagueSlotIds.join(',')}`);
+  if (vagueSlotIds.length !== 1) throw new Error(`selftest failed: vague work should ask only the execution-changing intent question, got ${vagueSlotIds.join(',')}`);
   if (vagueSchema.ambiguity_assessment?.method !== 'weighted_clarity_interview' || !vagueSchema.ambiguity_assessment?.adversarial_lenses?.includes('challenge_framing')) throw new Error('selftest failed: ambiguity schema missing weighted clarity / planning lenses');
   const pptRoute = routePrompt('$PPT 투자자용 피치덱 만들어줘');
   if (pptRoute?.id !== 'PPT') throw new Error('selftest failed: $PPT did not route to presentation pipeline');

package/src/core/fsx.mjs

@@ -5,7 +5,7 @@ import os from 'node:os';
 import crypto from 'node:crypto';
 import { spawn } from 'node:child_process';
 
-export const PACKAGE_VERSION = '0.7.45';
+export const PACKAGE_VERSION = '0.7.46';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/hooks-runtime.mjs

@@ -270,7 +270,7 @@ function payloadMentionsAnswersJson(payload = {}) {
 function clarificationPauseBlockReason(state = {}) {
   const id = state?.mission_id || 'latest';
   const route = state.route_command || state.route || state.mode || 'route';
-  return `SKS ${route} ambiguity gate is paused and waiting for explicit user answers. Do not run implementation, tests, route materialization, or unrelated tools yet. The only allowed actions are creating .sneakoscope/missions/${id}/answers.json from the user's reply and running "sks pipeline answer ${id} answers.json"; elapsed time or repeated hook resumes never count as answers.`;
+  return `SKS ${route} ambiguity gate is paused and waiting for explicit user answers. Do not run implementation, tests, route materialization, or unrelated tools yet. The only allowed action is sealing the user's reply with "sks pipeline answer ${id} --stdin"; elapsed time or repeated hook resumes never count as answers.`;
 }
 
 async function hookStop(root, state, payload, noQuestion) {

package/src/core/init.mjs

@@ -428,8 +428,11 @@ function installPolicy(scope, commandPrefix) {
 
 function mergeManagedCodexConfigToml(existingContent = '') {
   let next = removeLegacyTopLevelCodexModeLocks(String(existingContent || '').trimEnd());
+  next = removeTomlTableKey(next, 'notice', 'fast_default_opt_out');
+  next = upsertTopLevelTomlString(next, 'service_tier', 'fast');
   next = upsertTomlTableKey(next, 'features', 'codex_hooks = true');
   next = upsertTomlTableKey(next, 'features', 'multi_agent = true');
+  next = upsertTomlTableKey(next, 'features', 'fast_mode = true');
   next = upsertTomlTableKey(next, 'features', 'fast_mode_ui = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'visible = true');
   next = upsertTomlTableKey(next, 'user.fast_mode', 'enabled = true');
@@ -445,8 +448,7 @@ function mergeManagedCodexConfigToml(existingContent = '') {
 function removeLegacyTopLevelCodexModeLocks(text = '') {
   const legacy = {
     model: new Set(['gpt-5.5']),
-    model_reasoning_effort: new Set(['high']),
-    service_tier: new Set(['fast'])
+    model_reasoning_effort: new Set(['high'])
   };
   const lines = String(text || '').split('\n');
   const firstTable = lines.findIndex((x) => /^\s*\[.+\]\s*$/.test(x));
@@ -459,6 +461,38 @@ function removeLegacyTopLevelCodexModeLocks(text = '') {
   }).join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n');
 }
 
+function upsertTopLevelTomlString(text, key, value) {
+  const line = `${key} = "${value}"`;
+  const lines = String(text || '').split('\n');
+  const firstTable = lines.findIndex((x) => /^\s*\[.+\]\s*$/.test(x));
+  const end = firstTable === -1 ? lines.length : firstTable;
+  for (let i = 0; i < end; i += 1) {
+    if (new RegExp(`^\\s*${escapeRegExp(key)}\\s*=`).test(lines[i])) {
+      lines[i] = line;
+      return lines.join('\n').replace(/\n{3,}/g, '\n\n');
+    }
+  }
+  lines.splice(end, 0, line);
+  return lines.join('\n').replace(/^\n+/, '').replace(/\n{3,}/g, '\n\n');
+}
+
+function removeTomlTableKey(text, table, key) {
+  const lines = String(text || '').trimEnd().split('\n');
+  if (lines.length === 1 && lines[0] === '') return '';
+  const header = `[${table}]`;
+  const start = lines.findIndex((x) => x.trim() === header);
+  if (start === -1) return String(text || '');
+  let end = lines.length;
+  for (let i = start + 1; i < lines.length; i += 1) {
+    if (/^\s*\[.+\]\s*$/.test(lines[i])) {
+      end = i;
+      break;
+    }
+  }
+  const keyPattern = new RegExp(`^\\s*${key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}\\s*=`);
+  return lines.filter((line, index) => index <= start || index >= end || !keyPattern.test(line)).join('\n').replace(/\n{3,}/g, '\n\n');
+}
+
 function managedCodexConfigBlocks() {
   return [
     { table: 'mcp_servers.context7', text: context7ConfigToml().trim() },
@@ -470,7 +504,7 @@ function managedCodexConfigBlocks() {
     { table: 'profiles.sks-task-low', text: profileConfigBlock('sks-task-low', 'low') },
     { table: 'profiles.sks-task-medium', text: profileConfigBlock('sks-task-medium', 'medium') },
     { table: 'profiles.sks-logic-high', text: profileConfigBlock('sks-logic-high', 'high') },
-    { table: 'profiles.sks-fast-high', text: profileConfigBlock('sks-fast-high', 'high') },
+    { table: 'profiles.sks-fast-high', text: profileConfigBlock('sks-fast-high', 'high', { serviceTier: 'fast' }) },
     { table: 'profiles.sks-research-xhigh', text: profileConfigBlock('sks-research-xhigh', 'xhigh') },
     { table: 'profiles.sks-research', text: profileConfigBlock('sks-research', 'xhigh', { approval: 'never' }) },
     { table: 'profiles.sks-team', text: profileConfigBlock('sks-team', 'high') },
@@ -496,6 +530,7 @@ function profileConfigBlock(profile, effort, opts = {}) {
   return [
     `[profiles.${profile}]`,
     'model = "gpt-5.5"',
+    ...(opts.serviceTier ? [`service_tier = "${opts.serviceTier}"`] : []),
     `approval_policy = "${opts.approval || 'on-request'}"`,
     ...(opts.approvalsReviewer ? [`approvals_reviewer = "${opts.approvalsReviewer}"`] : []),
     `sandbox_mode = "${opts.sandbox || 'workspace-write'}"`,

package/src/core/pipeline.mjs

@@ -235,7 +235,7 @@ function planVerification(route, proof) {
 }
 
 function planNextActions(route, task, ambiguity, lane) {
-  if (ambiguity.required && !ambiguity.passed) return ['ask ambiguity-removal questions', 'write answers.json', 'run sks pipeline answer <mission-id> answers.json'];
+  if (ambiguity.required && !ambiguity.passed) return ['ask only execution-changing ambiguity questions', 'seal the decision contract from the user reply'];
   const actions = ['read pipeline-plan.json before work', 'execute kept stages only', 'run listed verification'];
   if (!lane.fast_lane_allowed && routeRequiresSubagents(route, task)) actions.splice(1, 0, 'materialize full Team artifacts before implementation');
   actions.push('refresh/validate TriWiki when required', 'finish with completion summary and Honest Mode');
@@ -255,8 +255,8 @@ export function promptPipelineContext(prompt, route = routePrompt(prompt)) {
     'Before work, load the required SKS skill context and follow the route lifecycle instead of treating the command as plain text.',
     'Codex App visibility: briefly surface what SKS is doing before tools run, mirror important worker/tool status to mission artifacts, and keep progress legible to the user.',
     'Hook visibility limit: hooks can inject context/status or block/continue a turn, but they cannot create arbitrary live chat bubbles; use team events, mission files, or normal assistant updates for live transcript details.',
-    'Ambiguity gate: every execution route must start with mandatory ambiguity-removal questions before execution. DFix and Answer bypass this gate because they do not start implementation.',
-    'Plan-first interaction: when ambiguity questions are required, call the Codex plan tool first so the user sees Ask questions -> Seal decision contract -> Execute/verify as the visible workflow.',
+    'Ambiguity gate: execution routes must infer obvious contract answers first and ask only missing answers that can change target, scope, safety, behavior, or acceptance. DFix and Answer bypass this gate because they do not start implementation.',
+    'Plan-first interaction: when ambiguity questions are truly required, show the user only the missing human decision(s), then seal the decision contract internally and execute/verify.',
     'Question-shaped directive policy: before using Answer, decide whether a question is a real information request or an implicit instruction/complaint about broken behavior. Rhetorical bug reports, mandatory-policy statements, and "why is this not happening?" execution complaints must route to Team, not Answer.',
     'Best-practice prompt shape: extract Goal, Context, Constraints, and Done-when before implementation; keep questions compact and only ask for answers that can change scope, safety, user-facing behavior, or acceptance criteria.',
     chatCaptureIntakeText(),
@@ -504,9 +504,16 @@ async function prepareClarificationGate(root, route, task, required, opts = {})
   if (schema.slots.length === 0) {
     await writeJsonAtomic(path.join(dir, 'answers.json'), schema.inferred_answers || {});
     const result = await sealContract(dir, mission);
-    const materialized = result.ok && route?.id === 'Team'
-      ? await materializeAutoSealedTeam(root, id, dir, route, task, result.contract?.sealed_hash || null)
-      : {};
+    let materialized = {};
+    if (result.ok && route?.id === 'Team') {
+      materialized = await materializeAutoSealedTeam(root, id, dir, route, task, result.contract?.sealed_hash || null);
+      if (opts.madSksAuthorization) {
+        const madSksState = await materializeMadSksAuthorization(dir, id, route, routeContext, result.contract || {});
+        materialized = { ...materialized, state: { ...(materialized.state || {}), ...madSksState } };
+      }
+    } else if (result.ok && route?.id === 'MadSKS') {
+      materialized = await materializeAutoSealedMadSks(dir, id, route, routeContext, result.contract || {});
+    }
     const effectiveTask = materialized.prompt || task;
     const plan = await writePipelinePlan(dir, { missionId: id, route, task: effectiveTask, required, ambiguity: { required: true, slots: 0, auto_sealed: result.ok, passed: result.ok, contract_hash: result.contract?.sealed_hash || null } });
     await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'route.clarification.auto_sealed', route: route.id, slots: 0, ok: result.ok });
@@ -542,7 +549,7 @@ Next atomic action: continue the original route lifecycle with the sealed decisi
   await appendJsonl(path.join(dir, 'events.jsonl'), { ts: nowIso(), type: 'route.clarification.questions_created', route: route.id, slots: schema.slots.length });
   const phase = `${route.mode}_CLARIFICATION_AWAITING_ANSWERS`;
   await setCurrent(root, routeState(id, route, phase, required, { prompt: task, questions_allowed: true, implementation_allowed: false, clarification_required: true, ambiguity_gate_required: true, pipeline_plan_ready: validatePipelinePlan(plan).ok, pipeline_plan_path: PIPELINE_PLAN_ARTIFACT, original_stop_gate: route.stopGate, stop_gate: 'clarification-gate' }));
-  const answerCommand = 'sks pipeline answer latest answers.json, then continue the original route lifecycle';
+  const answerCommand = 'sks pipeline answer latest --stdin';
   const title = 'MANDATORY ambiguity-removal gate activated.';
   return {
     route,
@@ -555,7 +562,7 @@ Question file: .sneakoscope/missions/${id}/questions.md
 Answer schema: .sneakoscope/missions/${id}/required-answers.schema.json
 Pipeline plan: .sneakoscope/missions/${id}/${PIPELINE_PLAN_ARTIFACT}
 
-Do not execute the route yet. Ask the user the required ambiguity-removal questions now. After the user answers, convert the answers to answers.json, run "${answerCommand}".
+Do not execute the route yet. Ask only the required ambiguity-removal questions now. After the user answers, seal the decision contract internally with "${answerCommand}".
 ${clarificationVisibleResponseContract(id)}
 ${context7RequirementText(required)}
 ${clarificationPlanHint(route, id)}
@@ -588,6 +595,74 @@ function applyMadSksAuthorizationToSchema(schema = {}) {
   return schema;
 }
 
+async function materializeAutoSealedMadSks(dir, id, route, routeContext = {}, contract = {}) {
+  await writeJsonAtomic(path.join(dir, 'mad-sks-gate.json'), {
+    schema_version: 1,
+    passed: false,
+    mad_sks_permission_active: true,
+    permissions_deactivated: false,
+    supabase_mcp_schema_cleanup_allowed: true,
+    direct_execute_sql_allowed: true,
+    normal_db_writes_allowed: true,
+    catastrophic_safety_guard_active: true,
+    contract_hash: contract.sealed_hash || null
+  });
+  await appendJsonl(path.join(dir, 'events.jsonl'), {
+    ts: nowIso(),
+    type: 'mad_sks.scoped_permission_opened',
+    route: route?.id || 'MadSKS',
+    catastrophic_safety_guard_active: true
+  });
+  return {
+    phase: 'MADSKS_SCOPED_PERMISSION_ACTIVE',
+    prompt: routeContext.task || '',
+    state: {
+      mad_sks_active: true,
+      mad_sks_modifier: true,
+      mad_sks_gate_file: 'mad-sks-gate.json',
+      mad_sks_gate_ready: true,
+      supabase_mcp_schema_cleanup_allowed: true,
+      direct_execute_sql_allowed: true,
+      normal_db_writes_allowed: true,
+      catastrophic_safety_guard_active: true
+    }
+  };
+}
+
+async function materializeMadSksAuthorization(dir, id, route, routeContext = {}, contract = {}) {
+  if (!routeContext.mad_sks_authorization || route?.id === 'MadSKS') return {};
+  const gateFile = route?.stopGate || 'done-gate.json';
+  await writeJsonAtomic(path.join(dir, 'mad-sks-authorization.json'), {
+    schema_version: 1,
+    mission_id: id,
+    route: route?.command || route?.id || null,
+    status: 'active',
+    active_only_for_current_route: true,
+    deactivates_when_gate_passed: gateFile,
+    supabase_mcp_schema_cleanup_allowed: true,
+    direct_execute_sql_allowed: true,
+    normal_db_writes_allowed: true,
+    catastrophic_safety_guard_active: true,
+    contract_hash: contract.sealed_hash || null
+  });
+  await appendJsonl(path.join(dir, 'events.jsonl'), {
+    ts: nowIso(),
+    type: 'mad_sks.modifier_authorization_opened',
+    route: route?.id || null,
+    gate: gateFile,
+    catastrophic_safety_guard_active: true
+  });
+  return {
+    mad_sks_active: true,
+    mad_sks_modifier: true,
+    mad_sks_gate_file: gateFile,
+    supabase_mcp_schema_cleanup_allowed: true,
+    direct_execute_sql_allowed: true,
+    normal_db_writes_allowed: true,
+    catastrophic_safety_guard_active: true
+  };
+}
+
 async function materializeAutoSealedTeam(root, id, dir, route, task, contractHash = null) {
   const spec = parseTeamSpecText(task);
   const cleanTask = spec.prompt || task;
@@ -809,11 +884,11 @@ async function clarificationAwaitingAnswersContext(root, state) {
   const schema = await readJson(path.join(missionDir(root, id), 'required-answers.schema.json'), null);
   const questionBlock = schema ? `\n\nRequired questions still pending:\n${formatRequiredQuestions(schema)}` : '';
   const planNote = await activePipelinePlanNote(root, state);
-  return `Active SKS route ${state.route_command || state.route || state.mode} is waiting for mandatory ambiguity-removal answers. If the user answered, write answers.json, run "sks pipeline answer ${id} answers.json", then continue the original route lifecycle. If required answers are missing, use the Codex plan tool first, then ask only those questions. Do not execute the route before this gate passes.${planNote}${clarificationVisibleResponseContract(id, false)}${clarificationPlanHint({ command: state.route_command || state.route || '$SKS', route: state.route || state.mode || 'SKS route' }, id, false)}${questionBlock}`;
+  return `Active SKS route ${state.route_command || state.route || state.mode} is still paused for ambiguity answers. Keep this retry compact: if the user answered, seal the contract with "sks pipeline answer ${id} --stdin"; otherwise ask only the missing slot ids. Do not expose internal answer files to the user and do not execute the route before this gate passes.${planNote}${questionBlock}`;
 }
 
 function clarificationVisibleResponseContract(id) {
-  const answerCommand = `sks pipeline answer ${id} answers.json`;
+  const answerCommand = `sks pipeline answer ${id} --stdin`;
   return `
 
 VISIBLE RESPONSE CONTRACT:
@@ -821,17 +896,17 @@ VISIBLE RESPONSE CONTRACT:
 - Do not call tools, do not start implementation, and do not advance to the next route phase.
 - Elapsed time, repeated hook resumes, or assistant self-continuation do not count as answers.
 - Reply to the user with the Required questions block so it is visible in chat.
-- Tell the user they can answer directly by slot id; after they answer, convert the reply to answers.json and run \`${answerCommand}\`.`;
+- Tell the user they can answer directly by slot id; after they answer, seal the contract internally with \`${answerCommand}\`.`;
 }
 
 function clarificationPlanHint(route, id) {
-  const command = `sks pipeline answer ${id} answers.json`;
+  const command = `sks pipeline answer ${id} --stdin`;
   return `
 
 Codex plan-tool interaction:
 Before asking the user, call update_plan with:
 - in_progress: Ask mandatory ambiguity-removal questions for ${route.command || '$SKS'}
-- pending: Convert the user's answers to answers.json and run \`${command}\`
+- pending: Seal the user's answers internally with \`${command}\`
 - pending: Continue the original route lifecycle with the sealed decision-contract.json
 Then ask the questions in one compact message.`;
 }
@@ -852,23 +927,12 @@ async function clarificationStopReason(root, state, kind) {
   const files = state?.mission_id ? `
 Question file: .sneakoscope/missions/${state.mission_id}/questions.md
 Answer schema: .sneakoscope/missions/${state.mission_id}/required-answers.schema.json` : '';
-  const command = `sks pipeline answer ${id} answers.json, then continue the original ${routeName} route`;
+  const command = `sks pipeline answer ${id} --stdin`;
   const title = `SKS ${routeName} is waiting for mandatory ambiguity-removal answers.`;
   return `${title}
-Do not finish or implement yet. Reprint these questions to the user if they are not already visible.${files}
-
-${clarificationVisibleResponseContract(id)}
-
-The user can answer directly in chat as plain text, for example:
-GOAL_PRECISE: ...
-ACCEPTANCE_CRITERIA:
-- ...
-NON_GOALS:
-- ...
-
-${clarificationPlanHint({ command: routeName, route: routeName }, id)}
+Do not finish or implement yet. Keep retries compact: show only the missing questions if they are not already visible, then wait for the user's answer.${files}
 
-After the user answers, convert the reply to answers.json and run: ${command}.${questionBlock}`;
+After the user answers, seal the contract internally with "${command}", then continue the original ${routeName} route.${questionBlock}`;
 }
 
 export async function recordContext7Evidence(root, state, payload) {

package/src/core/questions.mjs

@@ -412,12 +412,13 @@ export function buildQuestionSchema(prompt) {
   const ambiguity = buildAmbiguityAssessment(prompt);
   const slots = [];
   const presentationSpecific = domainHints.includes('presentation');
-  if (!presentationSpecific && ambiguity.unresolved_dimensions.includes('intent_target_or_required_outcome')) {
+  const intentMissing = ambiguity.unresolved_dimensions.includes('intent_target_or_required_outcome');
+  if (!presentationSpecific && intentMissing) {
     slots.push(
       { id: 'INTENT_TARGET', question: '실제로 바꿀 대상과 원하는 결과를 한 문장으로만 적어주세요. 파일/화면/기능명이 있으면 같이 적어주세요.', required: true, type: 'string' }
     );
   }
-  if (!presentationSpecific && ambiguity.unresolved_dimensions.includes('success_criteria_or_acceptance')) {
+  if (!presentationSpecific && !intentMissing && ambiguity.unresolved_dimensions.includes('success_criteria_or_acceptance')) {
     slots.push(
       { id: 'SUCCESS_CRITERIA_OR_ACCEPTANCE', question: '완료라고 판단할 수 있는 관찰 가능한 기준을 1~3개만 적어주세요. 모르면 “현재 코드 기준으로 판단”이라고 적어도 됩니다.', required: true, type: 'array_or_string' }
     );
@@ -427,7 +428,7 @@ export function buildQuestionSchema(prompt) {
       { id: 'RISK_AND_BOUNDARY', question: '여러 선택지가 있거나 위험한 변경이 있다면 반드시 지켜야 할 경계만 적어주세요. 없으면 “기존 동작 보존, 파괴적 작업 금지”라고 답해주세요.', required: true, type: 'string' }
     );
   }
-  if (ambiguity.unresolved_dimensions.includes('codebase_context_target')) {
+  if (!intentMissing && ambiguity.unresolved_dimensions.includes('codebase_context_target')) {
     slots.push(
       { id: 'CODEBASE_CONTEXT_TARGET', question: '이 요청이 가리키는 repo/브랜치/화면/파일/최근 오류 맥락을 알려주세요.', required: true, type: 'string' }
     );
@@ -504,7 +505,7 @@ export function questionsMarkdown(schema) {
     lines.push('UI 수준 E2E와 시각 검증은 Codex Computer Use 증거가 없으면 검증 완료로 주장할 수 없습니다. Chrome MCP, Browser Use, Playwright, Selenium, Puppeteer, 기타 브라우저 자동화는 UI/브라우저 검증 증거로 인정하지 않습니다.');
     lines.push('개발 서버가 아닌 배포/스테이징 도메인에서는 삭제성 테스트를 절대 실행하지 않습니다.');
   } else {
-    lines.push('이 질문들에 모두 답변하고 Decision Contract가 봉인된 뒤에만 실행됩니다.');
+    lines.push('실행을 바꿀 수 있는 질문에만 답변하면 Decision Contract가 봉인된 뒤 실행됩니다.');
     lines.push('봉인 후 실행 중에는 사용자에게 새 질문을 하지 않고 decision ladder로 해결합니다.');
     lines.push('사용자 의도가 실제로 모호한 항목만 묻고, 나머지는 TriWiki/current-code 기본값으로 추론합니다.');
   }
@@ -540,7 +541,7 @@ export function questionsMarkdown(schema) {
     lines.push(`- type: ${s.type}`);
     lines.push('');
   }
-  lines.push('## answers.json template');
+  lines.push('## Internal Answer Payload Template');
   lines.push('');
   lines.push('```json');
   const example = {};