vericify 1.0.1 → 1.1.0

package/package.json

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

package/src/adapters/index.js

@@ -1,4 +1,7 @@
+import { hashText } from "../core/util.js";
 import { listLocalStatePaths, loadLocalState } from "./local-state.js";
+import { loadPeerAdapterStates } from "./peer-capture.js";
+import { annotateRecords, mergeByKeyWithProvenance } from "./provenance.js";
 import {
   attachWorkspaceAdapter,
   detectWorkspaceAdapters,
@@ -14,9 +17,68 @@ export function listDefaultWorkspacePaths(workspaceRoot) {
 
 export function loadWorkspaceState(workspaceRoot) {
   const state = loadLocalState(workspaceRoot);
+  const adapterProfiles = detectWorkspaceAdapters(workspaceRoot, state.adapterAttachments);
+  const peer = loadPeerAdapterStates(workspaceRoot, adapterProfiles);
+
+  const handoffs = mergeByKeyWithProvenance(
+    state.handoffs,
+    annotateRecords(peer.handoffs, {
+      source: "peer",
+      sourceKind: "handoff",
+      sourcePath: peer.sourceRefs?.[0],
+    }),
+    (h) => h.handoff_id ?? hashText(JSON.stringify(h))
+  );
+  const todoNodes = mergeByKeyWithProvenance(
+    state.todoNodes,
+    annotateRecords(peer.todoNodes, {
+      source: "peer",
+      sourceKind: "todo_node",
+      sourcePath: peer.sourceRefs?.[0],
+    }),
+    (n) => n.id ?? hashText(JSON.stringify(n))
+  );
+  const ledgerEntries = mergeByKeyWithProvenance(
+    state.ledgerEntries,
+    annotateRecords(peer.ledgerEntries, {
+      source: "peer",
+      sourceKind: "run_ledger",
+      sourcePath: peer.sourceRefs?.[0],
+    }),
+    (e) => e.id ?? hashText(`${e.timestamp_utc}:${e.tool}:${e.message}`)
+  );
+  const statusEvents = mergeByKeyWithProvenance(
+    state.statusEvents,
+    annotateRecords(peer.statusEvents, {
+      source: "peer",
+      sourceKind: "status_event",
+      sourcePath: peer.sourceRefs?.[0],
+    }),
+    (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 = mergeByKeyWithProvenance(
+    state.processPosts,
+    annotateRecords(peer.processPosts, {
+      source: "peer",
+      sourceKind: "process_post",
+      sourcePath: peer.sourceRefs?.[0],
+    }),
+    (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/local-state.js

@@ -2,18 +2,12 @@ import { hashText, unique } from "../core/util.js";
 import { readJson, readNdjson } from "../core/fs.js";
 import { listStorePaths, resolveStoreLayout } from "../store/paths.js";
 import { readAdapterAttachments } from "../store/adapter-attachments.js";
+import { annotateRecords, mergeByKeyWithProvenance } from "./provenance.js";
 
 export function listLocalStatePaths(workspaceRoot) {
   return listStorePaths(workspaceRoot);
 }
 
-function mergeByKey(preferredItems, partnerItems, getKey) {
-  const merged = new Map();
-  for (const item of partnerItems) merged.set(getKey(item), item);
-  for (const item of preferredItems) merged.set(getKey(item), item);
-  return [...merged.values()];
-}
-
 function mergeOrderedIds(preferred, partner) {
   return unique([...preferred, ...partner]);
 }
@@ -36,29 +30,69 @@ export function loadLocalState(workspaceRoot) {
     statusEvents: readNdjson(paths.partner.statusEvents),
   };
 
-  const handoffs = mergeByKey(
-    Object.values(vericifyState.handoffRegistry.handoffs ?? {}),
-    Object.values(partnerState.handoffRegistry.handoffs ?? {}),
+  const handoffs = mergeByKeyWithProvenance(
+    annotateRecords(Object.values(vericifyState.handoffRegistry.handoffs ?? {}), {
+      source: "native",
+      sourceKind: "handoff",
+      sourcePath: paths.vericify.handoffRegistry,
+    }),
+    annotateRecords(Object.values(partnerState.handoffRegistry.handoffs ?? {}), {
+      source: "partner",
+      sourceKind: "handoff",
+      sourcePath: paths.partner.handoffRegistry,
+    }),
     (handoff) => handoff.handoff_id ?? hashText(JSON.stringify(handoff))
   );
-  const todoNodes = mergeByKey(
-    Object.values(vericifyState.todoState.nodes ?? {}),
-    Object.values(partnerState.todoState.nodes ?? {}),
+  const todoNodes = mergeByKeyWithProvenance(
+    annotateRecords(Object.values(vericifyState.todoState.nodes ?? {}), {
+      source: "native",
+      sourceKind: "todo_node",
+      sourcePath: paths.vericify.todoState,
+    }),
+    annotateRecords(Object.values(partnerState.todoState.nodes ?? {}), {
+      source: "partner",
+      sourceKind: "todo_node",
+      sourcePath: paths.partner.todoState,
+    }),
     (node) => node.id ?? hashText(JSON.stringify(node))
   );
-  const ledgerEntries = mergeByKey(
-    Array.isArray(vericifyState.runLedger.entries) ? vericifyState.runLedger.entries : [],
-    Array.isArray(partnerState.runLedger.entries) ? partnerState.runLedger.entries : [],
+  const ledgerEntries = mergeByKeyWithProvenance(
+    annotateRecords(Array.isArray(vericifyState.runLedger.entries) ? vericifyState.runLedger.entries : [], {
+      source: "native",
+      sourceKind: "run_ledger",
+      sourcePath: paths.vericify.runLedger,
+    }),
+    annotateRecords(Array.isArray(partnerState.runLedger.entries) ? partnerState.runLedger.entries : [], {
+      source: "partner",
+      sourceKind: "run_ledger",
+      sourcePath: paths.partner.runLedger,
+    }),
     (entry) => entry.id ?? hashText(`${entry.timestamp_utc}:${entry.tool}:${entry.message}`)
   );
-  const statusEvents = mergeByKey(
-    vericifyState.statusEvents,
-    partnerState.statusEvents,
+  const statusEvents = mergeByKeyWithProvenance(
+    annotateRecords(vericifyState.statusEvents, {
+      source: "native",
+      sourceKind: "status_event",
+      sourcePath: paths.vericify.statusEvents,
+    }),
+    annotateRecords(partnerState.statusEvents, {
+      source: "partner",
+      sourceKind: "status_event",
+      sourcePath: paths.partner.statusEvents,
+    }),
     (event) => event.event_id ?? hashText(`${event.timestamp}:${event.source_module}:${event.event_type}:${event.status}`)
   ).sort((left, right) => String(left.timestamp).localeCompare(String(right.timestamp)));
-  const processPosts = mergeByKey(
-    Array.isArray(vericifyState.processPosts.posts) ? vericifyState.processPosts.posts : [],
-    Array.isArray(partnerState.processPosts.posts) ? partnerState.processPosts.posts : [],
+  const processPosts = mergeByKeyWithProvenance(
+    annotateRecords(Array.isArray(vericifyState.processPosts.posts) ? vericifyState.processPosts.posts : [], {
+      source: "native",
+      sourceKind: "process_post",
+      sourcePath: paths.vericify.processPosts,
+    }),
+    annotateRecords(Array.isArray(partnerState.processPosts.posts) ? partnerState.processPosts.posts : [], {
+      source: "partner",
+      sourceKind: "process_post",
+      sourcePath: paths.partner.processPosts,
+    }),
     (post) => post.process_post_id ?? hashText(`${post.timestamp}:${post.agent_id}:${post.summary}`)
   ).sort((left, right) => String(left.timestamp).localeCompare(String(right.timestamp)));
 

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/adapters/provenance.js

@@ -0,0 +1,70 @@
+function sourceSignature(source) {
+  return `${source.source ?? "-"}|${source.source_kind ?? "-"}|${source.source_path ?? "-"}`;
+}
+
+function uniqueRecordSources(values) {
+  const seen = new Set();
+  const merged = [];
+  for (const value of values) {
+    if (!value) continue;
+    const normalized = {
+      source: value.source,
+      source_kind: value.source_kind,
+      source_path: value.source_path,
+    };
+    const signature = sourceSignature(normalized);
+    if (seen.has(signature)) continue;
+    seen.add(signature);
+    merged.push(normalized);
+  }
+  return merged;
+}
+
+function recordSourceList(record) {
+  const explicit = record.record_source
+    ? [{
+      source: record.record_source,
+      source_kind: record.record_source_kind,
+      source_path: record.record_source_path,
+    }]
+    : [];
+  return uniqueRecordSources([...explicit, ...(Array.isArray(record.record_sources) ? record.record_sources : [])]);
+}
+
+function mergeRecordMetadata(preferred, secondary) {
+  const recordSources = uniqueRecordSources([...recordSourceList(preferred), ...recordSourceList(secondary)]);
+  const primary = recordSources[0];
+  return {
+    ...secondary,
+    ...preferred,
+    record_source: preferred.record_source ?? secondary.record_source ?? primary?.source,
+    record_source_kind: preferred.record_source_kind ?? secondary.record_source_kind ?? primary?.source_kind,
+    record_source_path: preferred.record_source_path ?? secondary.record_source_path ?? primary?.source_path,
+    record_sources: recordSources,
+  };
+}
+
+export function annotateRecord(record, { source, sourceKind, sourcePath }) {
+  return mergeRecordMetadata({
+    ...record,
+    record_source: source,
+    record_source_kind: sourceKind,
+    record_source_path: sourcePath,
+  }, record);
+}
+
+export function annotateRecords(records, provenance) {
+  return records.map((record) => annotateRecord(record, provenance));
+}
+
+export function mergeByKeyWithProvenance(preferredItems, secondaryItems, getKey) {
+  const merged = new Map();
+  const upsert = (item) => {
+    const key = getKey(item);
+    const existing = merged.get(key);
+    merged.set(key, existing ? mergeRecordMetadata(item, existing) : item);
+  };
+  for (const item of secondaryItems) upsert(item);
+  for (const item of preferredItems) upsert(item);
+  return [...merged.values()];
+}