sneakoscope 0.9.12 → 0.9.13

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

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

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

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

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

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

package/src/core/proof/selftest-proof-fixtures.mjs

@@ -0,0 +1,54 @@
+import { writeRouteCompletionProof } from './route-adapter.mjs';
+
+const CLAIM_TEXT = {
+  hard_blocker: 'Hard blocker unblocks incomplete active gate after repeated identical compliance stops.',
+  team_gate: 'Team selftest fixture reached Completion Proof gate before reflection validation.',
+  subagent_gate: 'Subagent selftest fixture records Completion Proof after subagent evidence.'
+};
+
+const DEFAULTS = {
+  hard_blocker: {
+    artifacts: ['hard-blocker.json', 'compliance-loop-guard.json'],
+    gateSource: 'selftest-hard-blocker',
+    unverified: ['selftest fixture does not claim a real Team run completed']
+  },
+  team_gate: {
+    artifacts: ['team-gate.json', 'team-session-cleanup.json'],
+    gateSource: 'selftest-route-gate',
+    unverified: ['selftest fixture does not claim a real Team implementation run completed']
+  },
+  subagent_gate: {
+    artifacts: ['team-gate.json', 'team-session-cleanup.json', 'reflection-gate.json'],
+    gateSource: 'selftest-subagent-gate',
+    unverified: ['selftest fixture records mocked subagent evidence only']
+  }
+};
+
+export async function writeSelftestRouteProof(root, {
+  missionId,
+  route = '$Team',
+  kind = 'team_gate',
+  artifacts = null,
+  gateSource = null,
+  unverified = null
+} = {}) {
+  const defaults = DEFAULTS[kind] || DEFAULTS.team_gate;
+  return writeRouteCompletionProof(root, {
+    missionId,
+    route,
+    status: 'verified_partial',
+    gate: { passed: true, source: gateSource || defaults.gateSource },
+    summary: { selftest: true, tests_passed: 1, manual_review_required: true },
+    artifacts: artifacts || defaults.artifacts,
+    evidence: {
+      route_gate: { passed: true },
+      commands: [{ cmd: 'sks selftest --mock', status: 'verified_partial' }]
+    },
+    claims: [{
+      id: `selftest-${kind.replaceAll('_', '-')}-proof`,
+      text: CLAIM_TEXT[kind] || CLAIM_TEXT.team_gate,
+      status: 'verified_partial'
+    }],
+    unverified: unverified || defaults.unverified
+  });
+}

package/src/core/proof/validation.mjs

@@ -11,6 +11,7 @@ export function validateCompletionProof(proof = {}) {
   if (!Array.isArray(proof.unverified)) issues.push('unverified');
   if (!Array.isArray(proof.blockers)) issues.push('blockers');
   if (containsPlaintextSecret(proof)) issues.push('plaintext_secret');
+  if (proof.status === 'failed') issues.push('proof_failed');
   return {
     ok: issues.length === 0,
     status: issues.length ? 'failed' : proof.status,

package/src/core/rust-accelerator.mjs

@@ -16,18 +16,21 @@ export async function findRustAccelerator() {
 
 export async function runRustOrFallback(command, args = [], fallbackFn = async () => null) {
   const bin = await findRustAccelerator();
-  if (!bin) return { engine: 'js', available: false, result: await fallbackFn() };
+  if (!bin) return normalizeAcceleratorResult(command, { engine: 'js', available: false, result: await fallbackFn() });
   const result = await runProcess(bin, [command, ...args], { timeoutMs: 10000, maxOutputBytes: 1024 * 1024 }).catch((err) => ({ code: 1, stdout: '', stderr: err.message }));
-  if (result.code !== 0) return { engine: 'js', available: true, rust_error: result.stderr || result.stdout, result: await fallbackFn() };
-  return { engine: 'rust', available: true, stdout: result.stdout.trim(), result: parseRustJson(result.stdout) };
+  if (result.code !== 0) return normalizeAcceleratorResult(command, { engine: 'js', available: true, rust_error: classifyRustError(command, result.stderr || result.stdout), result: await fallbackFn() });
+  return normalizeAcceleratorResult(command, { engine: 'rust', available: true, stdout: result.stdout.trim(), result: parseRustJson(result.stdout) });
 }
 
 export async function rustImageHash(file) {
-  return runRustOrFallback('image-hash', [file], async () => ({ sha256: await sha256File(file) }));
+  return runRustOrFallback('image-hash', [file], async () => ({ ok: true, engine: 'js', path: file, sha256: await sha256File(file) }));
 }
 
 export async function rustVoxelValidate(file) {
-  return runRustOrFallback('voxel-validate', [file], async () => validateImageVoxelLedger(await readImageVoxelLedger(packageRoot(), file)));
+  return runRustOrFallback('voxel-validate', [file], async () => {
+    const validation = validateImageVoxelLedger(await readImageVoxelLedger(packageRoot(), file));
+    return { ok: validation.ok, engine: 'js', schema: 'sks.image-voxel-ledger.v1', images: validation.summary.images, anchors: validation.summary.anchors, issues: validation.issues };
+  });
 }
 
 export async function rustSecretScan(file) {
@@ -39,11 +42,30 @@ export async function rustSecretScan(file) {
 
 export async function rustInfo() {
   const bin = await findRustAccelerator();
-  if (!bin) return { available: false, packaging: 'source_checkout_or_optional_path', note: 'Rust accelerator available only from source checkout or SKS_RS_BIN until prebuilt packages exist.' };
+  const capabilities = ['compact-info', 'jsonl-tail', 'secret-scan', 'image-hash', 'voxel-validate'];
+  if (!bin) return { available: false, capabilities, packaging: 'source_checkout_or_optional_path', note: 'Rust accelerator available only from source checkout or SKS_RS_BIN until prebuilt packages exist.' };
   const result = await runProcess(bin, ['--version'], { timeoutMs: 3000, maxOutputBytes: 20_000 });
-  return { available: result.code === 0, bin, version: `${result.stdout}${result.stderr}`.trim(), packaging: 'source_checkout_or_optional_path' };
+  return { available: result.code === 0, bin, version: `${result.stdout}${result.stderr}`.trim(), capabilities, packaging: 'source_checkout_or_optional_path' };
 }
 
 function parseRustJson(text = '') {
   try { return JSON.parse(text); } catch { return text.trim(); }
 }
+
+function classifyRustError(command, text = '') {
+  const s = String(text || '');
+  if (/unknown|Commands:|optional accelerator/i.test(s)) return { kind: 'command_missing', command, message: s };
+  return { kind: 'runtime_error', command, message: s };
+}
+
+function normalizeAcceleratorResult(command, value) {
+  const result = value.result && typeof value.result === 'object' ? value.result : { ok: false, value: value.result };
+  return {
+    command,
+    engine: value.engine,
+    available: Boolean(value.available),
+    rust_error: value.rust_error || null,
+    stdout: value.stdout || null,
+    result
+  };
+}

package/src/core/version.mjs

@@ -1 +1 @@
-export const PACKAGE_VERSION = '0.9.12';
+export const PACKAGE_VERSION = '0.9.13';

package/src/core/wiki-image/callout-parser.mjs

@@ -0,0 +1,16 @@
+export function parseGeneratedReviewCallouts(ledger = {}) {
+  const items = Array.isArray(ledger.callouts)
+    ? ledger.callouts
+    : Array.isArray(ledger.issues)
+      ? ledger.issues
+      : [];
+  return items.map((item, index) => ({
+    id: item.id || `callout-${String(index + 1).padStart(3, '0')}`,
+    image_id: item.image_id || item.imageId || ledger.image_id || null,
+    bbox: item.bbox || item.box || null,
+    label: item.label || item.title || item.issue || `Callout ${index + 1}`,
+    source: item.source || ledger.source || 'gpt-image-2-annotated-review',
+    evidence_path: item.evidence_path || ledger.path || null,
+    trust_score: item.trust_score ?? 0.82
+  }));
+}

package/src/core/wiki-image/computer-use-ledger.mjs

@@ -0,0 +1,38 @@
+import path from 'node:path';
+import { nowIso, packageRoot, readJson } from '../fsx.mjs';
+import { addVisualAnchor, readImageVoxelLedger, writeImageVoxelLedger } from './image-voxel-ledger.mjs';
+import { validateImageVoxelLedger } from './validation.mjs';
+
+export async function importComputerUseEvidence(root = packageRoot(), file, opts = {}) {
+  const ledger = await readJson(path.resolve(root, file), {});
+  const current = await readImageVoxelLedger(root);
+  const screens = Array.isArray(ledger.screens) ? ledger.screens : [];
+  const images = [
+    ...(current.images || []),
+    ...screens.map((screen) => ({
+      id: screen.id,
+      path: screen.path,
+      sha256: screen.sha256 || 'fixture',
+      width: screen.width,
+      height: screen.height,
+      source: screen.source || 'codex-computer-use',
+      captured_at: screen.captured_at || nowIso()
+    }))
+  ].filter((image, index, all) => image.id && all.findIndex((entry) => entry.id === image.id) === index);
+  let next = await writeImageVoxelLedger(root, { ...current, mission_id: opts.missionId || current.mission_id || null, images });
+  for (const action of ledger.actions || []) {
+    if (!action.bbox) continue;
+    const result = await addVisualAnchor(root, {
+      imageId: action.screen_id,
+      bbox: action.bbox,
+      label: action.target || action.type || 'Computer Use action',
+      source: 'codex-computer-use',
+      evidencePath: file,
+      route: opts.route || '$Computer-Use',
+      missionId: opts.missionId
+    });
+    next = result.ledger;
+  }
+  const validation = validateImageVoxelLedger(next, { requireAnchors: true, route: opts.route || '$Computer-Use' });
+  return { schema: 'sks.computer-use-image-voxel-import.v1', ok: validation.ok, mode: ledger.mode || 'mock', ledger: next, validation };
+}

package/src/core/wiki-image/image-relation.mjs

@@ -0,0 +1,2 @@
+export { createImageRelation } from './visual-anchor.mjs';
+export { addImageRelation } from './image-voxel-ledger.mjs';

package/src/core/wiki-image/image-voxel-ledger.mjs

@@ -3,6 +3,7 @@ import { ensureDir, exists, nowIso, packageRoot, readJson, writeJsonAtomic } fro
 import { emptyImageVoxelLedger } from './image-voxel-schema.mjs';
 import { sha256File, imageDimensions } from './image-hash.mjs';
 import { validateImageVoxelLedger } from './validation.mjs';
+import { createImageRelation, createVisualAnchor } from './visual-anchor.mjs';
 
 export function wikiImageLedgerPath(root = packageRoot()) {
   return path.join(root, '.sneakoscope', 'wiki', 'image-voxel-ledger.json');
@@ -98,7 +99,49 @@ export async function imageVoxelSummary(root = packageRoot(), ledgerFile = wikiI
   };
 }
 
+export async function addVisualAnchor(root = packageRoot(), input = {}) {
+  const ledger = await readImageVoxelLedger(root);
+  const image = (ledger.images || []).find((entry) => entry.id === input.imageId);
+  const anchor = createVisualAnchor({
+    id: input.id || stableAnchorId(input.imageId, input.label, ledger.anchors?.length || 0),
+    imageId: input.imageId,
+    bbox: input.bbox,
+    label: input.label,
+    source: input.source || 'manual',
+    evidencePath: input.evidencePath || null,
+    trustScore: input.trustScore ?? 0.82,
+    route: input.route || null,
+    claimId: input.claimId || null
+  });
+  const anchors = [...(ledger.anchors || []).filter((entry) => entry.id !== anchor.id), anchor];
+  const next = await writeImageVoxelLedger(root, { ...ledger, mission_id: input.missionId || ledger.mission_id || null, anchors });
+  const validation = validateImageVoxelLedger(next, { requireAnchors: true, route: input.route || '$Wiki' });
+  return { ok: validation.ok && Boolean(image), anchor, ledger: next, validation: image ? validation : { ...validation, ok: false, issues: [...validation.issues, `missing_image:${input.imageId}`] } };
+}
+
+export async function addImageRelation(root = packageRoot(), input = {}) {
+  const ledger = await readImageVoxelLedger(root);
+  const relation = createImageRelation({
+    type: input.type || 'before_after',
+    beforeImageId: input.beforeImageId,
+    afterImageId: input.afterImageId,
+    anchors: input.anchors || [],
+    verification: input.verification || 'changed-screen-recheck',
+    status: input.status || 'verified_partial'
+  });
+  const relations = [...(ledger.relations || []), relation];
+  const next = await writeImageVoxelLedger(root, { ...ledger, mission_id: input.missionId || ledger.mission_id || null, relations });
+  const validation = validateImageVoxelLedger(next, { requireAnchors: true, requireRelations: true, route: input.route || '$Wiki' });
+  return { ok: validation.ok, relation, ledger: next, validation };
+}
+
 function stableImageId(rel, sha256) {
   const base = path.basename(rel).replace(/\.[^.]+$/, '').replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-|-$/g, '') || 'image';
   return `${base}-${sha256.slice(0, 8)}`;
 }
+
+function stableAnchorId(imageId = 'image', label = 'anchor', index = 0) {
+  const image = String(imageId || 'image').replace(/[^A-Za-z0-9_-]+/g, '-').slice(0, 40) || 'image';
+  const slug = String(label || 'anchor').replace(/[^A-Za-z0-9_-]+/g, '-').replace(/^-|-$/g, '').slice(0, 32) || 'anchor';
+  return `${image}-${slug}-${String(index + 1).padStart(3, '0')}`;
+}

package/src/core/wiki-image/proof-linker.mjs

@@ -0,0 +1,12 @@
+import { imageVoxelSummary } from './image-voxel-ledger.mjs';
+
+export async function imageVoxelProofEvidence(root, ledgerFile) {
+  const summary = await imageVoxelSummary(root, ledgerFile);
+  return {
+    schema: 'sks.image-voxel-proof-link.v1',
+    ok: summary.ok,
+    evidence: {
+      image_voxels: summary
+    }
+  };
+}

package/src/core/wiki-image/validation.mjs

@@ -1,12 +1,14 @@
 import { IMAGE_VOXEL_LEDGER_SCHEMA } from './image-voxel-schema.mjs';
 import { validateBbox } from './bbox.mjs';
 
-export function validateImageVoxelLedger(ledger = {}) {
+export function validateImageVoxelLedger(ledger = {}, opts = {}) {
   const issues = [];
   if (ledger.schema !== IMAGE_VOXEL_LEDGER_SCHEMA) issues.push('schema');
   const images = Array.isArray(ledger.images) ? ledger.images : [];
   const anchors = Array.isArray(ledger.anchors) ? ledger.anchors : [];
+  const relations = Array.isArray(ledger.relations) ? ledger.relations : [];
   const imageById = new Map();
+  const anchorById = new Map();
   for (const image of images) {
     if (!image.id) issues.push('image_id');
     if (image.id && imageById.has(image.id)) issues.push(`duplicate_image:${image.id}`);
@@ -15,28 +17,37 @@ export function validateImageVoxelLedger(ledger = {}) {
     if (!image.sha256) issues.push(`image_sha256:${image.id || 'unknown'}`);
     if (!Number.isFinite(Number(image.width)) || !Number.isFinite(Number(image.height))) issues.push(`image_dimensions:${image.id || 'unknown'}`);
   }
+  if (opts.requireAnchors && anchors.length === 0) issues.push(`missing_anchors:${opts.route || 'visual-route'}`);
   for (const anchor of anchors) {
     if (!anchor.id) issues.push('anchor_id');
+    if (anchor.id && anchorById.has(anchor.id)) issues.push(`duplicate_anchor:${anchor.id}`);
+    if (anchor.id) anchorById.set(anchor.id, anchor);
     if (!anchor.image_id || !imageById.has(anchor.image_id)) issues.push(`anchor_image_ref:${anchor.id || 'unknown'}`);
     if (anchor.bbox) {
-      const bbox = validateBbox(anchor.bbox, imageById.get(anchor.image_id) || {});
+      const image = imageById.get(anchor.image_id) || {};
+      if (!Number.isFinite(Number(image.width)) || !Number.isFinite(Number(image.height))) issues.push(`bbox_image_dimensions:${anchor.id || 'unknown'}`);
+      const bbox = validateBbox(anchor.bbox, image);
       for (const issue of bbox.issues) issues.push(`${issue}:${anchor.id || 'unknown'}`);
     } else {
       issues.push(`anchor_bbox:${anchor.id || 'unknown'}`);
     }
   }
-  for (const relation of Array.isArray(ledger.relations) ? ledger.relations : []) {
+  if (opts.requireRelations && relations.length === 0) issues.push(`missing_relations:${opts.route || 'visual-route'}`);
+  for (const relation of relations) {
     if (relation.before_image_id && !imageById.has(relation.before_image_id)) issues.push(`relation_before:${relation.before_image_id}`);
     if (relation.after_image_id && !imageById.has(relation.after_image_id)) issues.push(`relation_after:${relation.after_image_id}`);
+    for (const anchorId of relation.changed_anchor_ids || relation.anchors || []) {
+      if (!anchorById.has(anchorId)) issues.push(`relation_anchor:${anchorId}`);
+    }
   }
   return {
     ok: issues.length === 0,
-    status: issues.length ? 'blocked' : 'verified_partial',
+    status: issues.length ? 'blocked' : (anchors.length ? 'verified_partial' : 'not_verified'),
     issues,
     summary: {
       images: images.length,
       anchors: anchors.length,
-      relations: Array.isArray(ledger.relations) ? ledger.relations.length : 0
+      relations: relations.length
     }
   };
 }

package/src/core/wiki-image/visual-anchor.mjs

@@ -1,6 +1,6 @@
 import { rgbaKey, rgbaToWikiCoord } from '../wiki-coordinate.mjs';
 
-export function createVisualAnchor({ id, imageId, bbox, label, source, evidencePath, trustScore = 0.5, rgba = [58, 132, 210, 240] } = {}) {
+export function createVisualAnchor({ id, imageId, bbox, label, source, evidencePath, trustScore = 0.5, rgba = [58, 132, 210, 240], route = null, claimId = null } = {}) {
   const key = Array.isArray(rgba) ? rgbaKey(rgba) : String(rgba || '3a84d2f0');
   const rgbaTuple = Array.isArray(rgba)
     ? rgba
@@ -16,6 +16,8 @@ export function createVisualAnchor({ id, imageId, bbox, label, source, evidenceP
     evidence_path: evidencePath || null,
     trust_score: trustScore,
     trust_band: source || 'visual-anchor',
+    route,
+    claim_id: claimId,
     voxel_layers: {
       sem: 0.7,
       trust: trustScore,
@@ -27,3 +29,14 @@ export function createVisualAnchor({ id, imageId, bbox, label, source, evidenceP
     }
   };
 }
+
+export function createImageRelation({ type = 'before_after', beforeImageId, afterImageId, anchors = [], verification = 'changed-screen-recheck', status = 'verified_partial' } = {}) {
+  return {
+    type,
+    before_image_id: beforeImageId,
+    after_image_id: afterImageId,
+    changed_anchor_ids: Array.isArray(anchors) ? anchors : String(anchors || '').split(',').map((x) => x.trim()).filter(Boolean),
+    verification,
+    status
+  };
+}