sneakoscope 0.7.33 → 0.7.37

package/README.md

@@ -53,7 +53,7 @@ sks selftest --mock
 | PPT pipeline | Uses `$PPT` for simple, restrained, information-first HTML/PDF presentation artifacts, first asking delivery context, audience profile, STP strategy, decision context, and 3+ pain-point to solution/aha mappings before source research, design-system work, HTML/PDF export, and render QA. Independent strategy/render/file-write phases run in parallel where inputs allow and are recorded in `ppt-parallel-report.json`; editable source HTML is preserved under `source-html/`, PPT-only temporary build files are cleaned after completion, installed skills/MCPs outside the `$PPT` allowlist are ignored, generated image assets may use `$imagegen` only when sealed in the contract, and `ppt-style-tokens.json` records the design SSOT plus fused source inputs. |
 | Computer Use fast lane | Uses `$Computer-Use` / `$CU` for UI/browser/visual work that needs maximum speed: skip Team debate and upfront TriWiki loops, use Codex Computer Use directly, then refresh/validate TriWiki and run Honest Mode at final closeout. |
 | Goal | Provides a fast SKS bridge overlay for Codex native persisted `/goal` create, pause, resume, and clear controls; implementation continues through the selected SKS execution route. |
-| TriWiki voxels | Maintains `.sneakoscope/wiki/context-pack.json` as the context SSOT with coordinate anchors, voxel metadata, `attention.use_first`, and `attention.hydrate_first`. |
+| TriWiki voxels | Maintains `.sneakoscope/wiki/context-pack.json` as the context SSOT with coordinate anchors, voxel metadata, `attention.use_first`, `attention.hydrate_first`, and prompt-bound mistake recall ledgers. |
 | Context7 | Requires current docs for external packages, APIs, MCPs, SDKs, and framework/runtime behavior when correctness depends on current guidance. |
 | Design SSOT | Treats `design.md` as the only design decision source of truth. `docs/Design-Sys-Prompt.md` is the builder prompt; getdesign.md, official getdesign docs, and curated DESIGN.md examples from `VoltAgent/awesome-design-md` are source inputs that must be fused into `design.md` or route-local style tokens instead of becoming parallel authorities. |
 | DB safety | Treats SQL, migrations, Supabase, RLS, and destructive operations as high risk. |
@@ -166,7 +166,7 @@ sks tmux check
 sks tmux status --once
 ```
 
-Bare `sks` creates or reuses the default named tmux session for Codex CLI. Use `sks tmux open` when you need explicit `--workspace` / `--session` flags, `sks tmux check` for readiness without launching, and `sks help` for CLI help.
+Bare `sks` creates or reuses the default named tmux session for Codex CLI and attaches to it in an interactive terminal. Use `sks tmux open` when you need explicit `--workspace` / `--session` flags, `sks tmux check` for readiness without launching, and `sks help` for CLI help. Use `--no-attach` or `SKS_TMUX_NO_AUTO_ATTACH=1` when you only want SKS to create/reuse the session and print the manual attach command.
 
 Before opening tmux, SKS checks the installed Codex CLI against npm `@openai/codex@latest`. If a newer version exists, it asks `Y/n`; answering `y` updates automatically with `npm i -g @openai/codex@latest` and then opens tmux with the updated Codex CLI.
 
@@ -177,7 +177,7 @@ sks --mad
 sks --mad --yes
 ```
 
-This creates/uses the `sks-mad-high` Codex profile for a one-shot full-access, high-reasoning tmux session with `approval_policy = "on-request"` and `approvals_reviewer = "auto_review"`. It is scoped to that explicit command and does not change normal SKS/DB safety defaults. Repeat launches reuse the same named SKS MAD tmux session.
+This creates/uses the `sks-mad-high` Codex profile for a one-shot full-access, high-reasoning tmux session with `approval_policy = "on-request"` and `approvals_reviewer = "auto_review"`, then attaches to the session in an interactive terminal. It is scoped to that explicit command and does not change normal SKS/DB safety defaults. Repeat launches reuse the same named SKS MAD tmux session.
 
 MAD does not disable the pipeline contract: stages, executors, reviewers, and auto-review policy still must not invent unrequested fallback implementation code. If the requested path cannot be implemented, SKS should block with evidence rather than add substitute behavior.
 
@@ -435,7 +435,7 @@ sks wiki refresh
 sks wiki validate .sneakoscope/wiki/context-pack.json
 ```
 
-TriWiki is the long-running context source of truth. It keeps compact high-trust recall in `attention.use_first` and source-hydration targets in `attention.hydrate_first`.
+TriWiki is the long-running context source of truth. It keeps compact high-trust recall in `attention.use_first`, source-hydration targets in `attention.hydrate_first`, and binds relevant prior-mistake claims into the current decision contract when they match the prompt.
 
 ## Safety Model
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "ㅅㅋㅅ",
-  "version": "0.7.33",
+  "version": "0.7.37",
   "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/main.mjs

@@ -52,12 +52,13 @@ import { classifyToolError, harnessGrowthReport } from '../core/evaluation.mjs';
 import { runWorkflowPerfBench, validateWorkflowPerfReport } from '../core/perf-bench.mjs';
 import { buildProofField, proofFieldFixture, validateProofFieldReport } from '../core/proof-field.mjs';
 import { recordMistake, writeMistakeMemoryReport } from '../core/mistake-memory.mjs';
+import { MISTAKE_RECALL_ARTIFACT, contractConsumesMistakeRecall } from '../core/mistake-recall.mjs';
 import { buildPromptContext } from '../core/prompt-context-builder.mjs';
 import { renderTeamDashboardState, writeTeamDashboardState } from '../core/team-dashboard-renderer.mjs';
 import { GOAL_WORKFLOW_ARTIFACT } from '../core/goal-workflow.mjs';
 import { CODEX_APP_DOCS_URL, codexAppIntegrationStatus, formatCodexAppStatus } from '../core/codex-app.mjs';
 import { OPENCLAW_SKILL_NAME, installOpenClawSkill } from '../core/openclaw.mjs';
-import { buildTmuxLaunchPlan, buildTmuxOpenArgs, createTmuxSession, isTmuxShellSession, runTmuxLaunchPlanSyntaxCheck, tmuxReadiness, tmuxStatusKind, defaultTmuxSessionName, formatTmuxBanner, launchTmuxTeamView, launchTmuxUi, platformTmuxInstallHint, runTmuxStatus, sanitizeTmuxSessionName, teamLaneStyle } from '../core/tmux-ui.mjs';
+import { buildTmuxLaunchPlan, buildTmuxOpenArgs, createTmuxSession, isTmuxShellSession, runTmuxLaunchPlanSyntaxCheck, shouldAutoAttachTmux, tmuxReadiness, tmuxStatusKind, defaultTmuxSessionName, formatTmuxBanner, launchTmuxTeamView, launchTmuxUi, platformTmuxInstallHint, runTmuxStatus, sanitizeTmuxSessionName, teamLaneStyle } from '../core/tmux-ui.mjs';
 import { autoReviewProfileName, autoReviewStatus, autoReviewSummary, enableAutoReview, disableAutoReview, enableMadHighProfile, madHighProfileName } from '../core/auto-review.mjs';
 import { context7Command } from './context7-command.mjs';
 import { askPostinstallQuestion, checkContext7, checkRequiredSkills, ensureCodexCliTool, ensureGlobalCodexSkillsDuringInstall, ensureProjectContext7Config, ensureRelatedCliTools, ensureSksCommandDuringInstall, globalCodexSkillsRoot, maybePromptCodexUpdateForLaunch, postinstall, postinstallBootstrapDecision, shouldAutoApproveInstall } from './install-helpers.mjs';
@@ -803,6 +804,11 @@ async function versioning(sub = 'status', args = []) {
     console.log(`Bump:      ${status.bump || 'patch'}`);
     console.log(`Hook:      ${status.hook_installed ? 'installed' : 'missing'}${status.hook_path ? ` ${status.hook_path}` : ''}`);
     console.log(`Last seen: ${status.last_version || 'none'}`);
+    if (status.runtime_drift?.checked) {
+      const drift = status.runtime_drift;
+      console.log(`Runtime:   ${drift.runtime_version || 'unknown'} (${drift.relation || 'unknown'})`);
+      if (!drift.ok) console.log(`Warning:   source package is ${drift.package_version}, but bare sks resolves to ${drift.runtime_version}. Use node ./bin/sks.mjs in this repo or reinstall/update the global package before trusting runtime behavior.`);
+    }
     if (!status.ok) console.log('Run: sks doctor --fix');
     return;
   }
@@ -1662,6 +1668,12 @@ async function effectivePackageVersion() {
   return highestVersion([PACKAGE_VERSION, pkg.version]);
 }
 
+async function selftestRuntimeVersion() {
+  const source = await safeReadText(path.join(packageRoot(), 'src', 'core', 'fsx.mjs'));
+  const sourceVersion = source.match(/export const PACKAGE_VERSION = ['"]([^'"]+)['"];/)?.[1] || null;
+  return sourceVersion || PACKAGE_VERSION;
+}
+
 function highestVersion(versions = []) {
   return versions.filter(Boolean).reduce((best, candidate) => compareVersions(candidate, best) > 0 ? candidate : best, '0.0.0');
 }
@@ -1925,6 +1937,10 @@ async function selftest() {
   if (!tmuxSyntax.ok || !tmuxSyntax.command.includes('tmux attach-session -t sks-mad-selftest')) throw new Error('selftest failed: MAD tmux attach plan is not stable by session name');
   const tmuxOpenArgs = buildTmuxOpenArgs(workspacePlan);
   if (tmuxOpenArgs.join(' ') !== 'attach-session -t sks-mad-selftest') throw new Error('selftest failed: MAD tmux attach args are not stable by session name');
+  if (!shouldAutoAttachTmux(['--mad'], {}, { stdin: { isTTY: true }, stdout: { isTTY: true } })) throw new Error('selftest failed: MAD tmux launch does not auto-attach in an interactive terminal');
+  if (shouldAutoAttachTmux(['--mad', '--json'], {}, { stdin: { isTTY: true }, stdout: { isTTY: true } })) throw new Error('selftest failed: MAD tmux json mode should not auto-attach');
+  if (shouldAutoAttachTmux(['--mad', '--no-attach'], {}, { stdin: { isTTY: true }, stdout: { isTTY: true } })) throw new Error('selftest failed: MAD tmux --no-attach should remain print-only');
+  if (shouldAutoAttachTmux(['--mad'], { SKS_TMUX_NO_AUTO_ATTACH: '1' }, { stdin: { isTTY: true }, stdout: { isTTY: true } })) throw new Error('selftest failed: SKS_TMUX_NO_AUTO_ATTACH should disable tmux auto-attach');
   if (!isTmuxShellSession({ TMUX: '/tmp/tmux-501/default,1,0' })) throw new Error('selftest failed: tmux shell session env was not detected');
   if (tmuxStatusKind({ ok: false, bin: null }) !== 'missing') throw new Error('selftest failed: missing tmux was not labeled missing');
   const bareDefault = await runProcess(process.execPath, [path.join(packageRoot(), 'bin', 'sks.mjs')], {
@@ -2238,7 +2254,8 @@ async function selftest() {
   if (String(hookUpdateCurrentContext).includes('Update SKS now') || String(hookUpdateCurrentContext).includes('Skip update for this conversation')) throw new Error('selftest failed: hook prompted for update even though installed SKS is current');
   const hookUpdateCurrentState = await readJson(path.join(hookUpdateCurrentTmp, '.sneakoscope', 'state', 'update-check.json'), {});
   if (hookUpdateCurrentState.pending_offer) throw new Error('selftest failed: current installed SKS left a pending update offer');
-  if (hookUpdateCurrentState.current !== '9.9.9' || hookUpdateCurrentState.runtime_current !== PACKAGE_VERSION || hookUpdateCurrentState.installed_current !== '9.9.9') throw new Error(`selftest failed: hook did not record effective installed SKS version: ${JSON.stringify({ expected: { current: '9.9.9', runtime_current: PACKAGE_VERSION, installed_current: '9.9.9' }, actual: hookUpdateCurrentState })}`);
+  const hookRuntimeExpected = await selftestRuntimeVersion();
+  if (hookUpdateCurrentState.current !== '9.9.9' || hookUpdateCurrentState.runtime_current !== hookRuntimeExpected || hookUpdateCurrentState.installed_current !== '9.9.9') throw new Error(`selftest failed: hook did not record effective installed SKS version: ${JSON.stringify({ expected: { current: '9.9.9', runtime_current: hookRuntimeExpected, installed_current: '9.9.9', loaded_runtime_current: PACKAGE_VERSION }, actual: hookUpdateCurrentState })}`);
   const hookUpdatePendingTmp = tmpdir();
   await initProject(hookUpdatePendingTmp, {});
   await writeJsonAtomic(path.join(hookUpdatePendingTmp, '.sneakoscope', 'state', 'update-check.json'), {
@@ -3014,12 +3031,27 @@ async function selftest() {
   const coord = rgbaToWikiCoord({ r: 12, g: 34, b: 56, a: 255 });
   if (coord.schema !== 'sks.wiki-coordinate.v1' || coord.xyzw.length !== 4) throw new Error('selftest failed: RGBA wiki coordinate conversion');
   await writeTextAtomic(path.join(tmp, '.sneakoscope', 'memory', 'q2_facts', 'selftest.md'), '- claim: Selftest memory claim must be selected before lower-weight mission notes. | id: selftest-memory-priority | source: src/cli/main.mjs | risk: high | status: supported | evidence_count: 3 | required_weight: 1.0 | trust_score: 0.9\n');
+  await writeTextAtomic(path.join(tmp, '.sneakoscope', 'memory', 'q2_facts', 'tail-repeat.md'), [
+    ...Array.from({ length: 60 }, (_, i) => `- claim: Low priority filler memory ${i}. | id: tail-filler-${i} | source: src/cli/main.mjs | risk: low | status: supported | evidence_count: 1 | required_weight: 0.1 | trust_score: 0.5`),
+    '- claim: TriWiki repeated mistake recall must preserve recent high-weight tail lessons. | id: tail-repeat-mistake | source: src/core/mistake-recall.mjs | risk: high | status: supported | freshness: fresh | evidence_count: 4 | required_weight: 1.2 | trust_score: 0.95'
+  ].join('\n'));
   await createMission(tmp, { mode: 'sks', prompt: '모호한 질문은 그만 물어봐야지;; triwiki로 예측해' });
   await createMission(tmp, { mode: 'sks', prompt: 'triwiki에서 자주 요청하는 것들은 카운팅해서 더 우선 참고해줘' });
+  const projectClaims = await projectWikiClaims(tmp);
+  if (!projectClaims.some((claim) => claim.id === 'tail-repeat-mistake')) throw new Error('selftest failed: tail high-weight memory claim was dropped from TriWiki ingestion');
+  const recallPrompt = 'triwiki 반복 실수 방지 개선 selftest';
+  const recallMission = await createMission(tmp, { mode: 'team', prompt: recallPrompt });
+  await writeJsonAtomic(path.join(recallMission.dir, 'required-answers.schema.json'), { prompt: recallPrompt, slots: [{ id: 'GOAL_PRECISE', required: true }, { id: 'ACCEPTANCE_CRITERIA', required: true, type: 'array' }] });
+  await writeJsonAtomic(path.join(recallMission.dir, 'answers.json'), { GOAL_PRECISE: recallPrompt, ACCEPTANCE_CRITERIA: ['repeat mistake memory is consumed'] });
+  const recallSeal = await sealContract(recallMission.dir, { id: recallMission.id, prompt: recallPrompt, mode: 'team' });
+  if (!recallSeal.ok) throw new Error('selftest failed: mistake recall contract did not seal');
+  const recallLedger = await readJson(path.join(recallMission.dir, MISTAKE_RECALL_ARTIFACT), null);
+  if (!recallLedger?.required || !recallLedger.matches?.some((match) => match.id === 'tail-repeat-mistake')) throw new Error('selftest failed: mistake recall did not match tail TriWiki lesson');
+  if (!contractConsumesMistakeRecall(recallSeal.contract, recallLedger).ok) throw new Error('selftest failed: mistake recall was not consumed by decision contract');
   const wikiPack = contextCapsule({
     mission: { id: 'selftest-wiki', coord: { rgba: { r: 48, g: 132, b: 212, a: 240 } } },
     role: 'verifier',
-    claims: await projectWikiClaims(tmp),
+    claims: projectClaims,
     q4: { mode: 'selftest' },
     q3: ['sks', 'llm-wiki', 'wiki-coordinate'],
     budget: { maxWikiAnchors: 48, includeTrustSummary: true }
@@ -3070,6 +3102,17 @@ async function selftest() {
   const primingClaim = primingPack.claims?.find((claim) => claim.id === 'positive-recall-guard');
   if (!primingClaim || /elephant|do\s+not/i.test(primingClaim.text || '') || primingClaim.text_policy !== 'positive_recall_negation_suppressed') throw new Error('selftest failed: TriWiki compact recall did not suppress negative priming text');
   if (!primingPack.attention?.hydrate_first?.some((row) => row[0] === 'positive-recall-guard' && String(row[1]).includes('negative_priming'))) throw new Error('selftest failed: negative priming claim was not source-hydration gated');
+  const voxelPromotionPack = contextCapsule({
+    mission: { id: 'voxel-promotion-selftest', coord: { rgba: { r: 70, g: 100, b: 130, a: 255 } } },
+    role: 'worker',
+    claims: [
+      { id: 'voxel-priority-hydrate', text: 'TriWiki memory repeat prevention should hydrate source evidence when priority route layers are high.', authority: 'code', risk: 'low', status: 'supported', freshness: 'fresh', required_weight: 1.25, trust_score: 0.95, coord: { rgba: { r: 70, g: 100, b: 130, a: 255 } } }
+    ],
+    q4: { mode: 'voxel-promotion-selftest' },
+    q3: ['triwiki', 'memory'],
+    budget: { maxClaims: 1, maxWikiAnchors: 1, maxAttentionUse: 1, maxAttentionHydrate: 1 }
+  });
+  if (!voxelPromotionPack.attention?.hydrate_first?.some((row) => row[0] === 'voxel-priority-hydrate' && String(row[1]).startsWith('voxel:priority_route'))) throw new Error('selftest failed: voxel priority route did not promote hydration');
   const dryRunPack = await writeWikiContextPack(tmp, ['--max-anchors', '4'], { dryRun: true });
   if (wikiVoxelRowCount(dryRunPack.pack.wiki) !== 4) throw new Error('selftest failed: dry-run wiki pack did not build voxel rows');
   if (await exists(dryRunPack.file)) throw new Error('selftest failed: wiki refresh dry-run wrote context pack');

package/src/cli/maintenance-commands.mjs

@@ -991,7 +991,7 @@ async function memoryWikiClaims(root) {
       continue;
     }
     if (!text.trim()) continue;
-    const rows = parseMemoryClaimRows(text, relFile).slice(0, 24);
+    const rows = selectMemoryClaimRows(parseMemoryClaimRows(text, relFile), 48);
     let index = 0;
     for (const row of rows) {
       const source = row.source || relFile;
@@ -1015,6 +1015,48 @@ async function memoryWikiClaims(root) {
   return claims;
 }
 
+function selectMemoryClaimRows(rows = [], limit = 48) {
+  const prepared = (rows || []).map((row, index) => ({ row, index, total: rows.length }));
+  if (prepared.length <= limit) return prepared.map((item) => item.row);
+  const picked = new Map();
+  const add = (item) => {
+    if (!item?.row) return;
+    const key = item.row.id || `${item.index}:${item.row.text}`;
+    if (!picked.has(key)) picked.set(key, item);
+  };
+  const required = prepared.filter(({ row }) =>
+    Number(row.required_weight || 0) >= 0.95
+    || Number(row.trust_score || 0) >= 0.9
+    || row.risk === 'critical'
+    || (row.risk === 'high' && Number(row.evidence_count || 0) >= 3)
+  );
+  for (const item of required) add(item);
+  for (const item of prepared.slice(-12)) add(item);
+  const already = new Set([...picked.values()].map((item) => item.index));
+  const scored = prepared
+    .filter((item) => !already.has(item.index))
+    .map((item) => ({ ...item, score: memoryRowPriorityScore(item) }))
+    .sort((a, b) => (b.score - a.score) || (a.index - b.index));
+  for (const item of scored) {
+    if (picked.size >= limit) break;
+    add(item);
+  }
+  return [...picked.values()]
+    .sort((a, b) => a.index - b.index)
+    .slice(0, limit)
+    .map((item) => item.row);
+}
+
+function memoryRowPriorityScore({ row, index, total }) {
+  const required = Number(row.required_weight || 0);
+  const trust = Number(row.trust_score || 0);
+  const evidence = Number(row.evidence_count || 0);
+  const recency = total > 1 ? index / (total - 1) : 1;
+  const risk = { low: 0, medium: 0.35, high: 0.9, critical: 1.25 }[row.risk || 'medium'] ?? 0.35;
+  const freshness = { fresh: 0.45, unknown: 0.1, stale: -0.4 }[row.freshness || 'unknown'] ?? 0.1;
+  return required * 8 + trust * 4 + Math.log1p(Math.max(0, evidence)) + recency * 2 + risk + freshness;
+}
+
 async function listMemoryClaimFiles(base) {
   const out = [];
   async function walk(dir, depth = 0) {
@@ -1065,6 +1107,7 @@ function normalizeMemoryClaimRow(row, relFile) {
       risk: row.risk,
       status: row.status || row.confidence,
       freshness: row.freshness,
+      updated_at: row.updated_at || row.updatedAt || row.created_at || row.createdAt,
       evidence_count: Number.isFinite(Number(row.evidence_count)) ? Number(row.evidence_count) : undefined,
       required_weight: Number.isFinite(Number(row.required_weight)) ? Number(row.required_weight) : undefined,
       trust_score: Number.isFinite(Number(row.trust_score)) ? Number(row.trust_score) : undefined
@@ -1082,6 +1125,7 @@ function normalizeMemoryClaimRow(row, relFile) {
     risk: extractClaimField(clean, 'risk') || 'high',
     status,
     freshness: extractClaimField(clean, 'freshness') || 'fresh',
+    updated_at: extractClaimField(clean, 'updated_at') || extractClaimField(clean, 'updatedAt') || extractClaimField(clean, 'created_at'),
     evidence_count: parseOptionalNumber(extractClaimField(clean, 'evidence_count')),
     required_weight: parseOptionalNumber(extractClaimField(clean, 'required_weight')),
     trust_score: parseOptionalNumber(extractClaimField(clean, 'trust_score'))

package/src/core/decision-contract.mjs

@@ -2,6 +2,7 @@ import path from 'node:path';
 import { readJson, writeJsonAtomic, nowIso, sha256 } from './fsx.mjs';
 import { validateQaLoopAnswers } from './qa-loop.mjs';
 import { inferAnswersForPrompt } from './questions.mjs';
+import { bindMistakeRecallToAnswers, buildMistakeRecallLedger, mistakeRecallContractSummary, writeMistakeRecallArtifacts } from './mistake-recall.mjs';
 
 function isEmptyAnswer(v, slot = {}) {
   if (v === undefined || v === null) return true;
@@ -38,7 +39,7 @@ export function validateAnswers(schema, answers) {
   return { ok: errors.length === 0, errors, resolved, totalRequired: schema.slots.filter((s) => s.required).length };
 }
 
-export function buildDecisionContract({ mission, schema, answers }) {
+export function buildDecisionContract({ mission, schema, answers, mistakeRecall = null }) {
   const madSks = answers.MAD_SKS_MODE === 'explicit_invocation_only';
   const defaults = {
     if_multiple_valid_implementations: 'choose_smallest_reversible_change',
@@ -111,6 +112,7 @@ export function buildDecisionContract({ mission, schema, answers }) {
     acceptance_criteria: Array.isArray(answers.ACCEPTANCE_CRITERIA) ? answers.ACCEPTANCE_CRITERIA : String(answers.ACCEPTANCE_CRITERIA || '').split('\n').map((x) => x.trim()).filter(Boolean),
     non_goals: Array.isArray(answers.NON_GOALS) ? answers.NON_GOALS : String(answers.NON_GOALS || '').split('\n').map((x) => x.trim()).filter(Boolean),
     test_scope: answers.TEST_SCOPE,
+    triwiki_mistake_recall: mistakeRecallContractSummary(mistakeRecall),
     approved_defaults: defaults,
     decision_ladder: [
       'seed_contract',
@@ -134,21 +136,41 @@ export async function sealContract(missionDir, mission) {
   const schema = await readJson(path.join(missionDir, 'required-answers.schema.json'));
   const explicitAnswers = await readJson(path.join(missionDir, 'answers.json'));
   const inferred = inferAnswersForPrompt(mission?.prompt || schema?.prompt || '', explicitAnswers);
-  const answers = {
+  const baseAnswers = {
     ...(schema.inferred_answers || {}),
     ...inferred.answers,
     ...explicitAnswers
   };
+  const root = rootFromMissionDir(missionDir);
+  const mistakeRecall = await buildMistakeRecallLedger(root, {
+    prompt: mission?.prompt || schema?.prompt || '',
+    answers: baseAnswers
+  });
+  const answers = bindMistakeRecallToAnswers(baseAnswers, mistakeRecall);
   const validation = validateAnswers(schema, answers);
   if (!validation.ok) return { ok: false, validation };
-  const contract = buildDecisionContract({ mission, schema, answers });
+  const contract = buildDecisionContract({ mission, schema, answers, mistakeRecall });
+  const mistakeRecallConsumption = await writeMistakeRecallArtifacts(missionDir, mistakeRecall, contract);
   await writeJsonAtomic(path.join(missionDir, 'resolved-answers.json'), {
     explicit_answers: explicitAnswers,
     inferred_answers: { ...(schema.inferred_answers || {}), ...inferred.answers },
     inference_notes: { ...(schema.inference_notes || {}), ...inferred.notes },
-    answers
+    answers,
+    mistake_recall: {
+      artifact: 'mistake-recall-ledger.json',
+      consumed: mistakeRecallConsumption.ok,
+      required: mistakeRecall.required
+    }
   });
   await writeJsonAtomic(path.join(missionDir, 'decision-contract.json'), contract);
   await writeJsonAtomic(path.join(missionDir, 'answer-validation.json'), validation);
   return { ok: true, validation, contract };
 }
+
+function rootFromMissionDir(missionDir) {
+  const resolved = path.resolve(missionDir);
+  const parts = resolved.split(path.sep);
+  const idx = parts.lastIndexOf('.sneakoscope');
+  if (idx > 0) return parts.slice(0, idx).join(path.sep) || path.sep;
+  return path.resolve(resolved, '..', '..', '..');
+}

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.33';
+export const PACKAGE_VERSION = '0.7.37';
 export const DEFAULT_PROCESS_TAIL_BYTES = 256 * 1024;
 export const DEFAULT_PROCESS_TIMEOUT_MS = 30 * 60 * 1000;
 

package/src/core/mistake-recall.mjs

@@ -0,0 +1,277 @@
+import path from 'node:path';
+import fsp from 'node:fs/promises';
+import { nowIso, readJson, sha256, writeJsonAtomic } from './fsx.mjs';
+
+export const MISTAKE_RECALL_ARTIFACT = 'mistake-recall-ledger.json';
+export const CLAIM_CONSUMPTION_ARTIFACT = 'claim-consumption-ledger.json';
+
+const MISTAKE_CUE_RE = /\b(mistake|repeat|repeated|regression|forget|forgot|stale|drift|ambiguity|clarification|fallback|question|runtime|route|triwiki|wiki|voxel|memory)\b|반복|실수|또\s*|까먹|기억|모호|질문|복셀|검수|개선|정상\s*동작/i;
+
+export async function buildMistakeRecallLedger(root, { prompt = '', answers = {}, maxMatches = 8 } = {}) {
+  const seedText = `${prompt || ''}\n${JSON.stringify(answers || {})}`;
+  const queryTerms = tokenize(seedText);
+  const claims = [
+    ...(await claimsFromContextPack(root)),
+    ...(await claimsFromMemory(root))
+  ];
+  const scored = claims
+    .map((claim) => ({ ...claim, ...scoreClaim(claim, queryTerms, seedText) }))
+    .filter((claim) => claim.score >= 2.5 || (claim.mistake_cue && claim.overlap_count > 0))
+    .sort((a, b) => (b.score - a.score) || String(a.id).localeCompare(String(b.id)))
+    .slice(0, maxMatches);
+  return {
+    schema_version: 1,
+    generated_at: nowIso(),
+    prompt_hash: sha256(seedText),
+    required: scored.length > 0,
+    status: scored.length ? 'matched' : 'no_relevant_mistake_claims',
+    query_terms: [...queryTerms].slice(0, 24),
+    matches: scored.map((claim) => ({
+      id: claim.id,
+      text: claim.text,
+      source: claim.source,
+      file: claim.file || claim.source,
+      reason: claim.reason,
+      score: Number(claim.score.toFixed(3)),
+      overlap_count: claim.overlap_count,
+      required_weight: claim.required_weight,
+      trust_score: claim.trust_score,
+      risk: claim.risk,
+      freshness: claim.freshness
+    }))
+  };
+}
+
+export function bindMistakeRecallToAnswers(answers = {}, ledger = {}) {
+  if (!ledger?.required || !Array.isArray(ledger.matches) || !ledger.matches.length) return answers;
+  const ids = ledger.matches.map((match) => match.id).filter(Boolean);
+  const recallLine = `TriWiki mistake recall consumed before implementation: ${ids.join(', ')}`;
+  const riskBoundary = Array.isArray(answers.RISK_BOUNDARY)
+    ? [...answers.RISK_BOUNDARY]
+    : String(answers.RISK_BOUNDARY || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  if (!riskBoundary.includes(recallLine)) riskBoundary.push(recallLine);
+  const acceptance = Array.isArray(answers.ACCEPTANCE_CRITERIA)
+    ? [...answers.ACCEPTANCE_CRITERIA]
+    : String(answers.ACCEPTANCE_CRITERIA || '').split(/\r?\n/).map((line) => line.trim()).filter(Boolean);
+  const acceptanceLine = 'mistake-recall-ledger.json is consumed by the decision contract when relevant TriWiki mistakes are found';
+  if (!acceptance.includes(acceptanceLine)) acceptance.push(acceptanceLine);
+  return {
+    ...answers,
+    RISK_BOUNDARY: riskBoundary,
+    ACCEPTANCE_CRITERIA: acceptance,
+    TRIWIKI_MISTAKE_RECALL_REQUIRED: true,
+    TRIWIKI_MISTAKE_RECALL_IDS: ids,
+    TRIWIKI_MISTAKE_RECALL_STATUS: ledger.status
+  };
+}
+
+export function mistakeRecallContractSummary(ledger = {}) {
+  if (!ledger?.required) return { required: false, status: ledger?.status || 'not_required', matches: [] };
+  return {
+    required: true,
+    status: ledger.status,
+    artifact: MISTAKE_RECALL_ARTIFACT,
+    match_count: ledger.matches?.length || 0,
+    ids: (ledger.matches || []).map((match) => match.id).filter(Boolean),
+    sources: [...new Set((ledger.matches || []).map((match) => match.source).filter(Boolean))].slice(0, 8)
+  };
+}
+
+export function contractConsumesMistakeRecall(contract = {}, ledger = {}) {
+  if (!ledger?.required) return { ok: true, missing: [] };
+  const ids = (ledger.matches || []).map((match) => match.id).filter(Boolean);
+  if (!ids.length) return { ok: true, missing: [] };
+  const contractText = JSON.stringify(contract || {});
+  const missing = ids.filter((id) => !contractText.includes(id));
+  const summary = contract?.triwiki_mistake_recall;
+  if (!summary?.required) missing.push('contract.triwiki_mistake_recall.required');
+  if (summary?.artifact !== MISTAKE_RECALL_ARTIFACT) missing.push('contract.triwiki_mistake_recall.artifact');
+  return { ok: missing.length === 0, missing };
+}
+
+export async function writeMistakeRecallArtifacts(missionDir, ledger = {}, contract = {}) {
+  await writeJsonAtomic(path.join(missionDir, MISTAKE_RECALL_ARTIFACT), ledger);
+  const consumption = {
+    schema_version: 1,
+    generated_at: nowIso(),
+    artifact: MISTAKE_RECALL_ARTIFACT,
+    contract_hash: contract?.sealed_hash || null,
+    ...contractConsumesMistakeRecall(contract, ledger)
+  };
+  await writeJsonAtomic(path.join(missionDir, CLAIM_CONSUMPTION_ARTIFACT), consumption);
+  return consumption;
+}
+
+export async function mistakeRecallGateStatus(root, state = {}) {
+  const id = state?.mission_id;
+  if (!id) return { ok: true, missing: [] };
+  const dir = path.join(root, '.sneakoscope', 'missions', id);
+  const ledger = await readJson(path.join(dir, MISTAKE_RECALL_ARTIFACT), null);
+  if (!ledger) return { ok: true, missing: [] };
+  if (!ledger.required) return { ok: true, missing: [] };
+  const contract = await readJson(path.join(dir, 'decision-contract.json'), null);
+  if (!contract) return { ok: false, missing: ['decision-contract.json'] };
+  const consumed = contractConsumesMistakeRecall(contract, ledger);
+  return {
+    ok: consumed.ok,
+    missing: consumed.missing || [],
+    source: path.join('.sneakoscope', 'missions', id, MISTAKE_RECALL_ARTIFACT)
+  };
+}
+
+async function claimsFromContextPack(root) {
+  const pack = await readJson(path.join(root, '.sneakoscope', 'wiki', 'context-pack.json'), null);
+  const claims = [];
+  for (const claim of Array.isArray(pack?.claims) ? pack.claims : []) {
+    if (!claim?.id || !claim?.text) continue;
+    claims.push({
+      id: String(claim.id),
+      text: String(claim.text).slice(0, 420),
+      source: claim.source || '.sneakoscope/wiki/context-pack.json',
+      file: claim.source || '.sneakoscope/wiki/context-pack.json',
+      authority: claim.authority || 'wiki',
+      risk: claim.risk || 'medium',
+      freshness: claim.freshness || 'unknown',
+      trust_score: numberOrUndefined(claim.trust_score)
+    });
+  }
+  return claims;
+}
+
+async function claimsFromMemory(root) {
+  const base = path.join(root, '.sneakoscope', 'memory');
+  const files = await listClaimFiles(base);
+  const rows = [];
+  for (const file of files.slice(0, 120)) {
+    const rel = path.relative(root, file);
+    let text = '';
+    try {
+      text = await fsp.readFile(file, 'utf8');
+    } catch {
+      continue;
+    }
+    rows.push(...parseClaimRows(text, rel));
+  }
+  return rows;
+}
+
+async function listClaimFiles(base) {
+  const out = [];
+  async function walk(dir, depth = 0) {
+    if (depth > 3) return;
+    let entries = [];
+    try {
+      entries = await fsp.readdir(dir, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    for (const entry of entries.sort((a, b) => a.name.localeCompare(b.name))) {
+      const file = path.join(dir, entry.name);
+      if (entry.isDirectory()) await walk(file, depth + 1);
+      else if (/\.(md|txt|json)$/i.test(entry.name)) out.push(file);
+    }
+  }
+  await walk(base);
+  return out;
+}
+
+function parseClaimRows(text, relFile) {
+  if (/\.json$/i.test(relFile)) {
+    try {
+      const parsed = JSON.parse(text);
+      const rows = Array.isArray(parsed) ? parsed : (Array.isArray(parsed.claims) ? parsed.claims : []);
+      return rows.map((row) => normalizeClaim(row, relFile)).filter(Boolean);
+    } catch {
+      return [];
+    }
+  }
+  return String(text || '').split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line && !line.startsWith('#'))
+    .map((line) => normalizeClaim(line.replace(/^[-*]\s*/, ''), relFile))
+    .filter(Boolean);
+}
+
+function normalizeClaim(row, relFile) {
+  if (!row) return null;
+  if (typeof row === 'object') {
+    const text = String(row.text || row.claim || '').trim();
+    if (!text) return null;
+    return {
+      id: row.id ? String(row.id) : `memory-${slug(relFile)}-${sha256(text).slice(0, 8)}`,
+      text: text.slice(0, 420),
+      source: row.source || row.file || relFile,
+      file: row.file || row.source || relFile,
+      risk: row.risk || 'medium',
+      freshness: row.freshness || 'unknown',
+      required_weight: numberOrUndefined(row.required_weight),
+      trust_score: numberOrUndefined(row.trust_score)
+    };
+  }
+  const clean = String(row || '').trim();
+  if (!/\bclaim\s*:/i.test(clean)) return null;
+  const claimText = clean.replace(/^claim\s*:\s*/i, '').trim();
+  return {
+    id: extractField(clean, 'id') || `memory-${slug(relFile)}-${sha256(clean).slice(0, 8)}`,
+    text: claimText.slice(0, 420),
+    source: extractField(clean, 'source') || extractField(clean, 'file') || relFile,
+    file: extractField(clean, 'file') || extractField(clean, 'source') || relFile,
+    risk: extractField(clean, 'risk') || 'medium',
+    freshness: extractField(clean, 'freshness') || 'unknown',
+    required_weight: numberOrUndefined(extractField(clean, 'required_weight')),
+    trust_score: numberOrUndefined(extractField(clean, 'trust_score'))
+  };
+}
+
+function scoreClaim(claim, queryTerms, seedText) {
+  const hay = `${claim.id || ''} ${claim.text || ''} ${claim.source || ''}`.toLowerCase();
+  let overlap = 0;
+  for (const term of queryTerms) if (hay.includes(term)) overlap += 1;
+  const mistakeCue = MISTAKE_CUE_RE.test(hay);
+  const seedMistakeCue = MISTAKE_CUE_RE.test(seedText || '');
+  const required = Number(claim.required_weight || 0);
+  const trust = Number(claim.trust_score || 0);
+  const risk = { low: 0, medium: 0.25, high: 0.75, critical: 1.1 }[claim.risk || 'medium'] ?? 0.25;
+  const freshness = { fresh: 0.45, unknown: 0.1, stale: -0.25 }[claim.freshness || 'unknown'] ?? 0.1;
+  const score = overlap + required * 3.5 + trust * 1.5 + risk + freshness + (mistakeCue ? 2 : 0) + (seedMistakeCue && mistakeCue ? 1 : 0);
+  return {
+    score,
+    overlap_count: overlap,
+    mistake_cue: mistakeCue,
+    reason: [
+      overlap ? `prompt_overlap:${overlap}` : null,
+      mistakeCue ? 'mistake_cue' : null,
+      required ? `required_weight:${required}` : null,
+      trust ? `trust:${trust}` : null
+    ].filter(Boolean).join(',')
+  };
+}
+
+function tokenize(text) {
+  const out = new Set();
+  for (const match of String(text || '').toLowerCase().matchAll(/[a-z0-9_/-]{3,}|[가-힣]{2,}/g)) {
+    const token = match[0].replace(/^[-_/]+|[-_/]+$/g, '');
+    if (token && !STOP_TERMS.has(token)) out.add(token);
+  }
+  return out;
+}
+
+const STOP_TERMS = new Set([
+  'the', 'and', 'for', 'with', 'that', 'this', 'from', 'into', 'true', 'false',
+  '사용자', '요청', '현재', '코드', '기준', '구현', '작업', '완료', '검증'
+]);
+
+function extractField(text, key) {
+  const escaped = key.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  const match = String(text || '').match(new RegExp(`\\b${escaped}\\s*[:=]\\s*\\\`?([^\\\`|,;]+)`, 'i'));
+  return match ? match[1].trim().replace(/[.;)]$/, '') : null;
+}
+
+function numberOrUndefined(value) {
+  const n = Number(value);
+  return Number.isFinite(n) ? n : undefined;
+}
+
+function slug(value) {
+  return String(value || 'claim').toLowerCase().replace(/[^a-z0-9]+/g, '-').replace(/^-+|-+$/g, '').slice(0, 60) || 'claim';
+}

package/src/core/pipeline.mjs

@@ -10,6 +10,7 @@ import { GOAL_WORKFLOW_ARTIFACT, writeGoalWorkflow } from './goal-workflow.mjs';
 import { writeCodeStructureReport } from './code-structure.mjs';
 import { writeMemorySweepReport } from './memory-governor.mjs';
 import { writeMistakeMemoryReport } from './mistake-memory.mjs';
+import { MISTAKE_RECALL_ARTIFACT, mistakeRecallGateStatus } from './mistake-recall.mjs';
 import { recordSkillDreamEvent, skillDreamPolicyText, writeSkillForgeReport } from './skill-forge.mjs';
 import { writeResearchPlan } from './research.mjs';
 import { PPT_REQUIRED_GATE_FIELDS } from './ppt.mjs';
@@ -993,6 +994,15 @@ export async function projectGateStatus(root, state = {}) {
       source: active.file ? `.sneakoscope/missions/${id}/${active.file}` : null
     });
   }
+  const mistakeRecall = await mistakeRecallGateStatus(root, state);
+  if (id && (!mistakeRecall.ok || mistakeRecall.source)) {
+    gates.push({
+      id: MISTAKE_RECALL_ARTIFACT,
+      ok: mistakeRecall.ok,
+      missing: mistakeRecall.missing || [],
+      source: `.sneakoscope/missions/${id}/${MISTAKE_RECALL_ARTIFACT}`
+    });
+  }
   const reflection = await reflectionGateStatus(root, state);
   if (reflectionRequiredForState(state)) {
     gates.push({
@@ -1032,6 +1042,10 @@ export async function evaluateStop(root, state, payload, opts = {}) {
   if (state?.subagents_required && !(await hasSubagentEvidence(root, state))) {
     return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} requires subagent execution evidence before completion. Spawn worker/reviewer subagents for disjoint code-changing work, or record explicit evidence that subagents were unavailable or unsafe to split.`, { gate: 'subagent-evidence' });
   }
+  const mistakeRecall = await mistakeRecallGateStatus(root, state);
+  if (!mistakeRecall.ok) {
+    return complianceBlock(root, state, `SKS ${state.route_command || state.mode || 'route'} found relevant TriWiki mistake memory that is not bound to the decision contract. Re-run pipeline answer or seal the contract so ${MISTAKE_RECALL_ARTIFACT} is consumed before finishing.`, { gate: MISTAKE_RECALL_ARTIFACT, missing: mistakeRecall.missing });
+  }
   if (opts.noQuestion) {
     if (containsUserQuestion(last)) return complianceBlock(root, state, noQuestionContinuationReason(), { gate: 'no-question' });
     const gate = await passedActiveGate(root, state);

package/src/core/questions.mjs

@@ -230,14 +230,24 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
   const authWork = /로그인|auth|session|token|인증/.test(lower);
   const prioritySignalWork = /화|짜증|답답|;;|!!|강력|기억|우선|자주|반복|카운팅|count|frequency|frequent|priority|weight/.test(lower);
   const cliSurfaceWork = /\b(cli|command|route|usage|help|sks)\b|명령|커맨드|사용법/.test(lower);
+  const explicitRouteWork = /^\s*\$(?:research|team|goal|dfix|ppt|qa-loop|wiki|db|gx|computer-use|cu|autoresearch|sks|answer|help)\b/i.test(String(prompt || ''));
+  const triwikiAuditWork = /(triwiki|tri\s*wiki|wiki|복셀|voxel)/.test(lower)
+    && /(검수|연구|개선|정상|동작|작동|반복|실수|mistake|repeat|audit|inspect|prevent|방지)/.test(lower);
   const chatCaptureWork = hasFromChatImgSignal(text)
     && /(chat|conversation|message|messenger|kakao|screenshot|capture|채팅|대화|메신저|카톡|캡처|스크린샷)/i.test(text)
     && /(image|photo|attachment|attached|이미지|사진|첨부)/i.test(text)
     && /(client|customer|request|change|modify|fix|match|ocr|extract|text|고객사|클라이언트|요청|수정|변경|매칭|추출|글자|텍스트)/i.test(text);
-  const kind = versionWork ? 'version' : chatCaptureWork ? 'chat_capture' : prioritySignalWork ? 'priority' : questionGateWork ? 'questions' : installWork ? 'install' : null;
+  const effectivePrioritySignalWork = prioritySignalWork
+    && !explicitRouteWork
+    && !triwikiAuditWork
+    && !versionWork
+    && !presentationWork
+    && !chatCaptureWork;
+  const kind = versionWork ? 'version' : chatCaptureWork ? 'chat_capture' : triwikiAuditWork ? 'triwiki_audit' : effectivePrioritySignalWork ? 'priority' : questionGateWork ? 'questions' : installWork ? 'install' : null;
   const goals = {
     version: version ? `sneakoscope 버전을 ${version}로 올린다` : 'sneakoscope 버전을 다음 patch 버전으로 올린다',
     chat_capture: 'From-Chat-IMG로 채팅 요구사항과 첨부 원본 이미지를 매칭해 고객사 작업 지시서를 만들고 반영한다',
+    triwiki_audit: 'TriWiki가 반복 실수를 막는지 검수하고, 실패 경로를 코드와 검증으로 개선한다',
     priority: '강한 불만과 반복 요청을 TriWiki 우선순위 신호로 기록한다',
     questions: '예측 가능한 답은 추론하고 실제 모호한 항목만 질문한다',
     presentation: '청중과 STP 전략에 맞는 HTML 기반 발표자료/PDF 산출물을 만든다',
@@ -246,6 +256,7 @@ export function inferAnswersForPrompt(prompt, explicitAnswers = {}) {
   const criteria = {
     version: [version ? `version refs are ${version}` : 'version refs advance consistently', 'publish:dry gate passes', 'npm publish is not run'],
     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', 'Codex Computer Use visual inspection strengthens matches when available; no Playwright or browser automation substitute is allowed', 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'],
     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'],

package/src/core/tmux-ui.mjs

@@ -241,6 +241,28 @@ export function buildTmuxOpenArgs(plan = {}) {
   return ['attach-session', '-t', sanitizeTmuxSessionName(plan.session || plan.workspace || defaultTmuxSessionName(plan.root))];
 }
 
+export function shouldAutoAttachTmux(args = [], env = process.env, streams = {}) {
+  const stdin = streams.stdin || process.stdin;
+  const stdout = streams.stdout || process.stdout;
+  if (args.includes('--json') || args.includes('--status-only') || args.includes('--quiet') || args.includes('--no-attach')) return false;
+  if (String(env.SKS_TMUX_NO_AUTO_ATTACH || '') === '1') return false;
+  return Boolean(stdin?.isTTY && stdout?.isTTY);
+}
+
+function attachTmuxSession(plan = {}, args = [], opts = {}) {
+  const session = sanitizeTmuxSessionName(plan.session || plan.workspace || defaultTmuxSessionName(plan.root));
+  const tmuxBin = plan.tmux?.bin || 'tmux';
+  const attachArgs = isTmuxShellSession(opts.env || process.env) ? ['switch-client', '-t', session] : buildTmuxOpenArgs({ ...plan, session });
+  console.log(`Attaching: ${[path.basename(tmuxBin), ...attachArgs].join(' ')}`);
+  const attached = spawnSync(tmuxBin, attachArgs, { stdio: 'inherit' });
+  return {
+    ok: attached.status === 0,
+    status: attached.status,
+    signal: attached.signal || null,
+    command: [tmuxBin, ...attachArgs].join(' ')
+  };
+}
+
 export function runTmuxLaunchPlanSyntaxCheck(plan = {}) {
   const args = buildTmuxOpenArgs(plan);
   return {
@@ -292,7 +314,16 @@ export async function launchTmuxUi(args = [], opts = {}) {
     else console.log(`tmux: not created (${created.stderr || 'tmux failed'})`);
     if (created.ok) console.log(`Attach: ${created.attach_command}`);
   }
-  return { plan, created: Boolean(created.ok), session: created.session || plan.session, opened: created };
+  let attached = null;
+  if (created.ok && shouldAutoAttachTmux(args)) {
+    attached = attachTmuxSession({ ...plan, session: created.session || plan.session }, args);
+    if (!attached.ok) {
+      const status = attached.signal || (attached.status ?? 'unknown');
+      console.error(`SKS tmux attach failed (${status}). Run manually: ${created.attach_command}`);
+      process.exitCode = attached.status || 1;
+    }
+  }
+  return { plan, created: Boolean(created.ok), session: created.session || plan.session, opened: created, attached };
 }
 
 function printTmuxLaunchBlocked(plan, opts = {}) {

package/src/core/triwiki-attention.mjs

@@ -1,4 +1,4 @@
-import { buildWikiCoordinateIndex, compactWikiCoordinateIndex, normalizeWikiCoord, wikiCoordSimilarity } from './wiki-coordinate.mjs';
+import { WIKI_VOXEL_LAYERS, buildWikiCoordinateIndex, compactWikiCoordinateIndex, normalizeWikiCoord, wikiCoordSimilarity } from './wiki-coordinate.mjs';
 
 const TAU = 2 * Math.PI;
 
@@ -183,6 +183,51 @@ function hydrateReason(claim = {}) {
   return '';
 }
 
+function voxelHydrateCandidates(wiki = {}, anchors = new Map(), max = 4) {
+  const overlay = wiki.vx || wiki.voxel_overlay;
+  const rows = Array.isArray(overlay?.v) ? overlay.v : [];
+  const layers = Array.isArray(overlay?.l) ? overlay.l : WIKI_VOXEL_LAYERS;
+  const idx = Object.fromEntries(layers.map((layer, index) => [layer, index]));
+  return rows
+    .map((row) => {
+      const id = row?.[1];
+      const values = Array.isArray(row?.[2]) ? row[2] : [];
+      const anchor = anchors.get(id);
+      if (!id || !anchor) return null;
+      const prio = Number(values[idx.prio] || 0);
+      const conflict = Number(values[idx.conflict] || 0);
+      const route = Number(values[idx.route] || 0);
+      const trust = Number(values[idx.trust] || 0);
+      const fresh = Number(values[idx.fresh] || 0);
+      let reason = '';
+      if (conflict >= 0.35) reason = `voxel:conflict:${conflict.toFixed(2)}`;
+      else if (prio >= 0.92 && route >= 0.4) reason = `voxel:priority_route:${prio.toFixed(2)}`;
+      else if (prio >= 0.75 && fresh <= 0.25) reason = `voxel:stale_priority:${prio.toFixed(2)}`;
+      if (!reason) return null;
+      return {
+        id,
+        anchor,
+        reason,
+        score: conflict * 3 + prio * 2 + route + (1 - trust) * 0.8 + (1 - fresh) * 0.5
+      };
+    })
+    .filter(Boolean)
+    .sort((a, b) => (b.score - a.score) || String(a.id).localeCompare(String(b.id)))
+    .slice(0, max);
+}
+
+function uniqueAttentionRows(rows = [], max = 4) {
+  const out = [];
+  const seen = new Set();
+  for (const row of rows) {
+    if (!Array.isArray(row) || !row[0] || seen.has(row[0])) continue;
+    seen.add(row[0]);
+    out.push(row);
+    if (out.length >= max) break;
+  }
+  return out;
+}
+
 export function buildTriWikiAttention({ selected = [], wiki = {}, role = 'worker', maxUse = 4, maxHydrate = 4 } = {}) {
   const anchors = attentionAnchorMap(wiki);
   const ranked = [...(selected || [])]
@@ -199,11 +244,18 @@ export function buildTriWikiAttention({ selected = [], wiki = {}, role = 'worker
     .filter((claim) => trustAction(claim) === 'use')
     .slice(0, maxUse)
     .map((claim) => attentionRow(claim, anchors.get(claim.id)));
-  const hydrateFirst = ranked
+  const selectedHydrateRows = ranked
     .map((claim) => ({ claim, reason: hydrateReason(claim) }))
     .filter((item) => item.reason)
-    .slice(0, maxHydrate)
     .map((item) => attentionRow(item.claim, anchors.get(item.claim.id), item.reason));
+  const negativeHydrateRows = selectedHydrateRows.filter((row) => String(row[1] || '').includes('negative_priming'));
+  const voxelRows = voxelHydrateCandidates(wiki, anchors, maxHydrate)
+    .map((item) => attentionRow({ id: item.id }, item.anchor, item.reason));
+  const hydrateFirst = uniqueAttentionRows([
+    ...negativeHydrateRows,
+    ...voxelRows,
+    ...selectedHydrateRows
+  ], maxHydrate);
   return {
     mode: 'aggressive_triwiki_active_recall',
     use_first: useFirst,

package/src/core/version-manager.mjs

@@ -29,8 +29,9 @@ export async function versioningStatus(root) {
   const hookInstalled = hookText.includes(`BEGIN ${VERSION_HOOK_MARKER}`);
   const policy = await versionPolicy(root);
   const state = await readJson(path.join(git.common_dir, VERSION_STATE_FILE), {});
+  const runtimeDrift = await runtimeDriftStatus(root, version);
   return {
-    ok: !policy.enabled || hookInstalled || !version,
+    ok: (!policy.enabled || hookInstalled || !version) && runtimeDrift.ok,
     enabled: Boolean(policy.enabled && version),
     package_version: version,
     bump: policy.bump,
@@ -38,10 +39,41 @@ export async function versioningStatus(root) {
     hook_path: git.hook_path,
     state_path: path.join(git.common_dir, VERSION_STATE_FILE),
     last_version: state.last_version || null,
+    runtime_drift: runtimeDrift,
     reason: version ? null : 'package_json_version_missing'
   };
 }
 
+async function runtimeDriftStatus(root, packageVersion) {
+  if (!packageVersion || process.env.SKS_RUNTIME_DRIFT_CHECK === '0') {
+    return { ok: true, checked: false, reason: packageVersion ? 'disabled' : 'package_json_version_missing' };
+  }
+  const result = await runProcess('sks', ['--version'], {
+    cwd: root,
+    timeoutMs: 5000,
+    maxOutputBytes: 16 * 1024,
+    env: { SKS_RUNTIME_DRIFT_CHECK: '0' }
+  });
+  if (result.code !== 0) {
+    return { ok: true, checked: false, reason: 'sks_binary_unavailable', stderr: result.stderr?.trim() || null };
+  }
+  const match = String(result.stdout || '').match(/(\d+\.\d+\.\d+)/);
+  const runtimeVersion = match?.[1] || null;
+  const runtime = parseSemver(runtimeVersion);
+  const source = parseSemver(packageVersion);
+  if (!runtime || !source) {
+    return { ok: true, checked: true, reason: 'version_parse_unavailable', runtime_version: runtimeVersion, package_version: packageVersion };
+  }
+  const comparison = compareSemver(runtime, source);
+  return {
+    ok: comparison >= 0,
+    checked: true,
+    runtime_version: runtimeVersion,
+    package_version: packageVersion,
+    relation: comparison === 0 ? 'same' : (comparison > 0 ? 'runtime_newer' : 'runtime_older')
+  };
+}
+
 export async function runVersionPreCommit(root, opts = {}) {
   if (process.env.SKS_DISABLE_VERSIONING === '1') return { ok: true, skipped: true, reason: 'SKS_DISABLE_VERSIONING=1' };
   const policy = await versionPolicy(root);