sneakoscope 0.9.11 → 0.9.13

package/src/core/language-preference.mjs

@@ -0,0 +1,106 @@
+const HANGUL_RE = /[\u3131-\u318e\uac00-\ud7a3]/gu;
+const LATIN_WORD_RE = /[A-Za-z][A-Za-z']*/g;
+
+const KOREAN_OVERRIDE_PATTERNS = [
+  /\b(?:answer|respond|reply|write|explain|summari[sz]e|use)\s+(?:in\s+)?(?:korean|hangul)\b/i,
+  /(?:한국어|한글)(?:로|으로)?\s*(?:답|응답|말|작성|설명|정리|써|해줘|해주세요)/i,
+  /(?:답|응답|말|작성|설명|정리|써)\S{0,12}(?:한국어|한글)(?:로|으로)?/i
+];
+
+const ENGLISH_OVERRIDE_PATTERNS = [
+  /\b(?:answer|respond|reply|write|explain|summari[sz]e|use)\s+(?:in\s+)?english\b/i,
+  /영어(?:로|으로)?\s*(?:답|응답|말|작성|설명|정리|써|해줘|해주세요)/i,
+  /(?:답|응답|말|작성|설명|정리|써)\S{0,12}영어(?:로|으로)?/i
+];
+
+function countMatches(text, pattern) {
+  return (String(text || '').match(pattern) || []).length;
+}
+
+function hasExplicitOverride(text, patterns) {
+  return patterns.some((pattern) => pattern.test(text));
+}
+
+export function detectResponseLanguage(prompt = '') {
+  const text = String(prompt || '').trim();
+  if (!text) {
+    return { code: 'unknown', label: 'unknown', confidence: 0, reason: 'empty_prompt' };
+  }
+
+  const koreanOverride = hasExplicitOverride(text, KOREAN_OVERRIDE_PATTERNS);
+  const englishOverride = hasExplicitOverride(text, ENGLISH_OVERRIDE_PATTERNS);
+  if (koreanOverride && !englishOverride) {
+    return { code: 'ko', label: 'Korean', confidence: 1, reason: 'explicit_korean_override' };
+  }
+  if (englishOverride && !koreanOverride) {
+    return { code: 'en', label: 'English', confidence: 1, reason: 'explicit_english_override' };
+  }
+
+  const hangulCount = countMatches(text, HANGUL_RE);
+  const latinWords = String(text || '').match(LATIN_WORD_RE) || [];
+  const latinCharCount = latinWords.join('').length;
+  const totalLanguageChars = hangulCount + latinCharCount;
+  const hangulRatio = totalLanguageChars > 0 ? hangulCount / totalLanguageChars : 0;
+
+  if (hangulCount >= 8 || (hangulCount >= 2 && hangulRatio >= 0.08)) {
+    return {
+      code: 'ko',
+      label: 'Korean',
+      confidence: Math.min(0.98, 0.62 + hangulRatio),
+      reason: 'hangul_dominant_or_present'
+    };
+  }
+
+  if (latinWords.length >= 2) {
+    return {
+      code: 'en',
+      label: 'English',
+      confidence: Math.min(0.95, 0.55 + latinWords.length / 40),
+      reason: 'latin_words_present'
+    };
+  }
+
+  return { code: 'unknown', label: 'unknown', confidence: 0.2, reason: 'insufficient_language_signal' };
+}
+
+export function responseLanguageInstruction(prompt = '') {
+  const language = detectResponseLanguage(prompt);
+  if (language.code === 'ko') {
+    return [
+      '응답 언어: 사용자 요청은 주로 한국어입니다.',
+      '진행 업데이트, 사용자에게 보이는 요약, 최종 완료 요약, SKS 솔직모드는 한국어로 작성하세요.',
+      '코드, 명령어, 파일 경로, 패키지명, API명, 인용 원문은 원래 언어 그대로 유지하세요.',
+      '이후 사용자 메시지가 다른 응답 언어를 명시하면 가장 최근의 명시적 언어 요청을 따르세요.'
+    ].join(' ');
+  }
+  if (language.code === 'en') {
+    return [
+      'Response language: the user prompt is primarily English.',
+      'Write assistant progress updates, user-visible summaries, final completion summary, and SKS Honest Mode in English.',
+      'Preserve code, commands, file paths, package names, API names, and quoted source text in their original language.',
+      'If a later user message explicitly asks for a different response language, follow the latest explicit language request.'
+    ].join(' ');
+  }
+  return [
+    'Response language: match the user prompt language when clear.',
+    'If the prompt language remains ambiguous, use concise English while preserving code, commands, file paths, package names, API names, and quoted source text as-is.'
+  ].join(' ');
+}
+
+export function localizedFinalizationReason(kind, prompt = '') {
+  const language = detectResponseLanguage(prompt);
+  const korean = language.code === 'ko';
+  if (kind === 'completion_summary_missing') {
+    return korean
+      ? 'SKS 최종 완료 요약(completion summary)이 필요합니다. 마치기 전에 무엇을 했는지, 사용자/레포에 무엇이 바뀌었는지, 무엇을 검증했는지, 남은 gap이 무엇인지 SKS 솔직모드와 함께 한국어로 설명하세요.'
+      : 'SKS final completion summary is required before finishing. Explain what was done, what changed for the user/repo, what was verified, and any remaining gaps before or alongside SKS Honest Mode.';
+  }
+  if (kind === 'honest_loopback') {
+    return korean
+      ? 'SKS 솔직모드에서 해결되지 않은 gap이 발견되었습니다. decision-contract.json 기준의 post-ambiguity execution phase에서 계속 진행하고, gap을 고친 뒤 검증을 다시 실행하고, TriWiki를 refresh/validate한 다음 최종 솔직모드를 다시 시도하세요.'
+      : 'SKS Honest Mode found unresolved gaps. Continue from the post-ambiguity execution phase using decision-contract.json, fix them, rerun verification, refresh/validate TriWiki, then retry final Honest Mode.';
+  }
+  return korean
+    ? '마치기 전에 SKS 솔직모드가 필요합니다. 실제 목표를 다시 확인하고, 증거/테스트를 검증하고, 남은 gap을 솔직히 적은 뒤 최종 답변을 한국어로 제공하세요. 짧은 "SKS 솔직모드" 또는 "솔직모드" 섹션을 포함하세요.'
+    : 'SKS Honest Mode is required before finishing. Re-check the actual goal, verify evidence/tests, state gaps honestly, and only then provide the final answer. Include a short "SKS Honest Mode" or "솔직모드" section.';
+}

package/src/core/pipeline.mjs

@@ -16,7 +16,10 @@ import { evaluateResearchGate, writeResearchPlan } from './research.mjs';
 import { PPT_REQUIRED_GATE_FIELDS, writePptRouteArtifacts } from './ppt.mjs';
 import { writeQaLoopArtifacts } from './qa-loop.mjs';
 import { IMAGE_UX_REVIEW_GATE_ARTIFACT, IMAGE_UX_REVIEW_POLICY_ARTIFACT, IMAGE_UX_REVIEW_SCREEN_INVENTORY_ARTIFACT, IMAGE_UX_REVIEW_GENERATED_REVIEW_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ISSUE_LEDGER_ARTIFACT, IMAGE_UX_REVIEW_ITERATION_REPORT_ARTIFACT, IMAGE_UX_REVIEW_REQUIRED_GATE_FIELDS, writeImageUxReviewRouteArtifacts } from './image-ux-review.mjs';
+import { responseLanguageInstruction } from './language-preference.mjs';
 import { SPEED_LANE_POLICY } from './proof-field.mjs';
+import { validateRouteCompletionProof } from './proof/route-proof-gate.mjs';
+import { routeFromState, routeRequiresCompletionProof } from './proof/route-proof-policy.mjs';
 import { permissionGateSummary } from './permission-gates.mjs';
 import { CODEX_APP_IMAGE_GENERATION_DOC_URL, CODEX_COMPUTER_USE_EVIDENCE_SOURCE, CODEX_COMPUTER_USE_ONLY_POLICY, CODEX_IMAGEGEN_REQUIRED_POLICY, FROM_CHAT_IMG_CHECKLIST_ARTIFACT, FROM_CHAT_IMG_COVERAGE_ARTIFACT, FROM_CHAT_IMG_QA_LOOP_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_ARTIFACT, FROM_CHAT_IMG_TEMP_TRIWIKI_SESSIONS, SOLUTION_SCOUT_STAGE_ID, chatCaptureIntakeText, context7RequirementText, dollarCommand, evidenceMentionsForbiddenBrowserAutomation, getdesignReferencePolicyText, hasFromChatImgSignal, hasMadSksSignal, imageUxReviewPipelinePolicyText, looksLikeProblemSolvingRequest, noUnrequestedFallbackCodePolicyText, outcomeRubricPolicyText, pptPipelineAllowlistPolicyText, reflectionRequiredForRoute, reasoningInstruction, routeNeedsContext7, routePrompt, routeReasoning, routeRequiresSubagents, solutionScoutPolicyText, speedLanePolicyText, stripDollarCommand, stripMadSksSignal, stripVisibleDecisionAnswerBlocks, subagentExecutionPolicyText, stackCurrentDocsPolicyText, triwikiContextTracking, triwikiContextTrackingText, triwikiStagePolicyText } from './routes.mjs';
 import { TEAM_DECOMPOSITION_ARTIFACT, TEAM_GRAPH_ARTIFACT, TEAM_INBOX_DIR, TEAM_RUNTIME_TASKS_ARTIFACT, teamRuntimePlanMetadata, teamRuntimeRequiredArtifacts, validateTeamRuntimeArtifacts, writeTeamRuntimeArtifacts } from './team-dag.mjs';
@@ -313,6 +316,7 @@ export function promptPipelineContext(prompt, route = null) {
     reasoningInstruction(reasoning),
     '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.',
+    responseLanguageInstruction(cleanPrompt),
     '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.',
     'Ambient Goal continuation: even without an explicit $Goal keyword, use Codex native /goal persistence when it helps keep long work resumable and complete; do not let it replace or skip the selected SKS route gates.',
     'Route contract: execution routes infer contract answers from the prompt, TriWiki/current-code defaults, and conservative SKS policy. DFix and Answer bypass stateful execution because they do not start implementation.',
@@ -355,6 +359,7 @@ export function dfixQuickContext(prompt, route = routePrompt(prompt)) {
   const routeLabel = route?.command || '$DFix';
   return [
     `DFix ultralight pipeline active. Route: ${routeLabel} (Direct Fix: tiny copy/config/docs/labels/spacing/translation/simple mechanical edits).`,
+    responseLanguageInstruction(task),
     'Bypass: do not enter the general SKS prompt pipeline, mission creation, ambiguity gate, TriWiki refresh, Context7 routing, subagent orchestration, Goal, Research, eval, or broad planning.',
     `Task: ${task}`,
     'Task list:',
@@ -371,6 +376,7 @@ export function answerOnlyContext(prompt, route = routePrompt(prompt)) {
   const required = routeNeedsContext7(route, task);
   return [
     `SKS answer-only pipeline active. Route: ${route?.command || '$Answer'} (${route?.route || 'answer-only research'}).`,
+    responseLanguageInstruction(task),
     'Intent classification: answer/research question, not implementation. Do not create route mission state, ask ambiguity-gate questions, spawn subagents, continue active Team/Goal work, or edit files unless the user explicitly asks for implementation.',
     `Question: ${task}`,
     'Evidence flow:',
@@ -464,6 +470,7 @@ export function computerUseFastContext(prompt, route = routePrompt(prompt)) {
   const task = stripDollarCommand(prompt) || String(prompt || '').trim();
   return [
     `Computer Use fast lane active. Route: ${route?.command || '$Computer-Use'} (${route?.route || 'Computer Use fast lane'}).`,
+    responseLanguageInstruction(task),
     'Speed contract: do not enter Team, QA-LOOP clarification, repeated upfront TriWiki refresh, Context7, subagent orchestration, debate, reflection, or broad planning unless the user explicitly requests that heavier route.',
     `Task: ${task}`,
     'Execution order:',
@@ -482,6 +489,7 @@ async function prepareWikiQuickRoute(route, task) {
     route,
     additionalContext: [
       `SKS wiki pipeline active. Route: ${route.command} (${route.route}).`,
+      responseLanguageInstruction(task),
       `Task: ${task || 'refresh and validate TriWiki'}`,
       'Run policy: refresh/update/갱신 -> `sks wiki refresh` then validate; prune/clean/정리 -> `sks wiki refresh --prune` or dry-run prune first; pack -> `sks wiki pack` then validate.',
       stackCurrentDocsPolicyText(),
@@ -1351,11 +1359,27 @@ export async function evaluateStop(root, state, payload, opts = {}) {
       return complianceBlock(root, state, `SKS ${state.route_command || state.mode} route cannot stop yet. Pass ${gate.file || state.stop_gate} or record a hard blocker with evidence before finishing.${missing}`, { gate: gate.file || state.stop_gate, missing: gate.missing });
     }
   }
+  const proofGate = await routeProofGateStatus(root, state);
+  if (!proofGate.ok) {
+    return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} route cannot finalize without a valid Completion Proof. Missing or invalid proof issues: ${proofGate.issues.join(', ')}.`, { gate: 'completion-proof', missing: proofGate.issues });
+  }
   const reflection = await reflectionGateStatus(root, state);
   if (!reflection.ok) return complianceBlock(root, state, reflectionStopReason(state, reflection), { gate: 'reflection', missing: reflection.missing });
   return null;
 }
 
+async function routeProofGateStatus(root, state = {}) {
+  const route = routeFromState(state);
+  const required = state.proof_required === true || routeRequiresCompletionProof(route);
+  if (!required || !state?.mission_id) return { ok: true, required: false, issues: [] };
+  return validateRouteCompletionProof(root, {
+    missionId: state.mission_id,
+    route,
+    state,
+    visualClaim: state.visual_claim !== false
+  });
+}
+
 function clarificationGatePending(state = {}) {
   const phase = String(state.phase || '');
   return Boolean(state?.clarification_required && phase.includes('CLARIFICATION_AWAITING_ANSWERS'))

package/src/core/proof/claim-ledger.mjs

@@ -0,0 +1,9 @@
+export function summarizeClaims(claims = []) {
+  const rows = Array.isArray(claims) ? claims : [];
+  return {
+    total: rows.length,
+    supported: rows.filter((claim) => claim.status === 'supported').length,
+    unverified: rows.filter((claim) => claim.status === 'unverified').length,
+    blocked: rows.filter((claim) => claim.status === 'blocked').length
+  };
+}

package/src/core/proof/command-ledger.mjs

@@ -0,0 +1,17 @@
+import path from 'node:path';
+import { appendJsonl, nowIso, packageRoot, readText } from '../fsx.mjs';
+import { redactSecrets } from '../secret-redaction.mjs';
+import { proofDir } from './proof-writer.mjs';
+
+export async function appendProofCommand(root = packageRoot(), command = {}) {
+  const record = redactSecrets({ ts: nowIso(), ...command });
+  await appendJsonl(path.join(proofDir(root), 'commands.jsonl'), record);
+  return record;
+}
+
+export async function readProofCommands(root = packageRoot()) {
+  const text = await readText(path.join(proofDir(root), 'commands.jsonl'), '');
+  return text.split(/\r?\n/).filter(Boolean).map((line) => {
+    try { return JSON.parse(line); } catch { return { raw: line }; }
+  });
+}

package/src/core/proof/evidence-collector.mjs

@@ -0,0 +1,33 @@
+import path from 'node:path';
+import { packageRoot, readJson, runProcess, which } from '../fsx.mjs';
+import { codexLbMetrics, readCodexLbCircuit } from '../codex-lb-circuit.mjs';
+import { imageVoxelSummary } from '../wiki-image/image-voxel-ledger.mjs';
+
+export async function collectProofEvidence(root = packageRoot()) {
+  return {
+    files: await collectGitFileChanges(root),
+    image_voxels: await imageVoxelSummary(root).catch(() => null),
+    triwiki: await readJson(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), null).then((pack) => pack ? {
+      status: 'present',
+      schema: pack.schema || null,
+      claims: pack.trust_summary?.claims || pack.wiki?.a?.length || 0
+    } : null).catch(() => null),
+    codex_lb: await readCodexLbCircuit(root).then((circuit) => codexLbMetrics(circuit)).catch(() => null),
+    db_safety: await readJson(path.join(root, '.sneakoscope', 'db-safety.json'), null).then((policy) => policy ? {
+      status: 'present',
+      mode: policy.mode || null,
+      destructive_operations: policy.destructive_operations || null
+    } : null).catch(() => null)
+  };
+}
+
+async function collectGitFileChanges(root) {
+  const git = await which('git').catch(() => null);
+  if (!git) return [];
+  const result = await runProcess(git, ['status', '--short'], { cwd: root, timeoutMs: 5000, maxOutputBytes: 64 * 1024 }).catch(() => null);
+  if (!result || result.code !== 0) return [];
+  return result.stdout.split(/\r?\n/).filter(Boolean).map((line) => ({
+    status: line.slice(0, 2).trim() || 'changed',
+    path: line.slice(3).trim()
+  }));
+}

package/src/core/proof/file-change-ledger.mjs

@@ -0,0 +1,6 @@
+import { collectProofEvidence } from './evidence-collector.mjs';
+
+export async function fileChangeLedger(root) {
+  const evidence = await collectProofEvidence(root);
+  return evidence.files || [];
+}

package/src/core/proof/proof-reader.mjs

@@ -0,0 +1,30 @@
+import path from 'node:path';
+import { exists, packageRoot, readJson, readText } from '../fsx.mjs';
+import { emptyCompletionProof } from './proof-schema.mjs';
+import { proofDir } from './proof-writer.mjs';
+
+export async function readLatestProof(root = packageRoot()) {
+  const file = path.join(proofDir(root), 'latest.json');
+  if (!await exists(file)) return emptyCompletionProof({
+    status: 'not_verified',
+    unverified: ['No completion proof has been written yet.']
+  });
+  return readJson(file);
+}
+
+export async function readLatestProofMarkdown(root = packageRoot()) {
+  const file = path.join(proofDir(root), 'latest.md');
+  if (!await exists(file)) return '# SKS Completion Proof\n\nNo completion proof has been written yet.\n';
+  return readText(file);
+}
+
+export async function readRouteProof(root = packageRoot(), missionId = null) {
+  if (missionId) {
+    const missionProof = path.join(root, '.sneakoscope', 'missions', missionId, 'completion-proof.json');
+    if (await exists(missionProof)) return readJson(missionProof);
+    return null;
+  }
+  const latest = path.join(proofDir(root), 'latest.json');
+  if (await exists(latest)) return readJson(latest);
+  return null;
+}

package/src/core/proof/proof-redaction.test-helper.mjs

@@ -0,0 +1,9 @@
+import { containsPlaintextSecret, redactSecrets } from '../secret-redaction.mjs';
+
+export function assertProofRedaction(value) {
+  const redacted = redactSecrets(value);
+  return {
+    ok: !containsPlaintextSecret(redacted),
+    redacted
+  };
+}

package/src/core/proof/proof-schema.mjs

@@ -0,0 +1,42 @@
+import { PACKAGE_VERSION, nowIso } from '../fsx.mjs';
+
+export const COMPLETION_PROOF_SCHEMA = 'sks.completion-proof.v1';
+export const COMPLETION_PROOF_STATUSES = Object.freeze([
+  'verified',
+  'verified_partial',
+  'blocked',
+  'not_verified',
+  'failed'
+]);
+
+export function emptyCompletionProof(overrides = {}) {
+  return {
+    schema: COMPLETION_PROOF_SCHEMA,
+    version: PACKAGE_VERSION,
+    generated_at: nowIso(),
+    mission_id: null,
+    route: null,
+    status: 'not_verified',
+    summary: {
+      files_changed: 0,
+      commands_run: 0,
+      tests_passed: 0,
+      tests_failed: 0,
+      manual_review_required: true
+    },
+    evidence: {
+      commands: [],
+      files: [],
+      db_safety: null,
+      codex_app: null,
+      computer_use: null,
+      image_voxels: null,
+      triwiki: null
+    },
+    claims: [],
+    unverified: [],
+    blockers: [],
+    next_human_actions: [],
+    ...overrides
+  };
+}

package/src/core/proof/proof-writer.mjs

@@ -0,0 +1,81 @@
+import path from 'node:path';
+import { appendJsonl, ensureDir, nowIso, packageRoot, writeJsonAtomic, writeTextAtomic } from '../fsx.mjs';
+import { redactSecrets } from '../secret-redaction.mjs';
+import { emptyCompletionProof } from './proof-schema.mjs';
+import { validateCompletionProof } from './validation.mjs';
+
+export function proofDir(root = packageRoot()) {
+  return path.join(root, '.sneakoscope', 'proof');
+}
+
+export async function writeCompletionProof(root = packageRoot(), input = {}, opts = {}) {
+  const proof = redactSecrets(emptyCompletionProof({
+    generated_at: nowIso(),
+    ...input
+  }));
+  const validation = validateCompletionProof(proof);
+  const dir = proofDir(root);
+  await ensureDir(dir);
+  const latestJson = path.join(dir, 'latest.json');
+  const latestMd = path.join(dir, 'latest.md');
+  await writeJsonAtomic(latestJson, proof);
+  await writeTextAtomic(latestMd, renderProofMarkdown(proof, validation));
+  await writeJsonAtomic(path.join(dir, 'file-changes.json'), proof.evidence?.files || []);
+  await writeTextAtomic(path.join(dir, 'unverified.md'), renderUnverifiedMarkdown(proof));
+  if (opts.command) await appendJsonl(path.join(dir, 'commands.jsonl'), redactSecrets({ ts: nowIso(), ...opts.command }));
+  if (proof.mission_id) {
+    const missionDir = path.join(root, '.sneakoscope', 'missions', proof.mission_id);
+    await writeJsonAtomic(path.join(missionDir, 'completion-proof.json'), proof);
+    await writeTextAtomic(path.join(missionDir, 'completion-proof.md'), renderProofMarkdown(proof, validation));
+  }
+  return { ok: validation.ok, proof, validation, files: { latest_json: latestJson, latest_md: latestMd } };
+}
+
+export function renderProofMarkdown(proof = {}, validation = validateCompletionProof(proof)) {
+  const lines = [
+    '# SKS Completion Proof',
+    '',
+    `- Schema: ${proof.schema || 'unknown'}`,
+    `- Version: ${proof.version || 'unknown'}`,
+    `- Mission: ${proof.mission_id || 'latest-or-null'}`,
+    `- Route: ${proof.route || 'unknown'}`,
+    `- Status: ${proof.status || 'not_verified'}`,
+    `- Validation: ${validation.ok ? 'pass' : 'fail'}`,
+    '',
+    '## Summary',
+    '',
+    `- Files changed: ${proof.summary?.files_changed ?? 0}`,
+    `- Commands run: ${proof.summary?.commands_run ?? 0}`,
+    `- Tests passed: ${proof.summary?.tests_passed ?? 0}`,
+    `- Tests failed: ${proof.summary?.tests_failed ?? 0}`,
+    `- Manual review required: ${proof.summary?.manual_review_required === false ? 'false' : 'true'}`,
+    '',
+    '## Evidence',
+    '',
+    `- Commands: ${proof.evidence?.commands?.length || 0}`,
+    `- Files: ${proof.evidence?.files?.length || 0}`,
+    `- Image voxels: ${proof.evidence?.image_voxels?.anchors || proof.evidence?.image_voxels?.anchor_count || 0}`,
+    `- TriWiki: ${proof.evidence?.triwiki?.status || 'not_recorded'}`,
+    '',
+    '## Unverified',
+    ''
+  ];
+  const unverified = proof.unverified?.length ? proof.unverified : ['No unverified claims recorded.'];
+  for (const item of unverified) lines.push(`- ${typeof item === 'string' ? item : JSON.stringify(item)}`);
+  if (proof.blockers?.length) {
+    lines.push('', '## Blockers', '');
+    for (const blocker of proof.blockers) lines.push(`- ${typeof blocker === 'string' ? blocker : JSON.stringify(blocker)}`);
+  }
+  if (validation.issues?.length) {
+    lines.push('', '## Validation Issues', '');
+    for (const issue of validation.issues) lines.push(`- ${issue}`);
+  }
+  return `${lines.join('\n')}\n`;
+}
+
+function renderUnverifiedMarkdown(proof = {}) {
+  const lines = ['# SKS Unverified Claims', ''];
+  const items = proof.unverified?.length ? proof.unverified : ['No unverified claims recorded.'];
+  for (const item of items) lines.push(`- ${typeof item === 'string' ? item : JSON.stringify(item)}`);
+  return `${lines.join('\n')}\n`;
+}

package/src/core/proof/route-adapter.mjs

@@ -0,0 +1,74 @@
+import path from 'node:path';
+import { collectProofEvidence } from './evidence-collector.mjs';
+import { writeCompletionProof } from './proof-writer.mjs';
+import { normalizeProofRoute, routeRequiresImageVoxelAnchors } from './route-proof-policy.mjs';
+
+export async function writeRouteCompletionProof(root, {
+  missionId = null,
+  route = null,
+  status = 'verified_partial',
+  gate = null,
+  summary = {},
+  artifacts = [],
+  evidence = {},
+  claims = [],
+  unverified = [],
+  blockers = [],
+  nextHumanActions = []
+} = {}) {
+  const collected = await collectProofEvidence(root);
+  const normalizedRoute = normalizeProofRoute(route);
+  const mergedEvidence = {
+    ...collected,
+    ...evidence,
+    route_gate: gate || evidence.route_gate || null,
+    artifacts: normalizeArtifacts(root, artifacts)
+  };
+  const normalizedStatus = normalizeRouteProofStatus(status, {
+    route: normalizedRoute,
+    evidence: mergedEvidence,
+    blockers,
+    unverified
+  });
+  return writeCompletionProof(root, {
+    mission_id: missionId,
+    route: normalizedRoute,
+    status: normalizedStatus,
+    summary: {
+      files_changed: collected.files?.length || 0,
+      commands_run: mergedEvidence.commands?.length || 0,
+      tests_passed: 0,
+      tests_failed: 0,
+      manual_review_required: normalizedStatus !== 'verified',
+      ...summary
+    },
+    evidence: mergedEvidence,
+    claims,
+    unverified,
+    blockers,
+    next_human_actions: nextHumanActions
+  }, {
+    command: {
+      cmd: `sks proof route ${missionId || 'latest'}`,
+      route: normalizedRoute,
+      status: normalizedStatus
+    }
+  });
+}
+
+function normalizeRouteProofStatus(status, { route, evidence, blockers, unverified }) {
+  if (blockers?.length) return status === 'failed' ? 'failed' : 'blocked';
+  if (status === 'verified' && unverified?.length) return 'verified_partial';
+  if (routeRequiresImageVoxelAnchors(route)) {
+    const anchors = evidence?.image_voxels?.anchors ?? evidence?.image_voxels?.anchor_count ?? 0;
+    if (Number(anchors) <= 0) return status === 'verified' ? 'blocked' : status;
+  }
+  return status;
+}
+
+function normalizeArtifacts(root, artifacts = []) {
+  return artifacts.map((artifact) => {
+    if (typeof artifact !== 'string') return artifact;
+    return path.isAbsolute(artifact) ? path.relative(root, artifact).split(path.sep).join('/') : artifact;
+  });
+}

package/src/core/proof/route-proof-gate.mjs

@@ -0,0 +1,33 @@
+import { containsPlaintextSecret } from '../secret-redaction.mjs';
+import { readRouteProof } from './proof-reader.mjs';
+import { validateCompletionProof } from './validation.mjs';
+import { proofStatusBlocks, routeRequiresCompletionProof, routeRequiresImageVoxelAnchors } from './route-proof-policy.mjs';
+
+export async function validateRouteCompletionProof(root, { missionId = null, route = null, state = {}, visualClaim = true } = {}) {
+  const proofRequired = state.proof_required === true || routeRequiresCompletionProof(route);
+  if (!proofRequired) return { ok: true, required: false, status: 'not_required', issues: [] };
+  const proof = await readRouteProof(root, missionId);
+  if (!proof) {
+    return {
+      ok: false,
+      required: true,
+      status: 'blocked',
+      issues: ['completion_proof_missing']
+    };
+  }
+  const validation = validateCompletionProof(proof);
+  const issues = [...validation.issues];
+  if (proofStatusBlocks(proof.status)) issues.push(`proof_status_${proof.status}`);
+  if (containsPlaintextSecret(proof)) issues.push('plaintext_secret');
+  if (routeRequiresImageVoxelAnchors(route || proof.route, { visualClaim })) {
+    const anchors = proof.evidence?.image_voxels?.anchors ?? proof.evidence?.image_voxels?.anchor_count ?? 0;
+    if (Number(anchors) <= 0) issues.push('image_voxel_anchors_missing');
+  }
+  return {
+    ok: issues.length === 0,
+    required: true,
+    status: issues.length ? 'blocked' : proof.status,
+    issues,
+    proof
+  };
+}

package/src/core/proof/route-proof-policy.mjs

@@ -0,0 +1,96 @@
+export const SERIOUS_ROUTE_ALIASES = Object.freeze([
+  '$Team',
+  '$DFix',
+  '$QA-LOOP',
+  '$Research',
+  '$AutoResearch',
+  '$PPT',
+  '$Image-UX-Review',
+  '$UX-Review',
+  '$Visual-Review',
+  '$UI-UX-Review',
+  '$From-Chat-IMG',
+  '$Computer-Use',
+  '$CU',
+  '$DB',
+  '$Wiki',
+  '$GX',
+  '$Goal',
+  '$MAD-SKS',
+  'hproof',
+  'proof-field',
+  'recallpulse'
+]);
+
+export const VISUAL_ROUTE_ALIASES = Object.freeze([
+  '$Image-UX-Review',
+  '$UX-Review',
+  '$Visual-Review',
+  '$UI-UX-Review',
+  '$From-Chat-IMG',
+  '$PPT',
+  '$QA-LOOP',
+  '$Computer-Use',
+  '$CU',
+  '$GX'
+]);
+
+const ROUTE_NORMALIZATION = Object.freeze({
+  team: '$Team',
+  dfix: '$DFix',
+  qaloop: '$QA-LOOP',
+  'qa-loop': '$QA-LOOP',
+  research: '$Research',
+  autoresearch: '$AutoResearch',
+  ppt: '$PPT',
+  imageuxreview: '$Image-UX-Review',
+  'image-ux-review': '$Image-UX-Review',
+  uxreview: '$UX-Review',
+  'ux-review': '$UX-Review',
+  visualreview: '$Visual-Review',
+  'visual-review': '$Visual-Review',
+  uiuxreview: '$UI-UX-Review',
+  'ui-ux-review': '$UI-UX-Review',
+  fromchatimg: '$From-Chat-IMG',
+  'from-chat-img': '$From-Chat-IMG',
+  computeruse: '$Computer-Use',
+  'computer-use': '$Computer-Use',
+  cu: '$CU',
+  db: '$DB',
+  wiki: '$Wiki',
+  gx: '$GX',
+  goal: '$Goal',
+  madsks: '$MAD-SKS',
+  'mad-sks': '$MAD-SKS',
+  hproof: 'hproof',
+  prooffield: 'proof-field',
+  'proof-field': 'proof-field',
+  recallpulse: 'recallpulse'
+});
+
+export function normalizeProofRoute(route) {
+  const raw = String(route || '').trim();
+  if (!raw) return null;
+  if (SERIOUS_ROUTE_ALIASES.includes(raw) || VISUAL_ROUTE_ALIASES.includes(raw)) return raw;
+  const stripped = raw.replace(/^\$/, '').replace(/[^A-Za-z0-9-]+/g, '').toLowerCase();
+  return ROUTE_NORMALIZATION[stripped] || raw;
+}
+
+export function routeRequiresCompletionProof(route) {
+  const normalized = normalizeProofRoute(route);
+  return SERIOUS_ROUTE_ALIASES.includes(normalized);
+}
+
+export function routeRequiresImageVoxelAnchors(route, opts = {}) {
+  const normalized = normalizeProofRoute(route);
+  if (opts.visualClaim === false) return false;
+  return VISUAL_ROUTE_ALIASES.includes(normalized);
+}
+
+export function routeFromState(state = {}) {
+  return normalizeProofRoute(state.route_command || state.route || state.mode || state.route_id || state.id);
+}
+
+export function proofStatusBlocks(status) {
+  return status === 'failed' || status === 'blocked' || status === 'not_verified';
+}