vericify 1.0.1 → 1.0.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vericify",
-  "version": "1.0.1",
+  "version": "1.0.2",
   "private": false,
   "type": "module",
   "description": "Local-first run intelligence and operations hub for agent systems.",

package/src/adapters/index.js

@@ -1,4 +1,6 @@
+import { hashText } from "../core/util.js";
 import { listLocalStatePaths, loadLocalState } from "./local-state.js";
+import { loadPeerAdapterStates } from "./peer-capture.js";
 import {
   attachWorkspaceAdapter,
   detectWorkspaceAdapters,
@@ -8,15 +10,61 @@ import {
 
 export const DEFAULT_ADAPTER = "local-state";
 
+function mergeByKey(preferred, secondary, getKey) {
+  const merged = new Map();
+  for (const item of secondary) merged.set(getKey(item), item);
+  for (const item of preferred) merged.set(getKey(item), item);
+  return [...merged.values()];
+}
+
 export function listDefaultWorkspacePaths(workspaceRoot) {
   return listLocalStatePaths(workspaceRoot);
 }
 
 export function loadWorkspaceState(workspaceRoot) {
   const state = loadLocalState(workspaceRoot);
+  const adapterProfiles = detectWorkspaceAdapters(workspaceRoot, state.adapterAttachments);
+  const peer = loadPeerAdapterStates(workspaceRoot, adapterProfiles);
+
+  const handoffs = mergeByKey(
+    state.handoffs,
+    peer.handoffs,
+    (h) => h.handoff_id ?? hashText(JSON.stringify(h))
+  );
+  const todoNodes = mergeByKey(
+    state.todoNodes,
+    peer.todoNodes,
+    (n) => n.id ?? hashText(JSON.stringify(n))
+  );
+  const ledgerEntries = mergeByKey(
+    state.ledgerEntries,
+    peer.ledgerEntries,
+    (e) => e.id ?? hashText(`${e.timestamp_utc}:${e.tool}:${e.message}`)
+  );
+  const statusEvents = mergeByKey(
+    state.statusEvents,
+    peer.statusEvents,
+    (e) => e.event_id ?? hashText(`${e.timestamp}:${e.source_module}:${e.event_type}:${e.status}`)
+  ).sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp)));
+  const processPosts = mergeByKey(
+    state.processPosts,
+    peer.processPosts,
+    (p) => p.process_post_id ?? hashText(`${p.timestamp}:${p.agent_id}:${p.summary}`)
+  ).sort((a, b) => String(a.timestamp).localeCompare(String(b.timestamp)));
+
   return {
     ...state,
-    adapterProfiles: detectWorkspaceAdapters(workspaceRoot, state.adapterAttachments),
+    handoffs,
+    todoNodes,
+    todoOrder: [...new Set([...state.todoOrder, ...peer.todoOrder])],
+    ledgerEntries,
+    statusEvents,
+    processPosts,
+    adapterProfiles,
+    sourceRefs: {
+      ...state.sourceRefs,
+      peer: peer.sourceRefs,
+    },
   };
 }
 

package/src/adapters/peer-capture.js

@@ -0,0 +1,285 @@
+import { existsSync, readdirSync, statSync } from "node:fs";
+import { basename, join, resolve } from "node:path";
+import { readJson, readText } from "../core/fs.js";
+import { hashText } from "../core/util.js";
+
+function safeStatMtime(path) {
+  try {
+    return statSync(path).mtime.toISOString();
+  } catch {
+    return new Date().toISOString();
+  }
+}
+
+function peerId(adapterId, suffix) {
+  return `peer:${adapterId}:${hashText(suffix).slice(0, 10)}`;
+}
+
+function latestMtime(paths) {
+  let latest = 0;
+  for (const p of paths) {
+    try {
+      const t = statSync(p).mtime.getTime();
+      if (t > latest) latest = t;
+    } catch {
+      // ignore unreachable paths
+    }
+  }
+  return latest ? new Date(latest).toISOString() : new Date().toISOString();
+}
+
+function makeLedgerEntry(adapterId, label, timestamp, detectedPaths) {
+  return {
+    id: peerId(adapterId, `ledger:${timestamp}:${adapterId}`),
+    timestamp_utc: timestamp,
+    tool: adapterId,
+    category: "peer_observation",
+    message: `${label} workspace detected`,
+    metadata: {
+      adapter_id: adapterId,
+      source_adapter: adapterId,
+      detected_paths: detectedPaths,
+    },
+  };
+}
+
+function makeContextEvent(adapterId, filePath, content) {
+  return {
+    event_id: peerId(adapterId, `context:${filePath}`),
+    timestamp: safeStatMtime(filePath),
+    source_module: adapterId,
+    event_type: "CONTEXT_FILE",
+    status: "in_progress",
+    source_adapter: adapterId,
+    payload: {
+      summary: content.trim().slice(0, 120).replace(/\n+/g, " ") || `${basename(filePath)} present`,
+      file: basename(filePath),
+    },
+  };
+}
+
+function captureContextFile(adapterId, filePath, sourceRefs) {
+  if (!existsSync(filePath)) return null;
+  sourceRefs.push(filePath);
+  return makeContextEvent(adapterId, filePath, readText(filePath, ""));
+}
+
+function scanJsonFiles(dir) {
+  try {
+    return readdirSync(dir)
+      .filter((name) => name.endsWith(".json"))
+      .map((name) => join(dir, name));
+  } catch {
+    return [];
+  }
+}
+
+function passthroughJson(filePath) {
+  const empty = { handoffs: [], todoNodes: [], ledgerEntries: [], statusEvents: [], processPosts: [] };
+  try {
+    const data = readJson(filePath, null);
+    if (!data || typeof data !== "object") return empty;
+    return {
+      handoffs: data.handoffs && typeof data.handoffs === "object"
+        ? Object.values(data.handoffs).filter((v) => v?.handoff_id)
+        : [],
+      todoNodes: data.nodes && typeof data.nodes === "object"
+        ? Object.values(data.nodes).filter((v) => v?.id)
+        : [],
+      ledgerEntries: Array.isArray(data.entries) ? data.entries.filter((v) => v?.id) : [],
+      statusEvents: Array.isArray(data.events) ? data.events.filter((v) => v?.event_id) : [],
+      processPosts: Array.isArray(data.posts) ? data.posts.filter((v) => v?.process_post_id) : [],
+    };
+  } catch {
+    return empty;
+  }
+}
+
+function mergePassthrough(out, pt) {
+  out.handoffs.push(...pt.handoffs);
+  out.todoNodes.push(...pt.todoNodes);
+  out.ledgerEntries.push(...pt.ledgerEntries);
+  out.statusEvents.push(...pt.statusEvents);
+  out.processPosts.push(...pt.processPosts);
+}
+
+// ── Per-adapter capture ─────────────────────────────────────────────────────
+
+function captureCodex(workspaceRoot, profile, out) {
+  const sourceRefs = [];
+  const events = [];
+  const ev = captureContextFile("codex", resolve(workspaceRoot, "AGENTS.md"), sourceRefs);
+  if (ev) events.push(ev);
+
+  const codexDir = resolve(workspaceRoot, ".codex");
+  for (const jf of scanJsonFiles(codexDir)) {
+    sourceRefs.push(jf);
+    mergePassthrough(out, passthroughJson(jf));
+  }
+
+  if (sourceRefs.length) {
+    out.ledgerEntries.push(makeLedgerEntry("codex", profile.label, latestMtime(sourceRefs), sourceRefs));
+    out.statusEvents.push(...events);
+    out.sourceRefs.push(...sourceRefs);
+  }
+}
+
+function captureClaudeCode(workspaceRoot, profile, out) {
+  const sourceRefs = [];
+  const events = [];
+  const ev = captureContextFile("claude-code", resolve(workspaceRoot, "CLAUDE.md"), sourceRefs);
+  if (ev) events.push(ev);
+
+  const claudeDir = resolve(workspaceRoot, ".claude");
+  const settingsFiles = [join(claudeDir, "settings.json"), join(claudeDir, "settings.local.json")];
+  for (const sf of settingsFiles) {
+    if (existsSync(sf)) sourceRefs.push(sf);
+  }
+  for (const jf of scanJsonFiles(claudeDir)) {
+    if (!sourceRefs.includes(jf)) sourceRefs.push(jf);
+    mergePassthrough(out, passthroughJson(jf));
+  }
+
+  if (sourceRefs.length) {
+    out.ledgerEntries.push(makeLedgerEntry("claude-code", profile.label, latestMtime(sourceRefs), sourceRefs));
+    out.statusEvents.push(...events);
+    out.sourceRefs.push(...sourceRefs);
+  }
+}
+
+function captureCursor(workspaceRoot, profile, out) {
+  const sourceRefs = [];
+  const events = [];
+  const ev = captureContextFile("cursor", resolve(workspaceRoot, ".cursorrules"), sourceRefs);
+  if (ev) events.push(ev);
+
+  const rulesDir = resolve(workspaceRoot, ".cursor/rules");
+  if (existsSync(rulesDir)) {
+    try {
+      const ruleFiles = readdirSync(rulesDir)
+        .filter((name) => /\.(md|txt|mdc)$/.test(name))
+        .map((name) => join(rulesDir, name));
+      for (const rf of ruleFiles) {
+        const rev = captureContextFile("cursor", rf, sourceRefs);
+        if (rev) events.push(rev);
+      }
+    } catch {
+      // ignore unreadable rules dir
+    }
+  }
+
+  if (sourceRefs.length) {
+    out.ledgerEntries.push(makeLedgerEntry("cursor", profile.label, latestMtime(sourceRefs), sourceRefs));
+    out.statusEvents.push(...events);
+    out.sourceRefs.push(...sourceRefs);
+  }
+}
+
+function captureVscodeCopilot(workspaceRoot, profile, out) {
+  const sourceRefs = [];
+  const events = [];
+  const ev = captureContextFile(
+    "vscode-copilot-chat",
+    resolve(workspaceRoot, ".github/copilot-instructions.md"),
+    sourceRefs
+  );
+  if (ev) events.push(ev);
+
+  const settings = resolve(workspaceRoot, ".vscode/settings.json");
+  if (existsSync(settings)) sourceRefs.push(settings);
+
+  if (sourceRefs.length) {
+    out.ledgerEntries.push(
+      makeLedgerEntry("vscode-copilot-chat", profile.label, latestMtime(sourceRefs), sourceRefs)
+    );
+    out.statusEvents.push(...events);
+    out.sourceRefs.push(...sourceRefs);
+  }
+}
+
+function captureAntigravity(workspaceRoot, profile, out) {
+  const sourceRefs = [];
+  const events = [];
+  const configJson = resolve(workspaceRoot, "antigravity.config.json");
+  if (existsSync(configJson)) {
+    sourceRefs.push(configJson);
+    mergePassthrough(out, passthroughJson(configJson));
+  }
+
+  const antigravityDir = resolve(workspaceRoot, ".antigravity");
+  for (const jf of scanJsonFiles(antigravityDir)) {
+    if (!sourceRefs.includes(jf)) sourceRefs.push(jf);
+    mergePassthrough(out, passthroughJson(jf));
+  }
+
+  if (sourceRefs.length) {
+    out.ledgerEntries.push(
+      makeLedgerEntry("antigravity", profile.label, latestMtime(sourceRefs), sourceRefs)
+    );
+    out.statusEvents.push(...events);
+    out.sourceRefs.push(...sourceRefs);
+  }
+}
+
+const CAPTURE_FNS = {
+  codex: captureCodex,
+  "claude-code": captureClaudeCode,
+  cursor: captureCursor,
+  "vscode-copilot-chat": captureVscodeCopilot,
+  antigravity: captureAntigravity,
+};
+
+// ── Public API ──────────────────────────────────────────────────────────────
+
+export function capturePeerAdapterState(workspaceRoot, profile) {
+  const out = {
+    handoffs: [],
+    todoNodes: [],
+    todoOrder: [],
+    ledgerEntries: [],
+    statusEvents: [],
+    processPosts: [],
+    sourceRefs: [],
+  };
+
+  if (profile.detection_status !== "attached" && profile.detection_status !== "detected") {
+    return out;
+  }
+
+  const fn = CAPTURE_FNS[profile.adapter_id];
+  if (!fn) return out;
+
+  try {
+    fn(workspaceRoot, profile, out);
+  } catch {
+    // peer capture never throws
+  }
+
+  return out;
+}
+
+export function loadPeerAdapterStates(workspaceRoot, adapterProfiles) {
+  const merged = {
+    handoffs: [],
+    todoNodes: [],
+    todoOrder: [],
+    ledgerEntries: [],
+    statusEvents: [],
+    processPosts: [],
+    sourceRefs: [],
+  };
+
+  for (const profile of adapterProfiles) {
+    if (profile.category !== "peer") continue;
+    const captured = capturePeerAdapterState(workspaceRoot, profile);
+    merged.handoffs.push(...captured.handoffs);
+    merged.todoNodes.push(...captured.todoNodes);
+    merged.todoOrder.push(...captured.todoOrder);
+    merged.ledgerEntries.push(...captured.ledgerEntries);
+    merged.statusEvents.push(...captured.statusEvents);
+    merged.processPosts.push(...captured.processPosts);
+    merged.sourceRefs.push(...captured.sourceRefs);
+  }
+
+  return merged;
+}

package/src/tui/app.js

@@ -11,6 +11,7 @@ import { upsertTodoNode } from "../store/todo-state.js";
 import { formatTimestamp } from "../core/util.js";
 import { completeCommand, executeCommand } from "./commands.js";
 import {
+  buildAdaptersSections,
   buildCompareSections,
   buildHistorySections,
   buildHubMetrics,
@@ -165,7 +166,9 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
           ? buildInspectSections(selected, { tier })
           : state.view === "history"
             ? buildHistorySections(state.projected, selected, { tier })
-            : buildHubSections(state.projected, selected, { tier })),
+            : state.view === "adapters"
+              ? buildAdaptersSections(state.projected, { tier })
+              : buildHubSections(state.projected, selected, { tier })),
     ];
 
     line(boxTitle(` Vericify Hub | ${state.mode} | ${workspaceRoot} `, width));
@@ -175,7 +178,7 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
     renderPanelGrid(sections, width, tier);
     const prompt = state.mode === "command"
       ? `/${state.commandBuffer}`
-      : "[q quit] [j/k move] [Enter inspect] [c compare] [y history] [r refresh] [/ command] [h hub]";
+      : "[q quit] [j/k move] [Enter inspect] [c compare] [y history] [a adapters] [r refresh] [/ command] [h hub]";
     line(truncate(prompt, width));
     line(boxFooter(width));
   };
@@ -512,6 +515,13 @@ export async function runHub({ workspaceRoot, feedFile, loadState, watchedPaths
       recordInteractiveTransition(before, { source: "keyboard" });
       return;
     }
+    if (key.name === "a") {
+      const before = captureRuntimeState();
+      state.view = "adapters";
+      rerender();
+      recordInteractiveTransition(before, { source: "keyboard" });
+      return;
+    }
     if (key.name === "r") {
       const before = captureRuntimeState();
       refresh();

package/src/tui/commands.js

@@ -1,5 +1,5 @@
 export function completeCommand(input, runIds) {
-  const commands = ["help", "quit", "refresh", "hub", "run", "inspect", "compare", "history", "select", "next", "prev", "focus", "post", "handoff", "todo", "ledger", "event"];
+  const commands = ["help", "quit", "refresh", "hub", "run", "inspect", "compare", "history", "adapters", "select", "next", "prev", "focus", "post", "handoff", "todo", "ledger", "event"];
   const parts = input.split(/\s+/);
   const token = parts.at(-1) ?? "";
   const options = parts.length > 1 ? [...runIds, ...commands] : [...commands, ...runIds];
@@ -107,6 +107,9 @@ export function executeCommand(command, state) {
     const compareTarget = positionals[0];
     return { patch: { view: "compare", compareTarget }, message: "Switched to compare view." };
   }
+  if (name === "adapters") {
+    return { patch: { view: "adapters" }, message: "Switched to adapters view." };
+  }
   if (name === "history") {
     return { patch: { view: "history" }, message: "Switched to history view." };
   }

package/src/tui/panels.js

@@ -352,6 +352,79 @@ export function buildRunBoardSection(projected, selectedRun, options = {}) {
   };
 }
 
+const PEER_ADAPTER_IDS = new Set(["codex", "claude-code", "cursor", "vscode-copilot-chat", "antigravity"]);
+const STATUS_GLYPH = { ready: "✓", attached: "●", detected: "◉", manual: "○" };
+
+function relPath(absPath, root) {
+  return absPath.startsWith(root + "/") ? absPath.slice(root.length + 1) : absPath;
+}
+
+function adapterStatusRow(profile, workspaceRoot) {
+  const glyph  = STATUS_GLYPH[profile.detection_status] ?? "?";
+  const status = profile.detection_status.padEnd(8);
+  const label  = (profile.label_override ?? profile.label).padEnd(22);
+  const cat    = `(${profile.category})`.padEnd(10);
+  let detail = "";
+  if (profile.detection_status === "manual") {
+    detail = `→ vericify attach --adapter ${profile.adapter_id}`;
+  } else {
+    const paths = profile.detected_paths.slice(0, 3).map((p) => relPath(p, workspaceRoot));
+    detail = paths.join("  ");
+    if (profile.session_id) detail += `  session:${profile.session_id}`;
+  }
+  return `${glyph} ${status} ${label} ${cat} ${detail}`;
+}
+
+function buildPeerObservationRows(projected, tier) {
+  const limit = tier === "narrow" ? 4 : 6;
+  const items = (projected.runs ?? [])
+    .flatMap((run) => run.activity_items ?? [])
+    .filter((item) =>
+      item.label === "peer_observation" ||
+      (PEER_ADAPTER_IDS.has(item.actor_id) && item.source_kind === "status_event")
+    )
+    .sort((a, b) => String(b.timestamp).localeCompare(String(a.timestamp)));
+  return top(items, limit).map((item) =>
+    `${formatTimestamp(item.timestamp)} [${item.actor_id}] ${item.summary}`
+  );
+}
+
+function buildAttachGuideRows(profiles) {
+  const manual = profiles.filter((p) => p.detection_status === "manual" && p.category === "peer");
+  if (!manual.length) return ["All peer adapters detected or attached."];
+  return [
+    "Activate with:  vericify attach --adapter <id>",
+    ...manual.map((p) => `  ○ ${p.adapter_id.padEnd(22)} ${p.label}`),
+  ];
+}
+
+export function buildAdaptersSections(projected, options = {}) {
+  const { tier = "wide" } = options;
+  const profiles = projected.adapter_profiles ?? [];
+  const workspaceRoot = projected.workspace?.root_path ?? "";
+  const adapterRows = profiles.map((p) => adapterStatusRow(p, workspaceRoot));
+  const observationRows = buildPeerObservationRows(projected, tier);
+  const guideRows = buildAttachGuideRows(profiles);
+  return [
+    {
+      title: "Adapter Sources",
+      rows: adapterRows.length ? adapterRows : ["No adapters resolved."],
+      tone: "STATUS",
+      fullWidth: true,
+    },
+    {
+      title: "Peer Observations",
+      rows: observationRows.length ? observationRows : ["No peer capture data yet."],
+      tone: "TRACE",
+    },
+    {
+      title: "Attach Guide",
+      rows: guideRows,
+      tone: "WAIT",
+    },
+  ];
+}
+
 export function buildHubSections(projected, selectedRun, options = {}) {
   const { tier = "wide" } = options;
   return [