sneakoscope 0.6.3 → 0.6.6

package/README.md

@@ -16,6 +16,16 @@ Sneakoscope Codex is an update-aware, zero-runtime-dependency Node.js harness fo
 
 ```bash
 npm i -g sneakoscope
+sks
+```
+
+`npm i -g sneakoscope` prints the next command without opening an interactive prompt, so CI and agent installs do not hang. Run `sks` in a real terminal to open the setup UI. The UI asks whether this project should use the global install or a project-only install, then offers to run setup, doctor, and selftest.
+
+Default non-interactive setup:
+
+```bash
+sks setup
+sks doctor --fix
 ```
 
 The npm package name is `sneakoscope`; the command is branded as SKS and exposed as lowercase `sks` for shell portability. The package also exposes a `sneakoscope` command alias, so `sks setup` and `sneakoscope setup` are equivalent.
@@ -25,22 +35,20 @@ Global installation is the default and recommended setup. During `sks setup` or
 
 ## One-Prompt LLM Install
 
-If you are using Codex App, ChatGPT, Claude Code, Cursor, or another coding agent, copy the whole block below into the agent from your target project directory. The agent should install SKS, initialize the project, verify the setup, and show the available commands in one pass.
+If you are using Codex App, ChatGPT, Claude Code, Cursor, or another coding agent, copy this short prompt from your target project directory. It intentionally avoids recovery branches and broad instructions so the agent does only the install and verification work.
 
 ````text
-Install Sneakoscope Codex in the current project end to end. Do not ask follow-up questions unless a command requires user approval.
-
-Repository:
-https://github.com/mandarange/Sneakoscope-Codex.git
+Install Sneakoscope Codex in this project.
 
-Requirements:
-- Node.js must be >=20.11.
-- Codex CLI is installed separately. If it is missing, report that `@openai/codex` must be installed or `SKS_CODEX_BIN` must be set.
-- Use the published npm package for normal installs.
-- Do not modify application source files unless needed for SKS setup.
+Rules:
+- Do not modify application source files.
+- Ask only when a command requires user approval.
+- If Node.js is below 20.11, stop and report it.
+- If Codex CLI is missing, report: install @openai/codex or set SKS_CODEX_BIN.
 
-Run:
+Run exactly:
 ```bash
+node -v
 npm i -g sneakoscope
 sks setup
 sks update-check
@@ -50,68 +58,16 @@ sks commands
 sks dollar-commands
 ```
 
-If npm reports `ENOTEMPTY`, `EEXIST`, or a broken old global package:
-```bash
-npm uninstall -g sneakoscope
-npm i -g sneakoscope
-sks setup
-sks doctor --fix
-```
-
-If `sks` is not on PATH:
-```bash
-npx -y -p sneakoscope sks setup
-npx -y -p sneakoscope sks doctor --fix
-npx -y -p sneakoscope sks selftest --mock
-npx -y -p sneakoscope sks commands
-npx -y -p sneakoscope sks dollar-commands
-```
+If `sks` is unavailable after install, replace `sks` with `npx -y -p sneakoscope sks` and continue.
 
-For project-only install:
-```bash
-npm i -D sneakoscope
-npx sks setup --install-scope project
-npx sks update-check
-npx sks doctor --fix --install-scope project
-npx sks selftest --mock
-npx sks commands
-npx sks dollar-commands
-```
-
-Finish by reporting pass/fail and explaining only these generated outputs:
-- `.sneakoscope/` mission state and policy
-- `.codex/config.toml` Codex App profiles
-- `.codex/hooks.json` SKS hook integration
-- `.codex/skills/` local Codex App skills
-- `.codex/agents/` local Codex App multi-agent roles
-- `.codex/SNEAKOSCOPE.md` Codex App quick reference
-- `AGENTS.md` repository rules
-
-Show command discovery:
-```bash
-sks help
-sks update-check
-sks commands
-sks usage team
-sks usage ralph
-sks quickstart
-sks codex-app
-sks dollar-commands
-```
-
-Tell the user they can use these prompt commands inside Codex App:
-```text
-$DF 글자 색 바꿔줘
-$DF 내용을 영어로 바꿔줘
-$SKS show me available workflows
-$Team agree on the best plan and implement with specialists
-$Ralph implement this with mandatory clarification
-$Research investigate this idea
-$AutoResearch improve this workflow with experiments
-$DB check this migration safely
-```
+Finish with only:
+- setup passed/failed
+- Codex CLI present/missing
+- generated files: `.sneakoscope/`, `.codex/config.toml`, `.codex/hooks.json`, `.codex/skills/`, `.codex/agents/`, `.codex/SNEAKOSCOPE.md`, `AGENTS.md`
 ````
 
+Run `sks install-prompt --project` for a project-only prompt, or `sks install-prompt --full` for the longer recovery-oriented installer prompt.
+
 ## Repository
 
 ```bash
@@ -409,10 +365,11 @@ All terminal examples below use `sks`, but the same commands can be run with the
 ```bash
 sks help [topic]
 sks update-check [--json]
+sks wizard
 sks commands [--json]
-sks usage [install|setup|team|ralph|research|db|codex-app|df|dollar|eval|gx]
+sks usage [install|setup|team|ralph|research|db|codex-app|df|dollar|eval|gx|wiki]
 sks quickstart
-sks install-prompt [--project]
+sks install-prompt [--project] [--full]
 sks codex-app
 sks dollar-commands [--json]
 sks df
@@ -449,6 +406,10 @@ sks eval run [--json] [--out report.json] [--iterations N]
 sks eval compare --baseline old.json --candidate new.json [--json]
 sks eval thresholds
 
+sks wiki coords --rgba 12,34,56,255
+sks wiki pack [--json] [--role worker|verifier] [--max-anchors N]
+sks wiki validate [context-pack.json]
+
 sks hproof check [mission-id|latest]
 sks team "task" [--json]
 sks gx init [name]
@@ -622,7 +583,7 @@ sks hproof check latest
 `sks init` creates the local control surface:
 
 ```text
-.sneakoscope/              mission state, policy, retention, logs, GX cartridges
+.sneakoscope/              mission state, policy, retention, logs, wiki packs, GX cartridges
 .codex/config.toml    Codex profiles used by Sneakoscope Codex
 .codex/hooks.json     hook entrypoints
 .codex/skills/        Codex App local project skills
@@ -684,7 +645,28 @@ vgraph.json
 
 ## TriWiki Context Compression
 
-TriWiki is a harness-level context selection strategy, not a model-internal modification. It scores claims and memory entries by geometric distance, authority, freshness, risk, and token cost, then builds small context capsules for the current mission.
+TriWiki is a harness-level context selection strategy, not a model-internal modification. It scores claims and memory entries by geometric distance, authority, freshness, risk, and token cost, then builds context capsules for the current mission.
+
+The default model is anchor-first rather than lossy-summary-first. Selected claims are included as text, while non-selected claims are preserved as LLM Wiki anchors with id, source path, hash, RGBA key, and a compact coordinate tuple. Later turns can hydrate the missing context from the project wiki instead of depending on a one-way summary.
+
+RGBA wiki coordinates use four channels:
+
+```text
+R -> domain angle
+G -> layer radius through sin()
+B -> phase angle
+A -> concentration/confidence
+```
+
+The derived coordinate is `[domain, layer, phase, concentration]`, with an internal `xyzw` vector computed through sine/cosine. GX renders expose the same anchors through SVG data attributes and an RGBA coordinate strip, so visual context and text claims share one retrieval space.
+
+Useful commands:
+
+```bash
+sks wiki coords --rgba 12,34,56,255
+sks wiki pack
+sks wiki validate
+```
 
 Default context layers:
 

package/docs/PERFORMANCE.md

@@ -6,8 +6,8 @@ Sneakoscope Codex v0.6 is designed to keep runtime, package size, RAM, and stora
 
 - `codex exec` output is streamed to files and only a bounded tail is retained in memory.
 - Ralph cycles run under a timeout and bounded max cycles.
-- TriWiki claim selection uses bounded top-K selection instead of sorting unbounded context into prompts.
-- GX visual context renders deterministic SVG/HTML from JSON sources, avoiding external image-generation latency, cost, and nondeterminism.
+- TriWiki claim selection uses bounded top-K selection plus RGBA/trig wiki anchors instead of sorting unbounded context into prompts.
+- GX visual context renders deterministic SVG/HTML from JSON sources, avoiding external image-generation latency, cost, and nondeterminism. Rendered nodes expose the same RGBA wiki-coordinate anchors used by TriWiki.
 - `sks gc` runs after Ralph cycles by default.
 
 ## Evaluation metrics
@@ -30,6 +30,19 @@ Default meaningful-improvement thresholds are intentionally explicit: at least 2
 
 The accuracy metric is not a live model task score. It is a deterministic proxy for whether the context handed to a model is smaller, better supported, and less contaminated by unsupported critical claims.
 
+## LLM Wiki coordinate continuity
+
+TriWiki does not treat compression as permanent deletion. The visible context pack includes selected claim text plus a compact LLM Wiki coordinate index:
+
+```text
+R channel -> domain angle
+G channel -> layer radius via sin()
+B channel -> phase angle
+A channel -> concentration/confidence
+```
+
+Each anchor stores id, RGBA key, `[domain, layer, phase, concentration]`, source path, status/risk, and a text hash. This keeps non-selected claims hydratable across turns while keeping raw Q0 logs and large Q1 evidence out of the prompt until verification needs them.
+
 ## Package size
 
 - The npm package has zero runtime dependencies.
@@ -66,3 +79,5 @@ Blocked classes include destructive SQL, direct remote SQL mutation, `supabase d
 Sneakoscope Codex v0.4 replaces model-rendered visual cartridges with deterministic code-rendered context sheets. `vgraph.json` and `beta.json` are the inputs, `render.svg` and `render.html` are reproducible outputs, and `drift.json` records whether the rendered source hash still matches the current graph.
 
 This keeps visual context cheap to regenerate, diffable in normal tooling, and safe to validate during npm packaging without network calls or model access.
+
+GX snapshots include `wiki_coordinates`, and `render.svg` nodes include `data-wiki-rgba` and `data-wiki-coord` attributes. This makes the visual context sheet and LLM Wiki pack share one deterministic coordinate system.

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "sneakoscope",
   "displayName": "Sneakoscope Codex",
-  "version": "0.6.3",
+  "version": "0.6.6",
   "description": "Sneakoscope Codex: update-aware, database-safe Codex CLI harness with multi-agent Team orchestration, Ralph no-question execution, autoresearch-style loops, and H-Proof gates.",
   "type": "module",
   "homepage": "https://github.com/mandarange/Sneakoscope-Codex#readme",
@@ -32,6 +32,7 @@
   },
   "scripts": {
     "repo-audit": "node ./scripts/repo-audit.mjs",
+    "postinstall": "node ./bin/sks.mjs postinstall",
     "selftest": "node ./bin/sks.mjs selftest --mock",
     "doctor": "node ./bin/sks.mjs doctor",
     "packcheck": "find bin src scripts -name '*.mjs' -print0 | xargs -0 -n1 node --check",
@@ -63,6 +64,8 @@
     "hypothesis",
     "discovery",
     "llm-wiki",
+    "wiki-coordinate",
+    "context-compression",
     "gx",
     "svg",
     "deterministic",

package/src/cli/main.mjs

@@ -1,5 +1,7 @@
 import path from 'node:path';
 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 } from '../core/fsx.mjs';
 import { initProject, normalizeInstallScope, sksCommandPrefix } from '../core/init.mjs';
 import { getCodexInfo, runCodexExec } from '../core/codex-adapter.mjs';
@@ -13,13 +15,15 @@ import { storageReport, enforceRetention } from '../core/retention.mjs';
 import { classifySql, classifyCommand, loadDbSafetyPolicy, safeSupabaseMcpConfig, checkSqlFile, checkDbOperation, scanDbSafety } from '../core/db-safety.mjs';
 import { rustInfo } from '../core/rust-accelerator.mjs';
 import { renderCartridge, validateCartridge, driftCartridge, snapshotCartridge } from '../core/gx-renderer.mjs';
-import { DEFAULT_EVAL_THRESHOLDS, compareEvaluationReports, runEvaluationBenchmark } from '../core/evaluation.mjs';
+import { DEFAULT_EVAL_THRESHOLDS, compareEvaluationReports, defaultEvaluationScenario, runEvaluationBenchmark } from '../core/evaluation.mjs';
 import { buildResearchPrompt, evaluateResearchGate, writeMockResearchResult, writeResearchPlan } from '../core/research.mjs';
+import { contextCapsule } from '../core/triwiki-attention.mjs';
+import { rgbaKey, rgbaToWikiCoord, validateWikiCoordinateIndex } from '../core/wiki-coordinate.mjs';
 
 const flag = (args, name) => args.includes(name);
 const promptOf = (args) => args.filter((x) => !String(x).startsWith('--')).join(' ').trim();
 const REPOSITORY_URL = 'https://github.com/mandarange/Sneakoscope-Codex.git';
-const USAGE_TOPICS = 'install|setup|team|ralph|research|db|codex-app|df|dollar|eval|gx';
+const USAGE_TOPICS = 'install|setup|team|ralph|research|db|codex-app|df|dollar|eval|gx|wiki';
 
 const DOLLAR_COMMANDS = [
   { command: '$DF', route: 'fast design/content fix', description: 'Small UI/content edits such as text color, copy, label, spacing, or translation. Avoids heavy loops.' },
@@ -37,10 +41,11 @@ const COMMAND_CATALOG = [
   { name: 'help', usage: 'sks help [topic]', description: 'Show CLI help or focused help for a topic.' },
   { name: 'version', usage: 'sks version | sks --version', description: 'Print the installed Sneakoscope Codex version.' },
   { name: 'update-check', usage: 'sks update-check [--json]', description: 'Check npm for the latest Sneakoscope Codex version.' },
+  { name: 'wizard', usage: 'sks wizard', description: 'Open an interactive setup UI for install scope, setup, doctor, and verification.' },
   { name: 'commands', usage: 'sks commands [--json]', description: 'List every user-facing command with a short description.' },
   { name: 'usage', usage: `sks usage [${USAGE_TOPICS}]`, description: 'Print copy-ready workflows for common tasks.' },
   { name: 'quickstart', usage: 'sks quickstart', description: 'Show the shortest safe setup and verification flow.' },
-  { name: 'install-prompt', usage: 'sks install-prompt [--project]', description: 'Print an LLM-ready prompt that installs and configures SKS automatically.' },
+  { name: 'install-prompt', usage: 'sks install-prompt [--project] [--full]', description: 'Print a short LLM-ready prompt that installs and configures SKS automatically.' },
   { name: 'codex-app', usage: 'sks codex-app', description: 'Show Codex App setup files and example prompts.' },
   { name: 'dollar-commands', usage: 'sks dollar-commands [--json]', description: 'List Codex App $ commands such as $DF.' },
   { name: 'df', usage: 'sks df', description: 'Explain $DF fast design/content fix mode.' },
@@ -54,6 +59,7 @@ const COMMAND_CATALOG = [
   { name: 'research', usage: 'sks research prepare|run|status ...', description: 'Run frontier-style research missions with novelty and falsification gates.' },
   { name: 'db', usage: 'sks db policy|scan|mcp-config|classify|check ...', description: 'Inspect and enforce database/Supabase safety policy.' },
   { name: 'eval', usage: 'sks eval run|compare|thresholds ...', description: 'Run deterministic context-quality and performance evidence checks.' },
+  { name: 'wiki', usage: 'sks wiki coords|pack|validate ...', description: 'Build and validate RGBA/trig LLM Wiki coordinate context packs.' },
   { name: 'hproof', usage: 'sks hproof check [mission-id|latest]', description: 'Evaluate the H-Proof done gate for a mission.' },
   { name: 'team', usage: 'sks team "task" [--json]', description: 'Create a Codex multi-agent Team mission with consensus and implementation phases.' },
   { name: 'gx', usage: 'sks gx init|render|validate|drift|snapshot [name]', description: 'Create and verify deterministic SVG/HTML visual context cartridges.' },
@@ -73,8 +79,11 @@ function installScopeFromArgs(args = [], fallback = 'global') {
 export async function main(args) {
   const [cmd, sub, ...rest] = args;
   const tail = sub === undefined ? [] : [sub, ...rest];
-  if (!cmd || cmd === '--help' || cmd === '-h') return help();
+  if (!cmd) return shouldShowWizard() ? wizard([]) : help();
+  if (cmd === '--help' || cmd === '-h') return help();
   if (cmd === '--version' || cmd === '-v' || cmd === 'version') return version();
+  if (cmd === 'postinstall') return postinstall();
+  if (cmd === 'wizard' || cmd === 'ui') return wizard(tail);
   if (cmd === 'update-check') return updateCheck(tail);
   if (cmd === 'help') return help(tail);
   if (cmd === 'commands') return commands(tail);
@@ -100,6 +109,7 @@ export async function main(args) {
   if (cmd === 'team') return team(tail);
   if (cmd === 'db') return db(sub, rest);
   if (cmd === 'eval') return evalCommand(sub, rest);
+  if (cmd === 'wiki') return wiki(sub, rest);
   if (cmd === 'gc') return gc(tail);
   if (cmd === 'stats') return stats(tail);
   console.error(`Unknown command: ${cmd}`);
@@ -115,10 +125,11 @@ Usage:
   sks help [topic]
   sks version
   sks update-check [--json]
+  sks wizard
   sks commands [--json]
   sks usage [${USAGE_TOPICS}]
   sks quickstart
-  sks install-prompt [--project]
+  sks install-prompt [--project] [--full]
   sks codex-app
   sks dollar-commands [--json]
   sks df
@@ -143,6 +154,9 @@ Usage:
   sks db check --command "supabase db reset"
   sks eval run [--json] [--out report.json]
   sks eval compare --baseline old.json --candidate new.json [--json]
+  sks wiki coords --rgba 12,34,56,255
+  sks wiki pack [--json] [--role worker|verifier] [--max-anchors N]
+  sks wiki validate [context-pack.json]
   sks gx init [name]
   sks gx render [name] [--format svg|html|all]
   sks gx validate [name]
@@ -166,6 +180,75 @@ function version() {
   console.log(`sneakoscope ${PACKAGE_VERSION}`);
 }
 
+function shouldShowWizard() {
+  return Boolean(input.isTTY && output.isTTY && process.env.SKS_NO_WIZARD !== '1' && process.env.CI !== 'true');
+}
+
+function postinstall() {
+  console.log('\nSneakoscope Codex installed.');
+  console.log('Run `sks` to open the interactive setup UI, or run `sks setup` for the default global setup.');
+  console.log('Project-only setup: `sks wizard` -> choose project, or `npx sks setup --install-scope project`.\n');
+}
+
+async function wizard(args = []) {
+  if (!shouldShowWizard() && !flag(args, '--force')) return help();
+  const rl = readline.createInterface({ input, output });
+  try {
+    console.log('Sneakoscope Codex Setup UI\n');
+    console.log(`Current package: ${PACKAGE_VERSION}`);
+    const latest = await npmPackageVersion('sneakoscope');
+    if (latest.version) {
+      const needsUpdate = compareVersions(latest.version, PACKAGE_VERSION) > 0;
+      console.log(`Latest on npm:   ${latest.version}${needsUpdate ? ' (update available)' : ''}`);
+      if (needsUpdate) {
+        const update = await askChoice(rl, 'Update SKS before setup?', ['yes', 'no'], 'yes');
+        if (update === 'yes') {
+          console.log('\nRun this update command, then rerun `sks`:');
+          console.log('  npm i -g sneakoscope\n');
+          return;
+        }
+        console.log('Skipping update for this setup run.\n');
+      }
+    } else if (latest.error) {
+      console.log(`Latest on npm:   unknown (${latest.error})`);
+    }
+
+    const scope = await askChoice(rl, 'Install scope for this project?', ['global', 'project', 'commands', 'quit'], 'global');
+    if (scope === 'quit') return;
+    if (scope === 'commands') {
+      quickstart();
+      return;
+    }
+    if (scope === 'project') {
+      console.log('\nProject-only setup needs the package installed in this project:');
+      console.log('  npm i -D sneakoscope');
+      const proceed = await askChoice(rl, 'Continue with project setup after that dependency exists?', ['yes', 'no'], 'no');
+      if (proceed !== 'yes') return;
+    }
+
+    const runSetup = await askChoice(rl, `Run sks setup with ${scope} scope now?`, ['yes', 'no'], 'yes');
+    if (runSetup === 'yes') await setup(['--install-scope', scope]);
+    const runDoctor = await askChoice(rl, 'Run sks doctor --fix now?', ['yes', 'no'], 'yes');
+    if (runDoctor === 'yes') await doctor(['--fix', '--install-scope', scope]);
+    const runSelftest = await askChoice(rl, 'Run sks selftest --mock now?', ['yes', 'no'], 'yes');
+    if (runSelftest === 'yes') await selftest(['--mock']);
+    console.log('\nSetup UI complete. Useful next commands:');
+    console.log('  sks commands');
+    console.log('  sks dollar-commands');
+    console.log('  sks codex-app');
+  } finally {
+    rl.close();
+  }
+}
+
+async function askChoice(rl, question, choices, fallback) {
+  const suffix = choices.map((c) => c === fallback ? c.toUpperCase() : c).join('/');
+  const raw = (await rl.question(`${question} [${suffix}] `)).trim().toLowerCase();
+  const value = raw || fallback;
+  const hit = choices.find((c) => c.toLowerCase() === value || c[0].toLowerCase() === value);
+  return hit || fallback;
+}
+
 async function updateCheck(args = []) {
   const latest = await npmPackageVersion('sneakoscope');
   const result = {
@@ -226,6 +309,7 @@ function quickstart() {
 
 Install from npm:
   npm i -g sneakoscope
+  sks
 
 Initialize this project for CLI and Codex App:
   sks setup
@@ -249,9 +333,48 @@ GitHub install for unreleased commits:
 
 function installPrompt(args = []) {
   const projectOnly = flag(args, '--project');
+  const full = flag(args, '--full');
   const install = projectOnly
     ? `npm i -D sneakoscope\nnpx sks setup --install-scope project`
     : `npm i -g sneakoscope\nsks setup`;
+  if (full) return installPromptFull({ projectOnly, install });
+  const command = projectOnly ? 'npx sks' : 'sks';
+  const doctor = projectOnly ? 'npx sks doctor --fix --install-scope project' : 'sks doctor --fix';
+  const fallback = projectOnly
+    ? 'If `npx sks` is unavailable, run `npm i -D sneakoscope` again and stop with the error.'
+    : 'If `sks` is unavailable after install, replace `sks` with `npx -y -p sneakoscope sks` and continue.';
+
+  console.log(`Copy this prompt into an LLM coding assistant:
+
+Install Sneakoscope Codex in this project.
+
+Rules:
+- Do not modify application source files.
+- Ask only when a command requires user approval.
+- If Node.js is below 20.11, stop and report it.
+- If Codex CLI is missing, report: install @openai/codex or set SKS_CODEX_BIN.
+
+Run exactly:
+\`\`\`bash
+node -v
+${install}
+${command} update-check
+${doctor}
+${command} selftest --mock
+${command} commands
+${command} dollar-commands
+\`\`\`
+
+${fallback}
+
+Finish with only:
+- setup passed/failed
+- Codex CLI present/missing
+- generated files: \`.sneakoscope/\`, \`.codex/config.toml\`, \`.codex/hooks.json\`, \`.codex/skills/\`, \`.codex/agents/\`, \`.codex/SNEAKOSCOPE.md\`, \`AGENTS.md\`
+`);
+}
+
+function installPromptFull({ projectOnly, install }) {
   console.log(`Copy this prompt into an LLM coding assistant:
 
 Install Sneakoscope Codex in the current project end to end. Do not ask follow-up questions unless a command requires user approval.
@@ -404,6 +527,7 @@ function usage(args = []) {
 Discovery:
   sks help
   sks update-check
+  sks wizard
   sks commands
   sks quickstart
   sks install-prompt
@@ -416,6 +540,7 @@ Common workflows:
   sks usage ralph
   sks usage research
   sks usage db
+  sks usage wiki
   sks usage df
 `,
     install: `Install and Setup
@@ -561,8 +686,10 @@ CLI help:
 Use inside Codex App or an agent prompt:
   $DF        fast design/content fix
   $SKS       general Sneakoscope route
+  $Team      multi-agent team route
   $Ralph     Ralph mission route
   $Research  research mission route
+  $AutoResearch iterative experiment route
   $DB        database safety route
   $GX        visual context route
   $Help      command help route
@@ -582,6 +709,27 @@ Compare reports:
 
 Show thresholds:
   sks eval thresholds
+`,
+    wiki: `LLM Wiki Context Continuity
+
+Convert RGBA channels to deterministic wiki coordinates:
+  sks wiki coords --rgba 12,34,56,255
+
+Build a hydratable context pack:
+  sks wiki pack
+  sks wiki pack --json --role verifier --max-anchors 48
+
+Validate a saved pack:
+  sks wiki validate
+  sks wiki validate .sneakoscope/wiki/context-pack.json
+
+Model:
+  R -> domain angle
+  G -> layer radius through sin()
+  B -> phase angle
+  A -> concentration/confidence
+
+TriWiki keeps selected claims as text and preserves the rest as anchor ids, RGBA keys, coordinate tuples, source pointers, and hashes so later turns can hydrate the needed context instead of relying on lossy summaries.
 `,
     gx: `GX Visual Context
 
@@ -1122,6 +1270,20 @@ async function selftest() {
   if (nonDbDecision.action !== 'allow') throw new Error('selftest failed: non-DB command blocked by DB guard');
   const evalReport = runEvaluationBenchmark({ iterations: 5 });
   if (!evalReport.comparison.meaningful_improvement) throw new Error('selftest failed: evaluation benchmark did not show meaningful improvement');
+  if (!evalReport.candidate.wiki?.valid) throw new Error('selftest failed: wiki coordinate index invalid in eval');
+  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');
+  const wikiPack = contextCapsule({
+    mission: { id: 'selftest-wiki', coord: { rgba: { r: 48, g: 132, b: 212, a: 240 } } },
+    role: 'verifier',
+    claims: await projectWikiClaims(tmp),
+    q4: { mode: 'selftest' },
+    q3: ['sks', 'llm-wiki', 'wiki-coordinate'],
+    budget: { maxWikiAnchors: 48 }
+  });
+  const wikiValidation = validateWikiCoordinateIndex(wikiPack.wiki);
+  if (!wikiValidation.ok) throw new Error('selftest failed: wiki coordinate pack invalid');
+  if (!(wikiPack.wiki.anchors || wikiPack.wiki.a || []).some((anchor) => (Array.isArray(anchor) ? anchor[0] : anchor.id) === 'wiki-trig')) throw new Error('selftest failed: wiki trig anchor missing');
   const { dir: researchDir, mission: researchMission } = await createMission(tmp, { mode: 'research', prompt: '새로운 코드 리뷰 방법론 연구' });
   const researchPlan = await writeResearchPlan(researchDir, researchMission.prompt, {});
   const researchGate = await writeMockResearchResult(researchDir, researchPlan);
@@ -1136,10 +1298,12 @@ async function selftest() {
   if (!render.outputs.includes('render.svg')) throw new Error('selftest failed: gx svg not rendered');
   const validation = await validateCartridge(gxDir);
   if (!validation.ok) throw new Error('selftest failed: gx validation rejected');
+  if (!validateWikiCoordinateIndex(validation.wiki_coordinates).ok) throw new Error('selftest failed: gx wiki coordinate validation rejected');
   const drift = await driftCartridge(gxDir);
   if (drift.status !== 'low') throw new Error('selftest failed: gx drift is high');
   const snapshot = await snapshotCartridge(gxDir);
   if (!snapshot.files.svg || !snapshot.files.html) throw new Error('selftest failed: gx snapshot incomplete');
+  if (!validateWikiCoordinateIndex(snapshot.wiki_coordinates).ok) throw new Error('selftest failed: gx snapshot wiki coordinates invalid');
   const gc = await enforceRetention(tmp, { dryRun: true });
   if (!gc.report.exists) throw new Error('selftest failed: storage report');
   console.log('Sneakoscope Codex selftest passed.');
@@ -1191,6 +1355,91 @@ async function evalCommand(sub, args) {
   process.exitCode = 1;
 }
 
+async function wiki(sub, args = []) {
+  if (!sub || sub === 'help' || sub === '--help') {
+    console.log('Usage: sks wiki coords --rgba R,G,B,A | sks wiki pack [--json] [--role worker|verifier] [--max-anchors N] | sks wiki validate [context-pack.json] [--json]');
+    return;
+  }
+  if (sub === 'coords') {
+    const raw = readFlagValue(args, '--rgba', positionalArgs(args)[0] || '');
+    const parts = String(raw).split(/[,\s]+/).filter(Boolean).map((x) => Number.parseInt(x, 10));
+    if (parts.length < 3) throw new Error('Usage: sks wiki coords --rgba R,G,B,A');
+    const coord = rgbaToWikiCoord({ r: parts[0], g: parts[1], b: parts[2], a: parts[3] ?? 255 });
+    console.log(JSON.stringify({ rgba: coord.rgba, rgba_key: rgbaKey(coord.rgba), coord }, null, 2));
+    return;
+  }
+  if (sub === 'pack') {
+    const root = await projectRoot();
+    const role = readFlagValue(args, '--role', 'worker');
+    const maxAnchors = Number(readFlagValue(args, '--max-anchors', role.includes('verifier') ? 48 : 32));
+    const pack = contextCapsule({
+      mission: { id: 'project-wiki', coord: { rgba: { r: 48, g: 132, b: 212, a: 240 } } },
+      role,
+      contractHash: null,
+      claims: await projectWikiClaims(root),
+      q4: { mode: 'project-continuity', package: PACKAGE_VERSION, hydrate: 'anchor-first' },
+      q3: ['sks', 'llm-wiki', 'wiki-coordinate', 'gx', 'skills'],
+      budget: { maxWikiAnchors: maxAnchors }
+    });
+    const file = path.join(root, '.sneakoscope', 'wiki', 'context-pack.json');
+    await ensureDir(path.dirname(file));
+    await writeJsonAtomic(file, pack);
+    if (flag(args, '--json')) return console.log(JSON.stringify({ ...pack, path: file }, null, 2));
+    console.log('Sneakoscope LLM Wiki Context Pack');
+    console.log(`Path:     ${path.relative(root, file)}`);
+    console.log(`Claims:   ${pack.claims.length} hydrated text claims`);
+    console.log(`Anchors:  ${(pack.wiki.anchors || pack.wiki.a || []).length} coordinate anchors (${pack.wiki.overflow_count ?? pack.wiki.o ?? 0} overflow)`);
+    console.log(`Schema:   ${pack.wiki.schema}`);
+    console.log(`Validate: sks wiki validate ${path.relative(root, file)}`);
+    return;
+  }
+  if (sub === 'validate') {
+    const root = await projectRoot();
+    const target = positionalArgs(args)[0] || path.join(root, '.sneakoscope', 'wiki', 'context-pack.json');
+    const pack = await readJson(path.resolve(target));
+    const result = validateWikiCoordinateIndex(pack.wiki || pack);
+    if (flag(args, '--json')) return console.log(JSON.stringify(result, null, 2));
+    console.log(`Wiki coordinate index: ${result.ok ? 'ok' : 'failed'}`);
+    console.log(`Anchors checked: ${result.checked}`);
+    for (const issue of result.issues) console.log(`- ${issue.severity}: ${issue.id}${issue.anchor ? ` ${issue.anchor}` : ''}`);
+    process.exitCode = result.ok ? 0 : 2;
+    return;
+  }
+  console.error('Usage: sks wiki coords|pack|validate');
+  process.exitCode = 1;
+}
+
+async function projectWikiClaims(root) {
+  const claims = [
+    ['wiki-hooks', '.codex/hooks.json routes UserPromptSubmit, tool, permission, and Stop events through SKS guards.', '.codex/hooks.json', 'code', 'high'],
+    ['wiki-config', '.codex/config.toml enables Codex App profiles, multi-agent support, and Team agent limits.', '.codex/config.toml', 'code', 'high'],
+    ['wiki-skills', '.codex/skills and .agents/skills provide local routes for DF, Team, Ralph, Research, AutoResearch, DB, GX, wiki, and evaluation workflows.', '.codex/skills', 'code', 'medium'],
+    ['wiki-agents', '.codex/agents defines Team planning, implementation, DB safety, and QA reviewer roles.', '.codex/agents', 'code', 'medium'],
+    ['wiki-policy', '.sneakoscope/policy.json stores update-check, honest-mode, retention, database, performance, and prompt-pipeline policy.', '.sneakoscope/policy.json', 'contract', 'high'],
+    ['wiki-memory', '.sneakoscope/memory stores Q0 raw, Q1 evidence, Q2 facts, Q3 tags, and Q4 control bits for hydratable context.', '.sneakoscope/memory', 'wiki', 'high'],
+    ['wiki-gx', 'GX cartridges keep vgraph.json and beta.json as deterministic visual context sources with render, validation, drift, and snapshot outputs.', '.sneakoscope/gx/cartridges', 'vgraph', 'medium'],
+    ['wiki-db', 'Database safety blocks destructive SQL, risky Supabase commands, unsafe MCP writes, and production data mutation.', '.sneakoscope/db-safety.json', 'code', 'critical'],
+    ['wiki-hproof', 'H-Proof blocks completion when unsupported critical claims, DB safety issues, missing tests, or high visual/wiki drift remain.', '.sneakoscope/hproof', 'test', 'critical'],
+    ['wiki-eval', 'sks eval run measures token savings, evidence-weighted accuracy proxy, required recall, unsupported critical filtering, and build runtime.', 'src/core/evaluation.mjs', 'test', 'medium'],
+    ['wiki-trig', 'TriWiki maps RGBA channels to domain angle, layer radius, phase, and concentration using deterministic trigonometric coordinates.', 'src/core/wiki-coordinate.mjs', 'code', 'high']
+  ];
+  const out = [];
+  for (const [id, text, file, authority, risk] of claims) {
+    out.push({
+      id,
+      text,
+      authority,
+      risk,
+      status: await exists(path.join(root, file)) ? 'supported' : 'unknown',
+      freshness: 'fresh',
+      source: file,
+      file,
+      evidence_count: await exists(path.join(root, file)) ? 1 : 0
+    });
+  }
+  return out;
+}
+
 async function saveEvalReport(root, args, report, prefix) {
   if (flag(args, '--no-save')) return null;
   const requested = readFlagValue(args, '--out', null);
@@ -1214,6 +1463,7 @@ function printEvalRun(report, saved) {
   console.log(`Accuracy:  ${report.baseline.quality.accuracy_proxy} -> ${report.candidate.quality.accuracy_proxy} (${c.accuracy_delta >= 0 ? '+' : ''}${c.accuracy_delta})`);
   console.log(`Recall:    ${report.candidate.quality.required_recall}`);
   console.log(`Precision: ${report.baseline.quality.relevance_precision} -> ${report.candidate.quality.relevance_precision}`);
+  if (report.candidate.wiki) console.log(`Wiki:      ${report.candidate.wiki.anchors} anchors, valid=${report.candidate.wiki.valid}`);
   console.log(`Build ms:  ${report.baseline.context_build_ms_per_run} -> ${report.candidate.context_build_ms_per_run}`);
   console.log(`Meaningful improvement: ${c.meaningful_improvement ? 'yes' : 'no'}`);
   if (saved) console.log(`Report:    ${saved}`);

package/src/core/evaluation.mjs

@@ -1,5 +1,6 @@
 import { nowIso, sha256 } from './fsx.mjs';
 import { contextCapsule } from './triwiki-attention.mjs';
+import { validateWikiCoordinateIndex } from './wiki-coordinate.mjs';
 
 export const DEFAULT_EVAL_THRESHOLDS = Object.freeze({
   min_token_savings_pct: 0.25,
@@ -34,6 +35,7 @@ export function defaultEvaluationScenario() {
     ['req-db-block', 'destructive database operations such as DROP, TRUNCATE, db reset, and live execute_sql writes are blocked.', 'code', 'critical', 1.4],
     ['req-hook', '.codex/hooks.json routes PreToolUse, PostToolUse, PermissionRequest, UserPromptSubmit, and Stop to sks hook handlers.', 'code', 'high', 1],
     ['req-gx-hash', 'GX render output embeds the normalized vgraph.json source hash so drift can be detected deterministically.', 'test', 'medium', 0.9],
+    ['req-wiki-rgba', 'TriWiki stores RGBA-derived trigonometric wiki anchors so compressed context remains hydratable by id, hash, source, and coordinate.', 'code', 'high', 1.2],
     ['req-retention', 'runtime logs and mission artifacts are bounded through retention policy and sks gc.', 'code', 'medium', 0.85],
     ['req-selftest', 'selftest covers contract sealing, DB guard blocking, done-gate evaluation, GX render/validate/drift, snapshot, and retention report.', 'test', 'high', 1.1],
     ['req-skill', 'sks init installs local skills under .agents/skills so project workflows can trigger domain-specific guidance.', 'code', 'medium', 0.9],
@@ -43,6 +45,7 @@ export function defaultEvaluationScenario() {
     ['noise-rust-default', 'Rust acceleration is required at runtime for every npm installation.', 'unsupported', 'model', 'high'],
     ['noise-live-write', 'Live Supabase execute_sql writes are acceptable when the prompt sounds urgent.', 'unsupported', 'model', 'critical'],
     ['noise-image', 'GX visual context requires an external image generation service.', 'unsupported', 'model', 'medium'],
+    ['noise-wiki-lossy', 'TriWiki deletes non-selected claims permanently when it compresses context.', 'unsupported', 'wiki', 'high'],
     ['noise-unbounded', 'Raw child process output is kept entirely in memory for later summarization.', 'unsupported', 'model', 'high'],
     ['noise-hooks-only', 'Hooks are the only source of truth and mission files are optional.', 'unsupported', 'wiki', 'high'],
     ['noise-package', 'The npm package bundles @openai/codex and native Rust binaries.', 'unsupported', 'model', 'medium'],
@@ -134,11 +137,18 @@ function scoreSelection(allClaims, selectedIds) {
 
 function metricBlock({ label, context, scenario, msPerRun }) {
   const selectedIds = (context.claims || []).map((claim) => claim.id);
+  const wikiValidation = context.wiki ? validateWikiCoordinateIndex(context.wiki) : null;
   return {
     label,
     context_hash: sha256(JSON.stringify(context)),
     estimated_tokens: estimateTokens(context),
     context_build_ms_per_run: Number(msPerRun.toFixed(4)),
+    wiki: context.wiki ? {
+      schema: context.wiki.schema,
+      anchors: (context.wiki.anchors || context.wiki.a || []).length,
+      overflow_count: context.wiki.overflow_count ?? context.wiki.o ?? 0,
+      valid: wikiValidation.ok
+    } : null,
     quality: scoreSelection(scenario.claims, selectedIds)
   };
 }
@@ -158,6 +168,7 @@ export function compareMetricBlocks(baseline, candidate, thresholds = DEFAULT_EV
     unsupported_critical: candidate.quality.unsupported_critical_selected <= thresholds.max_unsupported_critical_selected,
     candidate_build_time: candidate.context_build_ms_per_run <= thresholds.max_candidate_build_ms_per_run
   };
+  if (candidate.wiki) checks.wiki_index = candidate.wiki.valid === true;
   return {
     token_savings_pct: Number(tokenSavingsPct.toFixed(4)),
     accuracy_delta: Number(accuracyDelta.toFixed(4)),

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

package/src/core/gx-renderer.mjs

@@ -1,5 +1,6 @@
 import path from 'node:path';
 import { exists, nowIso, readJson, readText, sha256, writeJsonAtomic, writeTextAtomic } from './fsx.mjs';
+import { buildWikiCoordinateIndex, normalizeWikiCoord, rgbaKey } from './wiki-coordinate.mjs';
 
 const SVG_WIDTH = 1280;
 const SVG_HEIGHT = 820;
@@ -89,6 +90,22 @@ export function vgraphHash(vgraph = {}) {
   return sha256(stableJson(normalizeVGraph(vgraph)));
 }
 
+function nodeWikiCoord(node) {
+  return normalizeWikiCoord(node?.coord || {}, `node:${node?.id || node?.label || 'node'}`);
+}
+
+function nodeClaims(graph) {
+  return graph.nodes.map((node) => ({
+    id: `node:${node.id}`,
+    text: node.label,
+    authority: 'vgraph',
+    source: 'vgraph.json',
+    status: node.status === 'blocked' ? 'unsupported' : 'supported',
+    risk: node.risk === 'critical' ? 'critical' : (node.risk === 'high' ? 'high' : 'medium'),
+    coord: nodeWikiCoord(node)
+  }));
+}
+
 function nodePalette(node) {
   if (node.risk === 'critical' || node.status === 'blocked') return { fill: '#fee2e2', stroke: '#b91c1c', text: '#3b0a0a' };
   if (node.risk === 'high' || node.status === 'warn') return { fill: '#ffedd5', stroke: '#c2410c', text: '#431407' };
@@ -166,13 +183,20 @@ export function renderVGraphSvg(vgraph = {}, beta = {}) {
     const palette = nodePalette(node);
     const labelLines = splitLabel(node.label);
     const tag = `${node.kind} / ${node.status}`;
-    return `<g class="node" transform="translate(${pos.x - pos.w / 2} ${pos.y - pos.h / 2})">
+    const wikiCoord = nodeWikiCoord(node);
+    return `<g class="node" data-wiki-rgba="${rgbaKey(wikiCoord.rgba)}" data-wiki-coord="${wikiCoord.domainAngle},${wikiCoord.layerRadius},${wikiCoord.phase},${wikiCoord.concentration}" transform="translate(${pos.x - pos.w / 2} ${pos.y - pos.h / 2})">
       <rect width="${pos.w}" height="${pos.h}" rx="14" fill="${palette.fill}" stroke="${palette.stroke}" stroke-width="3"/>
       <text x="18" y="27" class="node-title" fill="${palette.text}">${escapeXml(labelLines[0])}</text>
       ${labelLines.slice(1).map((line, i) => `<text x="18" y="${49 + i * 18}" class="node-title small" fill="${palette.text}">${escapeXml(line)}</text>`).join('\n')}
       <text x="18" y="${pos.h - 14}" class="node-meta" fill="${palette.text}">${escapeXml(shortText(tag, 34))}</text>
     </g>`;
   }).join('\n');
+  const wikiStrip = graph.nodes.slice(0, 24).map((node, index) => {
+    const coord = nodeWikiCoord(node);
+    const x = 1010 + (index % 12) * 18;
+    const y = 36 + Math.floor(index / 12) * 18;
+    return `<rect x="${x}" y="${y}" width="14" height="14" rx="2" fill="rgb(${coord.rgba.r},${coord.rgba.g},${coord.rgba.b})" fill-opacity="${(coord.rgba.a / 255).toFixed(3)}" data-node="${escapeXml(node.id)}" data-rgba="${rgbaKey(coord.rgba)}"/>`;
+  }).join('\n');
   const emptyState = graph.nodes.length ? '' : `<g class="empty">
     <rect x="332" y="214" width="616" height="178" rx="18"/>
     <text x="640" y="291" text-anchor="middle" class="empty-title">No graph nodes defined</text>
@@ -206,6 +230,7 @@ export function renderVGraphSvg(vgraph = {}, beta = {}) {
   <rect x="0" y="0" width="${SVG_WIDTH}" height="108" fill="#f8fafc"/>
   <text x="42" y="56" class="title">${escapeXml(graph.title)}</text>
   <text x="42" y="86" class="subtitle">vgraph:${escapeXml(graph.id)} hash:${hash.slice(0, 12)} nodes:${graph.nodes.length} edges:${graph.edges.length} generated:${generatedAt}</text>
+  <g aria-label="RGBA wiki coordinate atlas">${wikiStrip}</g>
   ${layerBands}
   ${edgeLines}
   ${nodeCards}
@@ -268,6 +293,13 @@ export function validateVGraph(vgraph = {}, beta = {}) {
     graph_id: graph.id,
     source_hash: vgraphHash(graph),
     counts: { nodes: graph.nodes.length, edges: graph.edges.length, invariants: graph.invariants.length, tests: graph.tests.length },
+    wiki_coordinates: buildWikiCoordinateIndex({
+      mission: { id: graph.id, coord: beta?.mission_coord || {} },
+      claims: nodeClaims(graph),
+      q4: { vgraph_hash: vgraphHash(graph) },
+      q3: ['gx', 'vgraph', 'wiki-coordinate'],
+      maxAnchors: Math.min(32, graph.nodes.length)
+    }),
     issues,
     warnings
   };
@@ -344,6 +376,13 @@ export async function snapshotCartridge(dir) {
     },
     validation,
     drift,
+    wiki_coordinates: buildWikiCoordinateIndex({
+      mission: { id: normalizeVGraph(vgraph).id, coord: beta?.mission_coord || {} },
+      claims: nodeClaims(normalizeVGraph(vgraph)),
+      q4: { vgraph_hash: vgraphHash(vgraph) },
+      q3: ['gx', 'vgraph', 'wiki-coordinate'],
+      maxAnchors: 32
+    }),
     vgraph: normalizeVGraph(vgraph),
     beta
   };

package/src/core/hooks-runtime.mjs

@@ -65,6 +65,7 @@ function promptPipelineContext(prompt) {
   const command = dollarCommand(prompt);
   const fastDesign = command === 'DF' || looksLikeFastDesignFix(prompt);
   const team = command === 'TEAM';
+  const wiki = command === 'GX' || /\b(llm wiki|wiki|context compression|context pack|hydrate|rgba|coordinate|좌표|컨텍스트|압축)\b/i.test(String(prompt || ''));
   const autoresearch = command === 'AUTORESEARCH' || command === 'RESEARCH' || /\b(autoresearch|experiment|benchmark|hypothesis|research|optimi[sz]e|improve metric|falsify|novelty|SEO|GEO)\b/i.test(String(prompt || ''));
   const route = command ? `$${command}` : (fastDesign ? '$DF inferred' : 'default');
   const dfLine = fastDesign
@@ -76,7 +77,10 @@ function promptPipelineContext(prompt) {
   const autoresearchLine = autoresearch
     ? '\nAutoResearch route: use an experiment loop with a clear program, fixed budget, metric, keep/discard decision, ledger, falsification, and next experiment.'
     : '';
-  return `SKS prompt pipeline active. Route: ${route}. Before work, respect the SKS update-check context if present. Optimize the user request before acting: extract intent, target files/surfaces, constraints, acceptance criteria, and the smallest safe execution path. Use explicit $ commands when present: $DF fast design/content edit, $Team multi-agent orchestration, $Ralph clarification-gated mission, $Research discovery run, $AutoResearch iterative experiment loop, $DB database safety, $GX visual context, $SKS general SKS help. Without a command, infer the lightest matching route and avoid heavy loops unless the task requires them. Do not stop at a plan when implementation was requested; continue until the stated goal is actually handled or a hard blocker is honestly reported. Before final answer, perform SKS Honest Mode: verify evidence, list tests run or gaps, call out uncertainty, and confirm the goal is actually complete.${dfLine}${teamLine}${autoresearchLine}`;
+  const wikiLine = wiki
+    ? '\nLLM Wiki route: preserve context through TriWiki RGBA/trig coordinate anchors. Prefer sks wiki pack for hydratable context; keep ids, hashes, source paths, and coordinates for non-selected claims instead of lossy summaries.'
+    : '';
+  return `SKS prompt pipeline active. Route: ${route}. Before work, respect the SKS update-check context if present. Optimize the user request before acting: extract intent, target files/surfaces, constraints, acceptance criteria, and the smallest safe execution path. Use explicit $ commands when present: $DF fast design/content edit, $Team multi-agent orchestration, $Ralph clarification-gated mission, $Research discovery run, $AutoResearch iterative experiment loop, $DB database safety, $GX visual context, $SKS general SKS help. Without a command, infer the lightest matching route and avoid heavy loops unless the task requires them. Preserve multi-turn context with LLM Wiki coordinate packs when compression or continuity matters. Do not stop at a plan when implementation was requested; continue until the stated goal is actually handled or a hard blocker is honestly reported. Before final answer, perform SKS Honest Mode: verify evidence, list tests run or gaps, call out uncertainty, and confirm the goal is actually complete.${dfLine}${teamLine}${autoresearchLine}${wikiLine}`;
 }
 
 export async function hookMain(name) {

package/src/core/init.mjs

@@ -64,6 +64,10 @@ When creating HTML, UI, prototype, deck-like, or visual artifacts, use the local
 
 Every user prompt enters the SKS prompt optimization pipeline even when the user does not type a command. Extract intent, target files or surfaces, constraints, acceptance criteria, risks, and the smallest safe execution path before acting. Choose the lightest matching route: fast edit, normal implementation, Ralph, Research, DB safety, GX, or evaluation. Do not run heavy Ralph/research/evaluation loops for simple direct edits.
 
+## LLM Wiki Continuity
+
+TriWiki context is anchor-first, not lossy-summary-first. Important claims, visual nodes, policy facts, and evidence pointers should receive deterministic RGBA wiki coordinates: R maps to domain angle, G maps to layer radius through sine, B maps to phase angle, and A maps to concentration/confidence. Use those trigonometric coordinates to preserve stable retrieval anchors across turns. Selected claims may be pasted as text, but non-selected claims must remain hydratable through id, hash, source path, and RGBA coordinate anchors instead of disappearing from the workflow.
+
 ## Dollar Commands
 
 Codex App users may invoke local SKS modes with skill-style dollar commands. \`$DF\` is the fast design/content fix route for small changes such as text color, copy edits, label changes, spacing tweaks, or translating visible text. \`$DF\` should avoid broad redesign, avoid unnecessary planning loops, and make the requested change directly with only cheap verification when useful.
@@ -79,7 +83,7 @@ When this repository is opened in Codex App, use the local Sneakoscope files as
 3. vgraph.json
 4. beta.json
 5. GX render/snapshot metadata
-6. LLM Wiki
+6. LLM Wiki coordinate index
 7. model knowledge only if explicitly allowed
 
 ## Database Safety
@@ -97,7 +101,7 @@ export async function initProject(root, opts = {}) {
   const hookCommandPrefix = opts.hookCommandPrefix || sksCommandPrefix(installScope, { globalCommand: opts.globalCommand });
   const sine = path.join(root, '.sneakoscope');
   const dirs = [
-    '.sneakoscope/state', '.sneakoscope/missions', '.sneakoscope/db', '.sneakoscope/bus', '.sneakoscope/hproof', '.sneakoscope/db', '.sneakoscope/memory/q0_raw', '.sneakoscope/memory/q1_evidence', '.sneakoscope/memory/q2_facts', '.sneakoscope/memory/q3_tags', '.sneakoscope/memory/q4_bits', '.sneakoscope/gx/cartridges', '.sneakoscope/model/fingerprints', '.sneakoscope/genome/candidates', '.sneakoscope/trajectories/raw', '.sneakoscope/locks', '.sneakoscope/tmp', '.sneakoscope/arenas', '.sneakoscope/reports', '.codex', '.codex/skills', '.codex/agents', '.agents/skills'
+    '.sneakoscope/state', '.sneakoscope/missions', '.sneakoscope/db', '.sneakoscope/bus', '.sneakoscope/hproof', '.sneakoscope/db', '.sneakoscope/wiki', '.sneakoscope/memory/q0_raw', '.sneakoscope/memory/q1_evidence', '.sneakoscope/memory/q2_facts', '.sneakoscope/memory/q3_tags', '.sneakoscope/memory/q4_bits', '.sneakoscope/gx/cartridges', '.sneakoscope/model/fingerprints', '.sneakoscope/genome/candidates', '.sneakoscope/trajectories/raw', '.sneakoscope/locks', '.sneakoscope/tmp', '.sneakoscope/arenas', '.sneakoscope/reports', '.codex', '.codex/skills', '.codex/agents', '.agents/skills'
   ];
   for (const d of dirs) await ensureDir(path.join(root, d));
 
@@ -129,6 +133,11 @@ export async function initProject(root, opts = {}) {
       dollar_commands: ['$DF', '$SKS', '$Team', '$Ralph', '$Research', '$AutoResearch', '$DB', '$GX', '$Help'],
       fast_design_command: '$DF'
     },
+    llm_wiki: {
+      coordinate_schema: 'sks.wiki-coordinate.v1',
+      channel_map: { r: 'domainAngle', g: 'layerRadius', b: 'phase', a: 'concentration' },
+      continuity_model: 'selected_text_plus_hydratable_rgba_trig_anchors'
+    },
     database_safety: 'destructive_db_operations_denied_always',
     gx_renderer: 'deterministic_svg_html'
   });
@@ -179,6 +188,12 @@ export async function initProject(root, opts = {}) {
           min_required_recall: 0.95
         }
       },
+      llm_wiki: {
+        coordinate_schema: 'sks.wiki-coordinate.v1',
+        default_pack: '.sneakoscope/wiki/context-pack.json',
+        compression_policy: 'preserve_ids_hashes_sources_rgba_coordinates_for_hydration',
+        channel_map: { r: 'domainAngle', g: 'layerRadius_sin', b: 'phase', a: 'concentration' }
+      },
       package: {
         zero_runtime_dependencies: true,
         rust_default_runtime: false,
@@ -270,6 +285,7 @@ This project has been initialized for both the SKS CLI and Codex App.
 - App skills: \`.codex/skills/\`
 - App agents: \`.codex/agents/\`
 - Mission state: \`.sneakoscope/missions/\`
+- LLM Wiki pack: \`.sneakoscope/wiki/context-pack.json\`
 - Current state: \`.sneakoscope/state/current.json\`
 
 ## Installed Command
@@ -290,6 +306,7 @@ ${commandPrefix} usage ralph
 ${commandPrefix} quickstart
 ${commandPrefix} install-prompt
 ${commandPrefix} codex-app
+${commandPrefix} wiki pack
 \`\`\`
 
 ## Dollar Commands
@@ -331,6 +348,8 @@ ${commandPrefix} ralph prepare "task"
 ${commandPrefix} ralph status latest
 ${commandPrefix} research prepare "topic"
 ${commandPrefix} team "task"
+${commandPrefix} wiki pack
+${commandPrefix} wiki validate
 ${commandPrefix} db scan --migrations
 \`\`\`
 
@@ -349,18 +368,18 @@ async function installSkills(root) {
     'DB': `---\nname: DB\ndescription: Dollar-command route for database and Supabase safety checks.\n---\n\nUse when the user invokes $DB or the task touches SQL, Supabase, Postgres, migrations, Prisma, Drizzle, Knex, MCP database tools, or production data. Run or follow sks db policy, sks db scan, sks db classify, and sks db check. Destructive database operations remain forbidden.\n`,
     'GX': `---\nname: GX\ndescription: Dollar-command route for deterministic GX visual context cartridges.\n---\n\nUse when the user invokes $GX or asks for architecture/context visualization through SKS. Prefer sks gx init, render, validate, drift, and snapshot. vgraph.json remains the source of truth.\n`,
     'Help': `---\nname: Help\ndescription: Dollar-command route for explaining installed SKS commands and workflows.\n---\n\nUse when the user invokes $Help or asks what commands exist. Prefer concise output from sks commands, sks usage <topic>, sks quickstart, sks aliases, and sks codex-app.\n`,
-    'prompt-pipeline': `---\nname: prompt-pipeline\ndescription: Default SKS prompt optimization pipeline that runs even without an explicit command.\n---\n\nFor every user request, silently extract intent, target surface, constraints, acceptance criteria, risk level, and the smallest safe route. Infer $DF for simple design/content edits. Use Ralph only for work that needs clarification gates, Research only for discovery work, DB only for database-risk work, GX only for visual context artifacts, and eval only when performance or context-quality claims need evidence.\n`,
+    'prompt-pipeline': `---\nname: prompt-pipeline\ndescription: Default SKS prompt optimization pipeline that runs even without an explicit command.\n---\n\nFor every user request, silently extract intent, target surface, constraints, acceptance criteria, risk level, and the smallest safe route. Infer $DF for simple design/content edits. Use Ralph only for work that needs clarification gates, Research only for discovery work, DB only for database-risk work, GX only for visual context artifacts, and eval only when performance or context-quality claims need evidence.\n\nContext continuity:\n- Prefer TriWiki coordinate context packs over ad hoc summaries when a task spans turns.\n- Use \`sks wiki pack\` when context continuity, compression quality, or LLM Wiki state matters.\n- Treat RGBA wiki anchors as hydratable pointers: selected text is only the visible slice; non-selected claims remain recoverable by id, hash, source path, and trigonometric coordinate.\n`,
     'honest-mode': `---\nname: honest-mode\ndescription: Required final SKS verification pass before claiming a task is complete.\n---\n\nUse before every final answer.\n\nChecklist:\n- Restate the actual user goal in one sentence.\n- Verify the implemented result against that goal.\n- List tests, commands, screenshots, or inspections that prove it.\n- State any missing verification, uncertainty, or hard blocker plainly.\n- Do not claim complete if the evidence does not support it.\n- If implementation was requested, do not stop at a plan.\n\nThe final response should include a concise SKS Honest Mode or 솔직모드 note when the hook requires it.\n`,
     'autoresearch-loop': `---\nname: autoresearch-loop\ndescription: Iterative AutoResearch-style loop for open-ended improvement, discovery, prompt, ranking, SEO/GEO, and workflow-quality tasks.\n---\n\nUse when the task asks for research, better ranking, SEO/GEO, prompt or workflow improvement, benchmark gains, non-obvious ideas, or repeated refinement.\n\nLoop:\n1. Program: define the objective, constraints, and budget.\n2. Hypothesis: propose one concrete change or experiment.\n3. Experiment: run the smallest local or documented check that can falsify it.\n4. Measure: record the metric, evidence, and artifact paths.\n5. Decision: keep, discard, or revise the hypothesis.\n6. Falsify: actively search for why the result could be wrong.\n7. Next: choose the next experiment or stop with an honest conclusion.\n\nRules:\n- Prefer small decisive experiments over broad speculation.\n- Keep a ledger in the mission/report when relevant.\n- Do not claim improvement without evidence.\n- End with Honest Mode: what improved, what did not, what remains unverified.\n`,
     'ralph-supervisor': `---\nname: ralph-supervisor\ndescription: Run the Ralph no-question loop after a decision contract is sealed.\n---\n\nYou are the Ralph Supervisor.\n\nRules:\n- Never ask the user during Ralph run.\n- Use decision-contract.json and the decision ladder.\n- Continue until done-gate.json passes or safe scope is completed with explicit limitation.\n- Keep outputs bounded. Write raw logs to files and summarize only tails.\n- Database destructive operations are never allowed.\n- Write progress to .sneakoscope mission files.\n`,
     'ralph-resolver': `---\nname: ralph-resolver\ndescription: Resolve newly discovered ambiguity during Ralph using the sealed decision ladder, without asking the user.\n---\n\nResolve ambiguity in this order: seed contract, explicit answers, approved defaults, AGENTS.md, current code/tests, smallest reversible change, defer optional scope. Never ask the user. If database risk is involved, prefer read-only, no-op, local-only migration file, or safe limitation; never run destructive SQL.\n`,
     'hproof-claim-ledger': `---\nname: hproof-claim-ledger\ndescription: Extract atomic claims and classify support status.\n---\n\nEvery factual statement must become an atomic claim. Unsupported critical claims cannot be used for implementation or final answer. Database claims require DB safety evidence.\n`,
-    'hproof-evidence-bind': `---\nname: hproof-evidence-bind\ndescription: Bind claims to code, tests, decision contract, vgraph, beta, wiki, or GX render evidence.\n---\n\nEvidence priority: current code/tests, decision-contract.json, vgraph.json, beta.json, GX snapshot/render metadata, wiki, user prompt. Database claims must respect .sneakoscope/db-safety.json.\n`,
+    'hproof-evidence-bind': `---\nname: hproof-evidence-bind\ndescription: Bind claims to code, tests, decision contract, vgraph, beta, wiki, or GX render evidence.\n---\n\nEvidence priority: current code/tests, decision-contract.json, vgraph.json, beta.json, GX snapshot/render metadata, LLM Wiki coordinate index, user prompt. Database claims must respect .sneakoscope/db-safety.json. Wiki claims should carry id, hash, source path, and RGBA/trig coordinate anchors so they can be hydrated instead of treated as unsupported summaries.\n`,
     'db-safety-guard': `---\nname: db-safety-guard\ndescription: Enforce Sneakoscope Codex database safety before using SQL, Supabase MCP, Postgres, Prisma, Drizzle, Knex, or migration commands.\n---\n\nRules:\n- Never run DROP, TRUNCATE, mass DELETE/UPDATE, db reset, db push, project deletion, branch reset/merge/delete, or RLS-disabling operations.\n- Supabase MCP must be read-only and project-scoped by default.\n- Live writes through execute_sql are blocked; use migration files and only local/preview branches if explicitly allowed.\n- Production writes are forbidden.\n- If unsure, read-only only.\n`,
-    'gx-visual-generate': `---\nname: gx-visual-generate\ndescription: Render a deterministic SVG/HTML visual sheet from vgraph.json and beta.json.\n---\n\nUse sks gx render. Do not use external image generation. vgraph.json is the source of truth and the SVG embeds its source hash.\n`,
-    'gx-visual-read': `---\nname: gx-visual-read\ndescription: Read a Sneakoscope Codex deterministic visual sheet and produce context notes.\n---\n\nExtract nodes, edges, invariants, tests, risks, and uncertainties from vgraph.json, beta.json, render.svg, or snapshot.json. Do not infer hidden nodes.\n`,
-    'gx-visual-validate': `---\nname: gx-visual-validate\ndescription: Validate render metadata against vgraph.json and beta.json.\n---\n\nRun sks gx validate and sks gx drift. If critical nodes, edges, or invariants are missing or the render hash is stale, mark validation failed.\n`,
-    'turbo-context-pack': `---\nname: turbo-context-pack\ndescription: Build ultra-low-token context packet with Q4 bits, Q3 tags, top-K claims, and minimal evidence.\n---\n\nDefault to Q4/Q3 only. Add Q2 or Q1 only when needed for support or verification.\n`,
+    'gx-visual-generate': `---\nname: gx-visual-generate\ndescription: Render a deterministic SVG/HTML visual sheet from vgraph.json and beta.json.\n---\n\nUse sks gx render. Do not use external image generation. vgraph.json is the source of truth and the SVG embeds its source hash. GX renders also expose RGBA wiki-coordinate pixels/data attributes for nodes so visual context and LLM Wiki anchors share one coordinate system.\n`,
+    'gx-visual-read': `---\nname: gx-visual-read\ndescription: Read a Sneakoscope Codex deterministic visual sheet and produce context notes.\n---\n\nExtract nodes, edges, invariants, tests, risks, uncertainties, and RGBA wiki-coordinate anchors from vgraph.json, beta.json, render.svg, or snapshot.json. Do not infer hidden nodes.\n`,
+    'gx-visual-validate': `---\nname: gx-visual-validate\ndescription: Validate render metadata against vgraph.json and beta.json.\n---\n\nRun sks gx validate and sks gx drift. If critical nodes, edges, invariants, source hash, or wiki-coordinate anchors are missing or stale, mark validation failed.\n`,
+    'turbo-context-pack': `---\nname: turbo-context-pack\ndescription: Build ultra-low-token context packet with Q4 bits, Q3 tags, top-K claims, and minimal evidence.\n---\n\nDefault to Q4/Q3 plus TriWiki RGBA coordinate anchors. Add Q2 or Q1 text only when needed for support or verification. Non-selected claims should not disappear: keep id, hash, source path, RGBA key, and [domain, layer, phase, concentration] tuple so the harness can hydrate them later.\n`,
     'research-discovery': `---\nname: research-discovery\ndescription: Run SKS Research Mode for frontier-style research, new hypothesis generation, novelty ledgers, falsification, and testable experiments.\n---\n\nUse when the user asks for research, new discoveries, frontier exploration, deep investigation, hypothesis generation, or non-obvious insights.\n\nMethod:\n1. Frame what would count as a discovery and what evidence would be required.\n2. Map nearby concepts, assumptions, baselines, and constraints.\n3. Generate competing hypotheses across mechanisms, analogies, edge cases, and failure modes.\n4. Falsify aggressively: counterexamples, missing evidence, alternate explanations, and safety boundaries.\n5. Synthesize only the surviving pieces into candidate insights.\n6. For every candidate insight, write novelty, confidence, falsifiability, evidence, falsifiers, and next_experiment to novelty-ledger.json.\n7. Produce research-report.md with concise findings and uncertainty.\n8. Pass research-gate.json only when at least one candidate insight survived falsification and has a testable prediction or experiment.\n\nQuality bar:\n- Do not summarize only; produce mechanisms, predictions, experiments, or implementation probes.\n- Do not claim breakthrough novelty without ledger evidence and uncertainty.\n- Prefer small decisive tests over broad speculation.\n- Keep raw notes bounded and cite artifact paths in final output.\n`,
     'performance-evaluator': `---\nname: performance-evaluator\ndescription: Evaluate whether SKS changes create meaningful performance, token-saving, accuracy-proxy, context-compression, or workflow improvements.\n---\n\nUse when a task claims faster execution, smaller prompts, better context quality, higher accuracy, or lower token cost.\n\nWorkflow:\n- Run sks eval run for the deterministic built-in benchmark.\n- Use sks eval compare --baseline old.json --candidate new.json for before/after report comparisons.\n- Report token_savings_pct, accuracy_delta, required_recall, unsupported_critical_selected, and meaningful_improvement.\n- Treat accuracy_proxy as evidence-weighted context quality, not live model task accuracy, unless an explicitly scored dataset was used.\n- For performance-sensitive work, set done-gate.json performance_evaluation_required/present fields and include the eval report path as evidence.\n`,
     'design-artifact-expert': `---\nname: design-artifact-expert\ndescription: Create or revise high-fidelity HTML, UI, prototype, deck-like, or visual design artifacts using project design context, variations, and rendered verification.\n---\n\nUse when the user asks for design, UI, prototype, HTML artifact, landing page, deck-like visual work, interaction design, or visual refinement.\n\nWorkflow:\n1. Understand the artifact, audience, constraints, fidelity, variants, and existing brand/design system.\n2. Inspect local code, assets, screenshots, or design-system docs before inventing visuals. If context exists, follow its visual vocabulary.\n3. Build the actual usable screen or artifact first; avoid empty landing-page framing unless the task is explicitly marketing.\n4. Use descriptive HTML filenames. Keep large artifacts split into small support files when needed.\n5. For screens/slides, add data-screen-label attributes for comment context. Slide labels are 1-indexed.\n6. Preserve state for decks, videos, or multi-step prototypes with localStorage when refresh continuity matters.\n7. Expose a small Tweaks surface for useful variants such as layout, density, color, copy, or interaction options.\n8. Verify the artifact renders cleanly in a browser or preview. For design tasks, set done-gate.json design_verification_required/present fields and cite evidence.\n\nQuality bar:\n- Root design decisions in available assets and components.\n- Use restrained, domain-appropriate layout and typography.\n- Avoid text overlap, unreadable controls, decorative clutter, one-note palettes, and placeholder-only deliverables.\n- Prefer icons and familiar controls for tool actions, and make repeated UI dimensions stable.\n`

package/src/core/triwiki-attention.mjs

@@ -1,16 +1,21 @@
+import { buildWikiCoordinateIndex, compactWikiCoordinateIndex, normalizeWikiCoord, wikiCoordSimilarity } from './wiki-coordinate.mjs';
+
 const TAU = 2 * Math.PI;
 
 export function clamp01(x) { return Math.max(0, Math.min(1, Number.isFinite(x) ? x : 0)); }
 export function wave(theta, phi) { return 0.5 + 0.5 * Math.cos(theta - phi); }
 
 export function trigScore(missionCoord = {}, claimCoord = {}) {
-  const domainDelta = (missionCoord.domainAngle || 0) - (claimCoord.domainAngle || 0);
-  const layerDelta = (missionCoord.layerRadius || 0) - (claimCoord.layerRadius || 0);
-  const phaseDelta = (missionCoord.phase || 0) - (claimCoord.phase || 0);
+  const missionWikiCoord = normalizeWikiCoord(missionCoord, 'mission');
+  const claimWikiCoord = normalizeWikiCoord(claimCoord, 'claim');
+  const domainDelta = (missionWikiCoord.domainAngle || 0) - (claimWikiCoord.domainAngle || 0);
+  const layerDelta = (missionWikiCoord.layerRadius || 0) - (claimWikiCoord.layerRadius || 0);
+  const phaseDelta = (missionWikiCoord.phase || 0) - (claimWikiCoord.phase || 0);
   return (
-    0.45 * wave(domainDelta, 0) +
-    0.25 * wave(layerDelta * 0.7, 0) +
-    0.30 * wave(phaseDelta, 0)
+    0.32 * wave(domainDelta, 0) +
+    0.18 * wave(layerDelta * 0.7, 0) +
+    0.22 * wave(phaseDelta, 0) +
+    0.28 * wikiCoordSimilarity(missionWikiCoord, claimWikiCoord)
   );
 }
 
@@ -45,7 +50,20 @@ function topKByScore(items, k) {
 export function selectClaims(mission, claims, budget = {}) {
   const maxClaims = Math.max(0, budget.maxClaims ?? 12);
   const scored = (claims || []).map((claim) => ({ claim, score: claimScore(mission, claim) }));
-  return topKByScore(scored, maxClaims).map((x) => ({ ...x.claim, triwiki_score: Number(x.score.toFixed(4)) }));
+  const selected = [];
+  const selectedIds = new Set();
+  const required = scored
+    .filter((x) => Number(x.claim.required_weight) > 0)
+    .sort((a, b) => b.score - a.score);
+  for (const item of required) {
+    if (selected.length >= maxClaims) break;
+    selected.push(item);
+    selectedIds.add(item.claim.id);
+  }
+  const fill = topKByScore(scored.filter((x) => !selectedIds.has(x.claim.id)), maxClaims - selected.length);
+  return [...selected, ...fill]
+    .sort((a, b) => b.score - a.score)
+    .map((x) => ({ ...x.claim, triwiki_score: Number(x.score.toFixed(4)) }));
 }
 
 export function geometricOffsets(max = 65536) {
@@ -54,15 +72,30 @@ export function geometricOffsets(max = 65536) {
   return out;
 }
 
-export function contextCapsule({ mission, role = 'worker', contractHash = null, claims = [], q4 = {}, q3 = [] }) {
-  const selected = selectClaims(mission, claims, { maxClaims: role.includes('verifier') ? 16 : 10 });
+export function contextCapsule({ mission, role = 'worker', contractHash = null, claims = [], q4 = {}, q3 = [], budget = {} }) {
+  const selected = selectClaims(mission, claims, { maxClaims: budget.maxClaims ?? (role.includes('verifier') ? 16 : 9) });
+  const fullWiki = buildWikiCoordinateIndex({
+    mission,
+    claims,
+    q4,
+    q3,
+    maxAnchors: budget.maxWikiAnchors ?? (role.includes('verifier') ? 16 : 7)
+  });
+  const wiki = budget.verboseWiki ? fullWiki : compactWikiCoordinateIndex(fullWiki);
+  const anchorRows = Array.isArray(wiki.a) ? wiki.a : [];
+  const anchorsById = new Map((wiki.anchors || []).map((anchor) => [anchor.id, anchor]));
+  for (const row of anchorRows) anchorsById.set(row[0], { id: row[0], rgba: row[1], c: row[2], h: row[7] });
   return {
     mission: mission.id,
     role,
     contract_hash: contractHash,
-    token_policy: 'Q4_Q3_DEFAULT_Q2_ON_DEMAND_Q1_FOR_VERIFICATION_ONLY',
+    token_policy: 'Q4_Q3_DEFAULT_WITH_RGBA_TRIG_WIKI_ANCHORS_Q2_Q1_HYDRATED_ON_DEMAND',
     q4,
     q3,
-    claims: selected.map((c) => ({ id: c.id, text: c.text, status: c.status, risk: c.risk, source: c.source, score: c.triwiki_score }))
+    wiki,
+    claims: selected.map((c) => {
+      const anchor = anchorsById.get(c.id);
+      return { id: c.id, text: c.text, status: c.status, risk: c.risk, source: c.source, score: c.triwiki_score, rgba: anchor?.rgba, h: anchor?.h };
+    })
   };
 }

package/src/core/wiki-coordinate.mjs

@@ -0,0 +1,228 @@
+import { sha256 } from './fsx.mjs';
+
+export const WIKI_COORD_SCHEMA = 'sks.wiki-coordinate.v1';
+export const WIKI_TAU = Math.PI * 2;
+
+export function clamp01(x) {
+  return Math.max(0, Math.min(1, Number.isFinite(x) ? x : 0));
+}
+
+function round6(x) {
+  return Number((Number.isFinite(x) ? x : 0).toFixed(6));
+}
+
+function byte(x) {
+  return Math.max(0, Math.min(255, Math.round(Number.isFinite(Number(x)) ? Number(x) : 0)));
+}
+
+function wrapTau(x) {
+  const value = Number.isFinite(Number(x)) ? Number(x) : 0;
+  return ((value % WIKI_TAU) + WIKI_TAU) % WIKI_TAU;
+}
+
+export function rgbaFromHash(seed = '') {
+  const hex = sha256(String(seed || 'wiki-anchor'));
+  return {
+    r: Number.parseInt(hex.slice(0, 2), 16),
+    g: Number.parseInt(hex.slice(2, 4), 16),
+    b: Number.parseInt(hex.slice(4, 6), 16),
+    a: 160 + (Number.parseInt(hex.slice(6, 8), 16) % 96)
+  };
+}
+
+export function rgbaKey(rgba = {}) {
+  const c = normalizeRgba(rgba);
+  return [c.r, c.g, c.b, c.a].map((x) => x.toString(16).padStart(2, '0')).join('');
+}
+
+export function normalizeRgba(rgba = {}) {
+  if (Array.isArray(rgba)) return { r: byte(rgba[0]), g: byte(rgba[1]), b: byte(rgba[2]), a: byte(rgba[3] ?? 255) };
+  if (typeof rgba === 'string') {
+    const clean = rgba.replace(/^#/, '').replace(/[^0-9a-f]/gi, '');
+    if (clean.length >= 6) {
+      return {
+        r: Number.parseInt(clean.slice(0, 2), 16),
+        g: Number.parseInt(clean.slice(2, 4), 16),
+        b: Number.parseInt(clean.slice(4, 6), 16),
+        a: clean.length >= 8 ? Number.parseInt(clean.slice(6, 8), 16) : 255
+      };
+    }
+  }
+  return { r: byte(rgba.r), g: byte(rgba.g), b: byte(rgba.b), a: byte(rgba.a ?? 255) };
+}
+
+export function rgbaToWikiCoord(rgba = {}) {
+  const c = normalizeRgba(rgba);
+  const alpha = c.a / 255;
+  const domainAngle = WIKI_TAU * ((c.r + 0.5) / 256);
+  const layerRadius = Math.sin(((c.g + 0.5) / 256) * (Math.PI / 2));
+  const phase = WIKI_TAU * ((c.b + 0.5) / 256);
+  const concentration = 0.05 + 0.95 * alpha;
+  return compactWikiCoord({ domainAngle, layerRadius, phase, concentration, rgba: c });
+}
+
+export function wikiCoordToRgba(coord = {}) {
+  const domainAngle = wrapTau(coord.domainAngle);
+  const phase = wrapTau(coord.phase);
+  const layerRadius = clamp01(coord.layerRadius);
+  const concentration = clamp01(coord.concentration ?? 1);
+  return {
+    r: byte((domainAngle / WIKI_TAU) * 256 - 0.5),
+    g: byte((Math.asin(layerRadius) / (Math.PI / 2)) * 256 - 0.5),
+    b: byte((phase / WIKI_TAU) * 256 - 0.5),
+    a: byte(((concentration - 0.05) / 0.95) * 255)
+  };
+}
+
+export function normalizeWikiCoord(coord = {}, seed = '') {
+  if (coord?.rgba) return rgbaToWikiCoord(coord.rgba);
+  if (coord && ['domainAngle', 'layerRadius', 'phase'].some((key) => Number.isFinite(Number(coord[key])))) {
+    return compactWikiCoord({
+      domainAngle: wrapTau(coord.domainAngle),
+      layerRadius: clamp01(Number(coord.layerRadius)),
+      phase: wrapTau(coord.phase),
+      concentration: clamp01(Number(coord.concentration ?? 0.85)),
+      rgba: coord.rgba || wikiCoordToRgba(coord)
+    });
+  }
+  return rgbaToWikiCoord(rgbaFromHash(seed));
+}
+
+export function compactWikiCoord(coord = {}) {
+  const domainAngle = wrapTau(coord.domainAngle);
+  const layerRadius = clamp01(Number(coord.layerRadius));
+  const phase = wrapTau(coord.phase);
+  const concentration = clamp01(Number(coord.concentration ?? 1));
+  const rgba = normalizeRgba(coord.rgba || wikiCoordToRgba({ domainAngle, layerRadius, phase, concentration }));
+  return {
+    schema: WIKI_COORD_SCHEMA,
+    rgba,
+    domainAngle: round6(domainAngle),
+    layerRadius: round6(layerRadius),
+    phase: round6(phase),
+    concentration: round6(concentration),
+    xyzw: [
+      round6(concentration * Math.cos(domainAngle)),
+      round6(concentration * Math.sin(domainAngle)),
+      round6(layerRadius * Math.cos(phase)),
+      round6(layerRadius * Math.sin(phase))
+    ]
+  };
+}
+
+export function wikiCoordSimilarity(a = {}, b = {}) {
+  const ca = normalizeWikiCoord(a, 'a');
+  const cb = normalizeWikiCoord(b, 'b');
+  const domain = 0.5 + 0.5 * Math.cos(ca.domainAngle - cb.domainAngle);
+  const phase = 0.5 + 0.5 * Math.cos(ca.phase - cb.phase);
+  const layer = 1 - Math.min(1, Math.abs(ca.layerRadius - cb.layerRadius));
+  const concentration = 1 - Math.min(1, Math.abs(ca.concentration - cb.concentration));
+  return clamp01((0.42 * domain) + (0.26 * layer) + (0.24 * phase) + (0.08 * concentration));
+}
+
+export function wikiAnchorFromClaim(claim = {}, index = 0) {
+  const id = String(claim.id || `claim-${index + 1}`);
+  const text = String(claim.text || claim.label || id);
+  const coord = normalizeWikiCoord(claim.coord || {}, `${id}:${text}`);
+  const source = claim.source || claim.authority || 'wiki';
+  return {
+    id,
+    rgba: rgbaKey(coord.rgba),
+    c: [coord.domainAngle, coord.layerRadius, coord.phase, coord.concentration],
+    k: claim.authority || source,
+    st: claim.status || 'unknown',
+    r: claim.risk || 'medium',
+    src: source,
+    h: sha256(`${id}\n${text}`).slice(0, 16),
+    tc: Math.max(1, Math.ceil(Number(claim.tokenCost) || text.length / 4)),
+    p: claim.hydrate || claim.path || claim.evidence_path || claim.file || null
+  };
+}
+
+export function buildWikiCoordinateIndex({ mission = {}, claims = [], q4 = {}, q3 = [], maxAnchors = 24 } = {}) {
+  const missionCoord = normalizeWikiCoord(mission.coord || {}, mission.id || JSON.stringify(q3 || []));
+  const anchors = (claims || [])
+    .map((claim, index) => {
+      const anchor = wikiAnchorFromClaim(claim, index);
+      const coord = { domainAngle: anchor.c[0], layerRadius: anchor.c[1], phase: anchor.c[2], concentration: anchor.c[3] };
+      return { ...anchor, sim: round6(wikiCoordSimilarity(missionCoord, coord)) };
+    })
+    .sort((a, b) => b.sim - a.sim || a.id.localeCompare(b.id))
+    .slice(0, Math.max(0, Number(maxAnchors) || 0));
+  return {
+    schema: WIKI_COORD_SCHEMA,
+    channel_map: {
+      r: 'domainAngle',
+      g: 'layerRadius',
+      b: 'phase',
+      a: 'concentration'
+    },
+    transform: 'domain=2pi*r/256; layer=sin(g*pi/512); phase=2pi*b/256; xyzw=[a*cos(domain),a*sin(domain),layer*cos(phase),layer*sin(phase)]',
+    mission: {
+      id: mission.id || 'mission',
+      rgba: rgbaKey(missionCoord.rgba),
+      c: [missionCoord.domainAngle, missionCoord.layerRadius, missionCoord.phase, missionCoord.concentration]
+    },
+    q4_hash: sha256(JSON.stringify(q4 || {})).slice(0, 16),
+    q3,
+    anchors,
+    overflow_count: Math.max(0, (claims || []).length - anchors.length),
+    hydration_policy: 'anchor_ids_hashes_and_paths_keep_context_hydratable_without_pasting_raw_q0'
+  };
+}
+
+export function compactWikiCoordinateIndex(index = {}) {
+  return {
+    schema: WIKI_COORD_SCHEMA,
+    ch: 'r=domain,g=sin-layer,b=phase,a=concentration',
+    m: [index.mission?.rgba || '000000ff', index.mission?.c || [0, 0, 0, 1]],
+    q: index.q4_hash || null,
+    q3: index.q3 || [],
+    a: (index.anchors || []).map((anchor) => [
+      anchor.id,
+      anchor.rgba,
+      anchor.c,
+      anchor.k,
+      anchor.st,
+      anchor.r,
+      anchor.src,
+      anchor.h,
+      anchor.p
+    ]),
+    o: index.overflow_count || 0,
+    hp: 'id+rgba+coord+source+hash hydrate Q2/Q1/Q0 on demand'
+  };
+}
+
+function expandedAnchors(index = {}) {
+  if (Array.isArray(index.anchors)) return index.anchors;
+  if (!Array.isArray(index.a)) return [];
+  return index.a.map((row) => ({
+    id: row[0],
+    rgba: row[1],
+    c: row[2],
+    k: row[3],
+    st: row[4],
+    r: row[5],
+    src: row[6],
+    h: row[7],
+    p: row[8]
+  }));
+}
+
+export function validateWikiCoordinateIndex(index = {}) {
+  const issues = [];
+  if (index.schema !== WIKI_COORD_SCHEMA) issues.push({ id: 'schema_mismatch', severity: 'error' });
+  if (!index.channel_map && !index.ch) issues.push({ id: 'channel_map_missing', severity: 'error' });
+  const anchors = expandedAnchors(index);
+  if (!anchors.length && !Array.isArray(index.anchors) && !Array.isArray(index.a)) issues.push({ id: 'anchors_missing', severity: 'error' });
+  const seen = new Set();
+  for (const anchor of anchors) {
+    if (!anchor.id) issues.push({ id: 'anchor_id_missing', severity: 'error' });
+    if (seen.has(anchor.id)) issues.push({ id: 'duplicate_anchor', severity: 'error', anchor: anchor.id });
+    seen.add(anchor.id);
+    if (!/^[0-9a-f]{8}$/i.test(String(anchor.rgba || ''))) issues.push({ id: 'invalid_rgba_key', severity: 'error', anchor: anchor.id });
+    if (!Array.isArray(anchor.c) || anchor.c.length !== 4) issues.push({ id: 'invalid_coord_tuple', severity: 'error', anchor: anchor.id });
+  }
+  return { ok: issues.length === 0, checked: anchors.length, issues };
+}