@smartmemory/compose 0.1.0

package/scripts/vision-track.mjs

@@ -0,0 +1,554 @@
+#!/usr/bin/env node
+/**
+ * vision-track — Agent bridge to the Vision Surface.
+ *
+ * Full CLI for creating, reading, updating, deleting, connecting,
+ * and querying vision board items from the embedded terminal.
+ */
+
+import { fileURLToPath } from 'node:url';
+import { dirname, resolve } from 'node:path';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// Import validation constants from the server (single source of truth)
+const { VALID_TYPES, VALID_STATUSES, VALID_CONNECTION_TYPES, VALID_PHASES } = await import(
+  resolve(__dirname, '..', 'server', 'vision-store.js')
+);
+
+const API = process.env.VISION_API || 'http://localhost:3001/api/vision';
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+async function apiCall(path, method = 'GET', body) {
+  const opts = { method, headers: { 'Content-Type': 'application/json' } };
+  if (body) opts.body = JSON.stringify(body);
+
+  let res;
+  try {
+    res = await fetch(`${API}${path}`, opts);
+  } catch (err) {
+    console.error(`Failed to reach server at ${API}. Is it running?`);
+    process.exit(1);
+  }
+
+  const data = await res.json();
+  if (!res.ok) {
+    console.error(`API error ${res.status}: ${data.error || JSON.stringify(data)}`);
+    process.exit(1);
+  }
+  return data;
+}
+
+function parseArgs(args) {
+  const result = { positional: [], flags: {}, connections: [] };
+  let i = 0;
+  while (i < args.length) {
+    if (args[i] === '--connects-to') {
+      result.connections.push(args[++i]);
+      i++;
+    } else if (args[i].startsWith('--')) {
+      const key = args[i].slice(2);
+      result.flags[key] = args[++i];
+      i++;
+    } else {
+      result.positional.push(args[i]);
+      i++;
+    }
+  }
+  return result;
+}
+
+function formatItem(i) {
+  return `${i.id}  ${(i.status || '').padEnd(12)}  ${(i.type || '').padEnd(10)}  ${(i.phase || '-').padEnd(15)}  ${i.title}`;
+}
+
+// ---------------------------------------------------------------------------
+// Commands
+// ---------------------------------------------------------------------------
+
+async function createItem(parsed) {
+  const title = parsed.positional[0];
+  if (!title) {
+    console.error('Usage: vision-track create <title> [options]');
+    process.exit(1);
+  }
+
+  const type = parsed.flags.type || 'artifact';
+  const status = parsed.flags.status || 'planned';
+  const confidence = parseInt(parsed.flags.confidence || '0', 10);
+  const phase = parsed.flags.phase || undefined;
+  const description = parsed.flags.description || '';
+  const parentId = parsed.flags['parent-id'] || undefined;
+
+  // Validate before sending
+  if (!VALID_TYPES.includes(type)) {
+    console.error(`Invalid type: ${type}. Valid: ${VALID_TYPES.join(', ')}`);
+    process.exit(1);
+  }
+  if (!VALID_STATUSES.includes(status)) {
+    console.error(`Invalid status: ${status}. Valid: ${VALID_STATUSES.join(', ')}`);
+    process.exit(1);
+  }
+  if (phase && !VALID_PHASES.includes(phase)) {
+    console.error(`Invalid phase: ${phase}. Valid: ${VALID_PHASES.join(', ')}`);
+    process.exit(1);
+  }
+  if (confidence < 0 || confidence > 4) {
+    console.error('Confidence must be 0-4');
+    process.exit(1);
+  }
+
+  const body = { type, title, status, confidence, description };
+  if (phase) body.phase = phase;
+  if (parentId) body.parentId = parentId;
+  if (parsed.flags.files !== undefined) {
+    body.files = parsed.flags.files ? parsed.flags.files.split(',').map(f => f.trim()) : [];
+  }
+
+  const item = await apiCall('/items', 'POST', body);
+  console.error(`Created: ${item.id} (${title})`);
+
+  // Create connections
+  for (const conn of parsed.connections) {
+    const sepIdx = conn.lastIndexOf(':');
+    if (sepIdx === -1) {
+      console.error(`Invalid connection format: ${conn} (expected ID:TYPE)`);
+      continue;
+    }
+    const targetId = conn.slice(0, sepIdx);
+    const connType = conn.slice(sepIdx + 1);
+
+    if (!VALID_CONNECTION_TYPES.includes(connType)) {
+      console.error(`Invalid connection type: ${connType}. Valid: ${VALID_CONNECTION_TYPES.join(', ')}`);
+      continue;
+    }
+
+    await apiCall('/connections', 'POST', {
+      fromId: item.id,
+      toId: targetId,
+      type: connType,
+    });
+    console.error(`  Connected: ${item.id} --[${connType}]--> ${targetId}`);
+  }
+
+  // Machine-readable output on stdout
+  process.stdout.write(item.id + '\n');
+}
+
+async function updateItem(parsed) {
+  const id = parsed.positional[0];
+  if (!id) {
+    console.error('Usage: vision-track update <id> [options]');
+    process.exit(1);
+  }
+
+  const updates = {};
+  if (parsed.flags.status) {
+    if (!VALID_STATUSES.includes(parsed.flags.status)) {
+      console.error(`Invalid status: ${parsed.flags.status}. Valid: ${VALID_STATUSES.join(', ')}`);
+      process.exit(1);
+    }
+    updates.status = parsed.flags.status;
+  }
+  if (parsed.flags.confidence !== undefined) {
+    updates.confidence = parseInt(parsed.flags.confidence, 10);
+  }
+  if (parsed.flags.phase) {
+    if (!VALID_PHASES.includes(parsed.flags.phase)) {
+      console.error(`Invalid phase: ${parsed.flags.phase}. Valid: ${VALID_PHASES.join(', ')}`);
+      process.exit(1);
+    }
+    updates.phase = parsed.flags.phase;
+  }
+  if (parsed.flags.title) updates.title = parsed.flags.title;
+  if (parsed.flags.description) updates.description = parsed.flags.description;
+  if (parsed.flags.files !== undefined) {
+    updates.files = parsed.flags.files ? parsed.flags.files.split(',').map(f => f.trim()) : [];
+  }
+  if (parsed.flags['add-files']) {
+    const current = await apiCall(`/items/${id}`);
+    const existing = current.files || [];
+    const adding = parsed.flags['add-files'].split(',').map(f => f.trim());
+    updates.files = [...new Set([...existing, ...adding])];
+  }
+
+  if (Object.keys(updates).length === 0) {
+    console.error('No updates specified');
+    process.exit(1);
+  }
+
+  const item = await apiCall(`/items/${id}`, 'PATCH', updates);
+  console.error(`Updated: ${item.id} (${item.title})`);
+  process.stdout.write(item.id + '\n');
+}
+
+async function getItem(parsed) {
+  const id = parsed.positional[0];
+  if (!id) {
+    console.error('Usage: vision-track get <id>');
+    process.exit(1);
+  }
+
+  // Try the single-item endpoint first; fall back to fetching all and filtering
+  let item, connections;
+  try {
+    const result = await apiCall(`/items/${id}`);
+    // If the endpoint returns item+connections (new server), use directly
+    if (result.id) {
+      connections = result.connections || [];
+      item = result;
+    } else {
+      throw new Error('fallback');
+    }
+  } catch {
+    // Fallback: fetch all items and filter client-side
+    const state = await apiCall('/items');
+    const allItems = state.items || [];
+    item = allItems.find(i => i.id === id);
+    if (!item) {
+      console.error(`Item not found: ${id}`);
+      process.exit(1);
+    }
+    connections = (state.connections || []).filter(
+      c => c.fromId === id || c.toId === id
+    );
+  }
+
+  console.log(`ID:          ${item.id}`);
+  console.log(`Title:       ${item.title}`);
+  console.log(`Type:        ${item.type}`);
+  console.log(`Status:      ${item.status}`);
+  console.log(`Phase:       ${item.phase || '-'}`);
+  console.log(`Confidence:  ${item.confidence}`);
+  console.log(`Description: ${item.description || '-'}`);
+  console.log(`Parent:      ${item.parentId || '-'}`);
+  console.log(`Created:     ${item.createdAt}`);
+  console.log(`Updated:     ${item.updatedAt}`);
+  if (item.files && item.files.length > 0) {
+    console.log(`Files:       ${item.files.join(', ')}`);
+  }
+
+  if (connections.length > 0) {
+    console.log(`\nConnections (${connections.length}):`);
+    for (const c of connections) {
+      const direction = c.fromId === item.id ? '-->' : '<--';
+      const otherId = c.fromId === item.id ? c.toId : c.fromId;
+      console.log(`  ${c.id}  ${direction} [${c.type}] ${otherId}`);
+    }
+  }
+}
+
+async function deleteItem(parsed) {
+  const id = parsed.positional[0];
+  if (!id) {
+    console.error('Usage: vision-track delete <id>');
+    process.exit(1);
+  }
+
+  await apiCall(`/items/${id}`, 'DELETE');
+  console.error(`Deleted: ${id}`);
+}
+
+async function connectItems(parsed) {
+  const fromId = parsed.positional[0];
+  const toId = parsed.positional[1];
+  const connType = parsed.flags.type;
+
+  if (!fromId || !toId) {
+    console.error('Usage: vision-track connect <fromId> <toId> --type <type>');
+    process.exit(1);
+  }
+  if (!connType) {
+    console.error(`Connection type required. Use --type <type>. Valid: ${VALID_CONNECTION_TYPES.join(', ')}`);
+    process.exit(1);
+  }
+  if (!VALID_CONNECTION_TYPES.includes(connType)) {
+    console.error(`Invalid connection type: ${connType}. Valid: ${VALID_CONNECTION_TYPES.join(', ')}`);
+    process.exit(1);
+  }
+
+  const conn = await apiCall('/connections', 'POST', { fromId, toId, type: connType });
+  console.error(`Connected: ${fromId} --[${connType}]--> ${toId}`);
+  process.stdout.write(conn.id + '\n');
+}
+
+async function disconnectItems(parsed) {
+  const connectionId = parsed.positional[0];
+  if (!connectionId) {
+    console.error('Usage: vision-track disconnect <connectionId>');
+    process.exit(1);
+  }
+
+  await apiCall(`/connections/${connectionId}`, 'DELETE');
+  console.error(`Disconnected: ${connectionId}`);
+}
+
+async function showStatus() {
+  // Compute summary client-side from /items — works with or without /summary endpoint
+  const state = await apiCall('/items');
+  const items = state.items || [];
+  const connections = state.connections || [];
+
+  const byPhase = {};
+  const byStatus = {};
+  const byType = {};
+  let totalConfidence = 0;
+  let confidenceCount = 0;
+  let openQuestions = 0;
+  let blockedItems = 0;
+
+  for (const item of items) {
+    const phase = item.phase || 'unassigned';
+    byPhase[phase] = (byPhase[phase] || 0) + 1;
+
+    const status = item.status || 'planned';
+    byStatus[status] = (byStatus[status] || 0) + 1;
+
+    const type = item.type || 'artifact';
+    byType[type] = (byType[type] || 0) + 1;
+
+    if (typeof item.confidence === 'number') {
+      totalConfidence += item.confidence;
+      confidenceCount++;
+    }
+
+    if (item.type === 'question' && item.status !== 'complete' && item.status !== 'killed') {
+      openQuestions++;
+    }
+
+    if (item.status === 'blocked') {
+      blockedItems++;
+    }
+  }
+
+  const avgConfidence = confidenceCount > 0
+    ? Math.round((totalConfidence / confidenceCount) * 100) / 100
+    : 0;
+
+  console.log(`=== Vision Surface Summary ===`);
+  console.log(`Total items: ${items.length}   Connections: ${connections.length}   Avg confidence: ${avgConfidence}`);
+  console.log(`Open questions: ${openQuestions}   Blocked: ${blockedItems}`);
+
+  if (Object.keys(byPhase).length > 0) {
+    console.log(`\nBy phase:`);
+    for (const [phase, count] of Object.entries(byPhase).sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${phase.padEnd(18)} ${count}`);
+    }
+  }
+
+  if (Object.keys(byStatus).length > 0) {
+    console.log(`\nBy status:`);
+    for (const [status, count] of Object.entries(byStatus).sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${status.padEnd(18)} ${count}`);
+    }
+  }
+
+  if (Object.keys(byType).length > 0) {
+    console.log(`\nBy type:`);
+    for (const [type, count] of Object.entries(byType).sort((a, b) => b[1] - a[1])) {
+      console.log(`  ${type.padEnd(18)} ${count}`);
+    }
+  }
+}
+
+async function showReady() {
+  const state = await apiCall('/items');
+  const items = state.items || [];
+  const connections = state.connections || [];
+
+  // Build set of items that are blocked by non-complete items
+  const blockedIds = new Set();
+  for (const conn of connections) {
+    if (conn.type === 'blocks') {
+      const blocker = items.find(i => i.id === conn.fromId);
+      if (blocker && blocker.status !== 'complete' && blocker.status !== 'killed') {
+        blockedIds.add(conn.toId);
+      }
+    }
+  }
+
+  // Ready = planned or ready status, not blocked
+  const ready = items.filter(i =>
+    (i.status === 'planned' || i.status === 'ready') &&
+    !blockedIds.has(i.id)
+  );
+
+  if (ready.length === 0) {
+    console.log('No ready items found.');
+  } else {
+    for (const i of ready) {
+      console.log(formatItem(i));
+    }
+  }
+  console.error(`${ready.length} ready item${ready.length !== 1 ? 's' : ''}`);
+}
+
+async function searchItems(parsed) {
+  const query = (parsed.positional[0] || '').toLowerCase();
+  const state = await apiCall('/items');
+  const items = state.items || [];
+
+  const matches = query
+    ? items.filter(i =>
+        i.title.toLowerCase().includes(query) ||
+        (i.description || '').toLowerCase().includes(query) ||
+        i.type.includes(query) ||
+        (i.phase || '').includes(query)
+      )
+    : items;
+
+  for (const i of matches) {
+    console.log(formatItem(i));
+  }
+  console.error(`${matches.length} item${matches.length !== 1 ? 's' : ''} found`);
+}
+
+async function listItems() {
+  const state = await apiCall('/items');
+  const items = state.items || [];
+  for (const i of items) {
+    console.log(formatItem(i));
+  }
+  console.error(`${items.length} item${items.length !== 1 ? 's' : ''} total`);
+}
+
+function showHelp() {
+  console.log(`vision-track — Agent bridge to the Vision Surface
+
+COMMANDS
+
+  Items:
+    create <title> [options]    Create a new item
+    get <id>                    Get item details + connections
+    update <id> [options]       Update an item
+    delete <id>                 Delete an item and its connections
+    list                        List all items
+    search [query]              Search items by title/description/type/phase
+
+  Connections:
+    connect <fromId> <toId> --type <type>   Create a connection
+    disconnect <connectionId>               Delete a connection
+
+  Queries:
+    status                      Board summary (counts by phase/status/type)
+    ready                       Items ready to work on (not blocked)
+    help                        Show this help
+
+CREATE OPTIONS
+    --type TYPE           ${VALID_TYPES.join(', ')}
+    --phase PHASE         ${VALID_PHASES.join(', ')}
+    --status STATUS       ${VALID_STATUSES.join(', ')}
+    --confidence N        0-4 (default: 0)
+    --description DESC    Item description
+    --parent-id ID        Parent item ID
+    --files <paths>       Comma-separated file paths
+    --connects-to ID:TYPE Connection (repeatable)
+
+UPDATE OPTIONS
+    --status STATUS       New status
+    --confidence N        New confidence (0-4)
+    --phase PHASE         New phase
+    --title TITLE         New title
+    --description DESC    New description
+    --files <paths>       Comma-separated file paths (replaces existing)
+    --add-files <paths>   Comma-separated file paths (merges with existing)
+
+CONNECTION TYPES
+    ${VALID_CONNECTION_TYPES.join(', ')}
+
+EXAMPLES
+    # Create a spec in design phase
+    vision-track create "Auth flow spec" --type spec --phase design
+
+    # Create and connect to parent
+    vision-track create "Login UI" --type task --phase implementation \\
+      --connects-to abc123:supports
+
+    # Get item details
+    vision-track get abc123
+
+    # Update status and confidence
+    vision-track update abc123 --status complete --confidence 3
+
+    # Connect two existing items
+    vision-track connect item1 item2 --type informs
+
+    # Board overview
+    vision-track status
+
+    # What's ready to work on?
+    vision-track ready
+
+    # Delete an item
+    vision-track delete abc123
+
+OUTPUT
+    stdout: machine-readable (IDs). stderr: human-readable messages.
+    Pipe-friendly: \`id=$(vision-track create "title" --type task)\``);
+}
+
+// ---------------------------------------------------------------------------
+// Snapshot
+// ---------------------------------------------------------------------------
+
+async function takeSnapshot(parsed) {
+  const BASE = (process.env.VISION_API || 'http://localhost:3001/api/vision').replace('/api/vision', '');
+  const timeout = parsed.flags.timeout || '3000';
+  const noDom = parsed.flags['no-dom'] !== undefined;
+
+  let res;
+  try {
+    res = await fetch(`${BASE}/api/snapshot?timeout=${timeout}`);
+  } catch (err) {
+    console.error(`Failed to connect: ${err.message}`);
+    process.exit(1);
+  }
+
+  if (!res.ok) {
+    const data = await res.json().catch(() => ({}));
+    console.error(`Snapshot failed (${res.status}): ${data.error || res.statusText}`);
+    process.exit(1);
+  }
+
+  const snapshot = await res.json();
+
+  // Optionally strip DOM tree for compact output
+  if (noDom) delete snapshot.dom;
+
+  console.log(JSON.stringify(snapshot, null, 2));
+}
+
+// ---------------------------------------------------------------------------
+// Main
+// ---------------------------------------------------------------------------
+
+const args = process.argv.slice(2);
+const command = args[0];
+const rest = args.slice(1);
+
+if (!command || command === '--help' || command === '-h' || command === 'help') {
+  showHelp();
+  process.exit(0);
+}
+
+const parsed = parseArgs(rest);
+
+switch (command) {
+  case 'create':     await createItem(parsed); break;
+  case 'get':        await getItem(parsed); break;
+  case 'update':     await updateItem(parsed); break;
+  case 'delete':     await deleteItem(parsed); break;
+  case 'connect':    await connectItems(parsed); break;
+  case 'disconnect': await disconnectItems(parsed); break;
+  case 'status':     await showStatus(); break;
+  case 'ready':      await showReady(); break;
+  case 'search':     await searchItems(parsed); break;
+  case 'list':       await listItems(); break;
+  case 'snapshot':   await takeSnapshot(parsed); break;
+  default:
+    console.error(`Unknown command: ${command}. Run 'vision-track help' for usage.`);
+    process.exit(1);
+}

package/scripts/wire-all-orphans.mjs

@@ -0,0 +1,108 @@
+#!/usr/bin/env node
+import { readFileSync } from 'fs';
+import { execFileSync } from 'child_process';
+
+/*
+ * Wire all orphaned items to their parent feature/track.
+ * Mapping is manual — each orphan gets a parent and connection type.
+ */
+
+// Parent IDs
+const BOOTSTRAP     = '3743457d-0fad-4d42-9361-e1a4670b1688';
+const PIPELINE      = '404db70c-62ec-4a1f-85bb-bbb5563e3298';
+const VISIBILITY    = '2c54bedf-313a-4e03-bd53-41ff84c39c45';
+const DOGFOODING    = 'e3fdc74d-b640-4968-9ec4-8f9153ba6c7d';
+const FOUNDATION    = '0bd89667-64d5-4a81-ac4c-d252225bb769';
+const TERMINAL      = 'c1e35905-eb7b-4abf-8b2a-63ef37789060';
+const VIEWS         = '1d0b7445-6253-4581-9505-b18c1c721978';
+const THEME         = 'c0cd61ae-bb9c-4a9b-afca-bd8cf1dcef06';
+const ONTOLOGY      = '44bd4826-b86d-4342-9041-883eb50f974c';
+const VT_ENHANCE    = '97d4f5b4-e7c7-4c7c-9997-e01fe426c331';
+const DRILLDOWN     = '9ad7174c-2d1d-456a-a60c-86b18ca92304';
+const PERSISTENCE   = '2083f287-8a22-4f0e-9072-b5cd39dce0c3';
+const DISCOVERY_SUP = '29ba34a4-be37-4e2e-ba6d-f30a5cda38f2';
+const CONNECTORS    = '4675b520-3f21-4a48-b081-fcdb0c1ddfea';
+const STANDALONE    = '730004ed-1372-420d-9011-657b0a334c4a';
+const BREADCRUMBS   = '90c892e3-59d7-44ba-872f-0d62898a699e';
+const FORGE_LOOP    = 'f66a5788-0d96-41f3-9660-e85ae0d821c5';
+const AGENT_MON     = 'b81d24e2-9632-4e2a-967e-8aa0742740a7';
+
+// [orphanId, parentId, connectionType]
+const wiring = [
+  // Core decisions → Foundation & Discovery
+  ['5632a099-62f6-4f38-9d20-992a3072f369', FOUNDATION, 'supports'],
+  ['b16f899e-8e21-4d52-8ce6-2aecada67084', FOUNDATION, 'supports'],
+  ['9e90b79c-ce89-4fdf-a831-0be0c0677594', FOUNDATION, 'supports'],
+  ['f4702d82-992b-4027-a463-5cce923f9301', FOUNDATION, 'supports'],
+  ['b323d38c-0950-46ed-a64f-beefb9b66f72', FOUNDATION, 'supports'],
+  ['a11b2fe3-2b40-450c-804b-7c78e07813ed', FOUNDATION, 'supports'],
+  ['7853f84d-b121-4b6a-9849-5ae2e6576732', CONNECTORS, 'supports'],
+  ['cadd6004-8750-409c-857e-703061fd3f95', BOOTSTRAP, 'supports'],
+
+  // Ideas → various
+  ['2662567c-deac-4eec-9084-19d9756c093d', VISIBILITY, 'supports'],
+  ['bdbdd363-894d-48ad-be45-1680d1095c37', PIPELINE, 'supports'],
+  ['d45f80f0-43d5-48a2-bc80-83231f205c0c', PIPELINE, 'supports'],
+  ['83bdd6a9-c0aa-4c42-bc74-f65d2e320d0d', FOUNDATION, 'supports'],
+  ['1e555432-ce1c-4279-820c-0ba4fad53b2b', FOUNDATION, 'supports'],
+  ['orphan-persistence-model', PERSISTENCE, 'supports'],
+  ['orphan-voice-input', DISCOVERY_SUP, 'supports'],
+  ['orphan-mobile-view', STANDALONE, 'supports'],
+  ['idea-testing-strategy', PIPELINE, 'supports'],
+  ['e3091928-0b0d-4656-984b-8a2764eda72a', DRILLDOWN, 'supports'],
+
+  // Questions → various
+  ['37a333aa-1f0a-4f0d-8cab-c349f06a08cd', FOUNDATION, 'supports'],
+  ['5a836beb-afd4-4d21-b36d-1fe7c8a21eb8', FOUNDATION, 'supports'],
+  ['417e5c2c-992a-40e1-8ba1-3bc7e25564b0', VISIBILITY, 'supports'],
+  ['c38aa3ae-febb-4370-81ca-b22163825d10', ONTOLOGY, 'supports'],
+  ['question-release-strategy', STANDALONE, 'supports'],
+
+  // Threads → various
+  ['c3e13f70-2740-4558-997e-7f1dcb7a39c8', BOOTSTRAP, 'supports'],
+  ['86878969-e6cf-4002-8f50-b90122acf9ab', ONTOLOGY, 'supports'],
+  ['19f05faa-d50d-4697-87d2-c77b5d710a26', PIPELINE, 'supports'],
+  ['d28e17d8-b9e7-4484-84ec-27f83568371d', FOUNDATION, 'supports'],
+  ['thread-impl-bootstrap', BOOTSTRAP, 'supports'],
+
+  // Artifacts → various
+  ['09bcd9f9-316d-411b-9b66-22a2ddfa093e', VIEWS, 'supports'],
+  ['f29ec601-25ec-47c7-b5bb-6226512af135', ONTOLOGY, 'supports'],
+  ['8d3b67d7-122e-4231-a9ba-cb5ced9c92a7', BOOTSTRAP, 'supports'],
+
+  // Decisions (visibility) → Agent Visibility
+  ['dec-visibility-01', VISIBILITY, 'supports'],
+  ['dec-visibility-02', VISIBILITY, 'supports'],
+  ['dec-visibility-03', VISIBILITY, 'supports'],
+  ['dec-visibility-04', VISIBILITY, 'supports'],
+
+  // Specs → various
+  ['bf0f895c-f42e-4cbe-8322-101a4b6b8dff', VIEWS, 'supports'],
+  ['8d091d8f-10ba-41c1-8867-41032c4a60ef', VISIBILITY, 'supports'],
+  ['4b8c6dd8-cfb3-4d60-92b6-d745d7a4d4ce', VT_ENHANCE, 'supports'],
+  ['46481456-5233-4dc1-974e-17ff6c6c15d0', VT_ENHANCE, 'supports'],
+  ['6d1282a3-a64e-45c5-9c8c-fd2f46b1adc9', DRILLDOWN, 'supports'],
+
+  // Decisions (ontology/realignment) → Product Ontology
+  ['14d18445-158a-4c36-a352-8dbc7544c62f', ONTOLOGY, 'supports'],
+  ['c77d78ed-dfa3-4222-89e6-b3694335c6bf', ONTOLOGY, 'supports'],
+  ['13cfc103-0eaa-4c06-be0a-998174f49349', ONTOLOGY, 'supports'],
+
+  // Decisions (forge-loop) → Forge-Loop track
+  ['695aa0ff-6b48-4ddc-b19e-3d470a269c4e', FORGE_LOOP, 'supports'],
+  ['4bb32a05-f128-4822-976e-ccc96eb4c3ec', FORGE_LOOP, 'supports'],
+];
+
+let success = 0, fail = 0;
+for (const [fromId, toId, type] of wiring) {
+  try {
+    execFileSync('node', ['scripts/vision-track.mjs', 'connect', fromId, toId, '--type', type], { stdio: 'pipe' });
+    success++;
+    process.stdout.write('.');
+  } catch (e) {
+    fail++;
+    process.stdout.write('x');
+    console.error(`\n  FAIL: ${fromId} -> ${toId}: ${e.stderr?.toString().trim()}`);
+  }
+}
+console.log(`\n\nDone: ${success} wired, ${fail} failed`);