@zuzuucodes/cli 1.0.0

package/experiments/experiment-1-trace-capture/adapters/gemini-cli.mjs

@@ -0,0 +1,113 @@
+// Gemini CLI adapter — parses ~/.gemini/tmp/<project>/logs.json.
+//
+// Deliberately the THIN counterpart to claude-code, and the honest proof of the
+// README's thesis that "observability completeness varies by host". Gemini's
+// logs.json is a flat user-prompt timeline only:
+//   { sessionId, messageId, type:"user", message, timestamp }
+// — no assistant turns, no tool calls (those live in Gemini *checkpoint* files,
+// deferred). So this adapter emits SESSION -> TURN (prompt) and stops there.
+// Same core, second host, different shape => host-agnosticity DEMONSTRATED, not
+// asserted; the missing tool layer is a capture gap, not a core change.
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync, readdirSync, readFileSync } from 'node:fs';
+import { event, trace, EventKind } from '../core/event.mjs';
+import { emptySignals } from './signals.mjs';
+
+const TMP_DIR = join(homedir(), '.gemini', 'tmp');
+
+const ms = (iso) => (iso ? Date.parse(iso) : NaN);
+const clean = (s) => String(s).replace(/\s+/g, ' ').trim();
+const truncate = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+
+function readLog(file) {
+  try {
+    const data = JSON.parse(readFileSync(file, 'utf8'));
+    return Array.isArray(data) ? data : [];
+  } catch {
+    return [];
+  }
+}
+
+export const geminiCli = {
+  name: 'gemini-cli',
+
+  detect() {
+    return existsSync(TMP_DIR);
+  },
+
+  // Cross-host distill: logs.json is PROMPT-ONLY (no tool calls) → empty superset.
+  // Honest: gemini's on-disk capture is thin (tool calls live in checkpoints).
+  mineSignals() {
+    return emptySignals();
+  },
+
+  listSessions() {
+    if (!existsSync(TMP_DIR)) return [];
+    const out = [];
+    for (const project of readdirSync(TMP_DIR)) {
+      const file = join(TMP_DIR, project, 'logs.json');
+      if (!existsSync(file)) continue;
+      const rows = readLog(file);
+      const sessions = new Map(); // sessionId -> {count, last}
+      for (const r of rows) {
+        if (!r.sessionId) continue;
+        const s = sessions.get(r.sessionId) || { count: 0, last: 0 };
+        s.count++;
+        s.last = Math.max(s.last, ms(r.timestamp) || 0);
+        sessions.set(r.sessionId, s);
+      }
+      for (const [sessionId, s] of sessions) {
+        out.push({ sessionId, label: `${project} (${s.count} msgs)`, ref: { file, sessionId }, mtime: s.last });
+      }
+    }
+    return out.sort((a, b) => b.mtime - a.mtime);
+  },
+
+  parse(ref) {
+    const { file, sessionId } = ref;
+    const rows = readLog(file)
+      .filter((r) => r.sessionId === sessionId && r.type === 'user')
+      .sort((a, b) => (a.messageId ?? 0) - (b.messageId ?? 0));
+
+    const times = rows.map((r) => ms(r.timestamp)).filter(Number.isFinite);
+    const startMs = times.length ? Math.min(...times) : 0;
+    const endMs = times.length ? Math.max(...times) : startMs;
+
+    const events = rows.map((r, i) => {
+      const t = ms(r.timestamp);
+      const start = Number.isFinite(t) ? t : startMs;
+      // Tile prompts: a prompt span runs until the next prompt (gives readable durations).
+      const nextT = ms(rows[i + 1]?.timestamp);
+      const end = Number.isFinite(nextT) ? nextT : Math.max(start, endMs);
+      const text = clean(r.message);
+      return event({
+        kind: EventKind.TURN,
+        refId: `${sessionId}:${r.messageId ?? i}`,
+        parentRefId: sessionId,
+        name: 'turn: ' + (truncate(text, 60) || '(empty)'),
+        startMs: start,
+        endMs: end,
+        attributes: { 'turn.prompt.bytes': text.length },
+      });
+    });
+
+    events.unshift(
+      event({
+        kind: EventKind.SESSION,
+        refId: sessionId,
+        parentRefId: null,
+        name: `session ${sessionId.slice(0, 8)} (gemini-cli)`,
+        startMs,
+        endMs,
+        attributes: {
+          'host.name': 'gemini-cli',
+          'host.capture.note': 'logs.json = user prompts only; tool calls live in checkpoints (not captured)',
+        },
+      }),
+    );
+
+    return trace({ host: 'gemini-cli', sessionId, events });
+  },
+};

package/experiments/experiment-1-trace-capture/adapters/host-adapter.mjs

@@ -0,0 +1,43 @@
+// The HostAdapter contract — the host-agnostic seam.
+//
+// Shape borrowed from entire.io's audited adapter model (inspiration/
+// entire-io-host-adapter-audit.md): a small required surface to DETECT a host and
+// RESOLVE + PARSE its session transcript, normalizing into the one Event vocabulary.
+// The dispatcher (registry/capture) routes by capability, never by host name — so
+// the core stays agnostic and a new host is "just another adapter".
+//
+// Capture today is transcript-parsing, which works for ANY host that writes a
+// session log to disk (all of them) and needs zero cooperation from the host.
+// Live hooks are an OPTIONAL later capability (HookSupport), not the foundation.
+//
+// An adapter is a plain object implementing:
+//
+//   name: string
+//       stable adapter id, also the OTel `host.name` (e.g. "claude-code").
+//
+//   detect(): boolean
+//       is this host present on the machine? (its data dir exists)
+//
+//   listSessions(opts?): Array<{ sessionId, label, ref }>
+//       enumerate available sessions. `ref` is whatever parse() needs to load it
+//       (a file path, or {file, sessionId} when a file holds many sessions).
+//       Sorted most-recent-first when possible.
+//
+//   parse(ref): import('../core/event.mjs').trace
+//       load one session and normalize it into a { host, sessionId, title, events }
+//       trace whose events are exactly one SESSION root + its descendants.
+//
+// Optional (not implemented in Experiment 1):
+//   installHooks(), parseHookEvent(stdin) -> Event   // live capture where supported
+
+export const HOST_ADAPTER_KEYS = ['name', 'detect', 'listSessions', 'parse'];
+
+/** Throw if an object doesn't implement the required adapter surface. */
+export function assertAdapter(a) {
+  for (const k of HOST_ADAPTER_KEYS) {
+    if (typeof a?.[k] !== (k === 'name' ? 'string' : 'function')) {
+      throw new Error(`invalid HostAdapter: missing ${k}`);
+    }
+  }
+  return a;
+}

package/experiments/experiment-1-trace-capture/adapters/opencode.mjs

@@ -0,0 +1,205 @@
+// OpenCode adapter — reads ~/.local/share/opencode/opencode.db (SQLite).
+//
+// Built against REAL wire data (a live `opencode run` session via the Google
+// provider). Confirmed shapes (v1.16.2):
+//   session row: { id, directory, title, model(JSON string), time_created, time_updated }
+//   message row: { id, session_id, time_created, data:JSON{ role: user|assistant, time } }
+//   part row:    { id, message_id, session_id, time_created, data:JSON{ type, ... } }
+//     part.data.type ∈ text | tool | reasoning | step-start | step-finish
+//       text → { text }                        (user prompt + assistant text live here)
+//       tool → { tool, callID, state:{ status, input, output, time:{start,end}, metadata:{exit} } }
+//
+// node:sqlite is loaded LAZILY (createRequire) so importing this adapter never
+// breaks the registry on Node <22 — only `opencode` commands touch SQLite.
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync } from 'node:fs';
+import { createRequire } from 'node:module';
+import { event, trace, EventKind, Status } from '../core/event.mjs';
+import { assembleSignals, emptySignals } from './signals.mjs';
+
+const require = createRequire(import.meta.url);
+const DB_PATH = join(homedir(), '.local', 'share', 'opencode', 'opencode.db');
+
+const clean = (s) => String(s).replace(/\s+/g, ' ').trim();
+const truncate = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+const openDb = (path) => new (require('node:sqlite').DatabaseSync)(path, { readOnly: true });
+
+/**
+ * Pure normalization — host-agnostic, hermetically testable.
+ * @param {object} t
+ * @param {{id,directory,title,model,time_created,time_updated}} t.session
+ * @param {Array<{id,role,time_created}>} t.messages
+ * @param {Array<{messageId,time_created,type,text?,tool?,callID?,state?}>} t.parts
+ */
+export function buildTrace({ session, messages, parts }) {
+  const sid = session.id;
+  const events = [];
+
+  const partsByMsg = new Map();
+  for (const p of parts) {
+    if (!partsByMsg.has(p.messageId)) partsByMsg.set(p.messageId, []);
+    partsByMsg.get(p.messageId).push(p);
+  }
+
+  // Turns: one per user message; prompt text = its text parts.
+  const turns = [];
+  for (const m of messages.filter((m) => m.role === 'user').sort((a, b) => a.time_created - b.time_created)) {
+    const text = (partsByMsg.get(m.id) || []).filter((p) => p.type === 'text').map((p) => p.text || '').join(' ');
+    turns.push({ refId: m.id, start: m.time_created });
+    events.push(
+      event({
+        kind: EventKind.TURN,
+        refId: m.id,
+        parentRefId: sid,
+        name: 'turn: ' + (truncate(clean(text), 60) || '(empty)'),
+        startMs: m.time_created,
+        endMs: m.time_created,
+        attributes: { 'turn.prompt.bytes': text.length },
+      }),
+    );
+  }
+
+  // Tool spans: from tool parts, paired durations via state.time.{start,end}.
+  const turnEnd = new Map();
+  for (const p of parts.filter((p) => p.type === 'tool').sort((a, b) => (a.state?.time?.start || 0) - (b.state?.time?.start || 0))) {
+    const st = p.state || {};
+    const startMs = st.time?.start || p.time_created || session.time_created;
+    const endMs = st.time?.end || startMs;
+    let parent = sid;
+    for (const t of turns) if (t.start <= startMs) parent = t.refId; // most recent user turn
+    const input = JSON.stringify(st.input ?? {});
+    const output = typeof st.output === 'string' ? st.output : JSON.stringify(st.output ?? '');
+    events.push(
+      event({
+        kind: EventKind.TOOL_CALL,
+        refId: p.callID || `${sid}:call:${events.length}`,
+        parentRefId: parent,
+        name: p.tool || 'tool',
+        startMs,
+        endMs,
+        status: st.status === 'error' ? Status.ERROR : Status.OK,
+        attributes: {
+          'gen_ai.operation.name': 'execute_tool',
+          'gen_ai.tool.name': p.tool || '',
+          'host.tool.name': p.tool || '',
+          'tool.input.bytes': input.length,
+          'tool.result.bytes': output.length,
+        },
+      }),
+    );
+    turnEnd.set(parent, Math.max(turnEnd.get(parent) ?? 0, endMs));
+  }
+
+  for (const e of events) if (e.kind === EventKind.TURN && turnEnd.has(e.refId)) e.endMs = Math.max(e.endMs, turnEnd.get(e.refId));
+
+  const ends = events.map((e) => e.endMs);
+  const startMs = session.time_created || Math.min(...turns.map((t) => t.start), session.time_updated || 0);
+  const endMs = Math.max(session.time_updated || 0, startMs, ...ends);
+
+  let model = '';
+  try {
+    const m = typeof session.model === 'string' ? JSON.parse(session.model) : session.model;
+    if (m) model = `${m.providerID || ''}/${m.id || m.modelID || ''}`;
+  } catch {
+    /* model stays '' */
+  }
+
+  events.unshift(
+    event({
+      kind: EventKind.SESSION,
+      refId: sid,
+      parentRefId: null,
+      name: `session ${String(sid).slice(0, 12)} (opencode)`,
+      startMs,
+      endMs,
+      attributes: { 'host.name': 'opencode', 'host.session.model': model, 'host.cwd': session.directory || '' },
+    }),
+  );
+
+  return trace({ host: 'opencode', sessionId: sid, title: session.title || '', events });
+}
+
+// opencode shell tool (real-wire): tool part name "bash", state.input.command
+// (a string), state.status enum ("completed" | "error"). Pure → testable.
+const OC_SHELL = new Set(['bash', 'shell']);
+export function signalsFromParts(parts) {
+  const shellCalls = [];
+  for (const p of parts.filter((p) => p.type === 'tool').sort((a, b) => (a.state?.time?.start || a.time_created || 0) - (b.state?.time?.start || b.time_created || 0))) {
+    if (!OC_SHELL.has(p.tool)) continue;
+    const cmd = p.state?.input?.command;
+    if (typeof cmd !== 'string' || !cmd) continue;
+    shellCalls.push({ cmd, failed: p.state?.status === 'error', tool: p.tool });
+  }
+  return assembleSignals(shellCalls);
+}
+
+export const opencode = {
+  name: 'opencode',
+
+  detect() {
+    return existsSync(DB_PATH);
+  },
+
+  // Cross-host distill: shell command TEXT + status enum from SQLite parts.
+  mineSignals(ref) {
+    try {
+      const dbPath = ref?.db || DB_PATH;
+      const sid = ref?.sessionId || ref;
+      if (!existsSync(dbPath)) return emptySignals();
+      const db = openDb(dbPath);
+      try {
+        const parts = db
+          .prepare('SELECT time_created, data FROM part WHERE session_id = ? ORDER BY time_created')
+          .all(sid)
+          .map((p) => {
+            const d = JSON.parse(p.data);
+            return { time_created: p.time_created, type: d.type, tool: d.tool, state: d.state };
+          });
+        return signalsFromParts(parts);
+      } finally {
+        db.close();
+      }
+    } catch {
+      return emptySignals();
+    }
+  },
+
+  listSessions() {
+    if (!existsSync(DB_PATH)) return [];
+    const db = openDb(DB_PATH);
+    try {
+      return db
+        .prepare('SELECT id, title, time_updated FROM session ORDER BY time_updated DESC')
+        .all()
+        .map((r) => ({ sessionId: r.id, ref: { db: DB_PATH, sessionId: r.id }, label: r.title || 'opencode', mtime: r.time_updated }));
+    } finally {
+      db.close();
+    }
+  },
+
+  parse(ref) {
+    const dbPath = ref?.db || DB_PATH;
+    const sid = ref?.sessionId || ref;
+    const db = openDb(dbPath);
+    try {
+      const session = db.prepare('SELECT id, directory, title, model, time_created, time_updated FROM session WHERE id = ?').get(sid);
+      if (!session) throw new Error(`opencode session not found: ${sid}`);
+      const messages = db
+        .prepare('SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created')
+        .all(sid)
+        .map((m) => ({ id: m.id, time_created: m.time_created, role: JSON.parse(m.data).role }));
+      const parts = db
+        .prepare('SELECT message_id, time_created, data FROM part WHERE session_id = ? ORDER BY time_created')
+        .all(sid)
+        .map((p) => {
+          const d = JSON.parse(p.data);
+          return { messageId: p.message_id, time_created: p.time_created, type: d.type, text: d.text, tool: d.tool, callID: d.callID, state: d.state };
+        });
+      return buildTrace({ session, messages, parts });
+    } finally {
+      db.close();
+    }
+  },
+};

package/experiments/experiment-1-trace-capture/adapters/pi.mjs

@@ -0,0 +1,218 @@
+// pi CLI adapter — parses ~/.pi/agent/sessions/<slug>/*.jsonl.
+//
+// Built against REAL wire data (a captured `pi` probe session), not docs.
+// Confirmed shapes (one JSON object per line):
+//   { type:"session", version:3, id, timestamp, cwd }      → the session header (line 1)
+//   { type:"model_change", id, parentId, timestamp, provider, modelId }
+//   { type:"thinking_level_change", id, parentId, timestamp, thinkingLevel }   (metadata)
+//   { type:"message", id, parentId, timestamp, message:{ role, content:[…], … } }
+//       role "user"       → content [{ type:"text", text }]            (the prompt → a TURN)
+//       role "assistant"  → content [{ type:"thinking", … } | { type:"text", text }
+//                                    | { type:"toolCall", id, name, arguments }]  (toolCall → a TOOL span)
+//       role "toolResult" → { toolCallId, toolName, content:[{type:"text",text}], isError }
+//
+// Tool spans pair the assistant's content.toolCall to its toolResult message by
+// toolCall.id === toolResult.message.toolCallId, giving real durations + an
+// isError → Status.ERROR flag. Turns come from role:"user" messages (clean prompt).
+
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { existsSync, readdirSync, statSync, readFileSync } from 'node:fs';
+import { event, trace, EventKind, Status } from '../core/event.mjs';
+import { assembleSignals, emptySignals } from './signals.mjs';
+
+const SESSIONS_DIR = join(homedir(), '.pi', 'agent', 'sessions');
+
+// pi shell tool (real-wire): assistant content[].toolCall name "bash",
+// arguments.command (an object, not a JSON string); paired toolResult.isError.
+const PI_SHELL = new Set(['bash', 'shell']);
+function piCmdText(args) {
+  const a = typeof args === 'string' ? (() => { try { return JSON.parse(args); } catch { return {}; } })() : args ?? {};
+  if (typeof a.command === 'string') return a.command;
+  if (Array.isArray(a.command)) return a.command.join(' ');
+  if (typeof a.cmd === 'string') return a.cmd;
+  return '';
+}
+const ms = (iso) => (iso ? Date.parse(iso) : NaN);
+const clean = (s) => String(s).replace(/\s+/g, ' ').trim();
+const truncate = (s, n) => (s.length > n ? s.slice(0, n - 1) + '…' : s);
+
+function readJsonl(file) {
+  return readFileSync(file, 'utf8')
+    .split('\n')
+    .filter(Boolean)
+    .map((l) => {
+      try {
+        return JSON.parse(l);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+// First [{type:"text"}] item's text, joined — pi content is an array of parts.
+function textOf(content) {
+  if (!Array.isArray(content)) return '';
+  return content
+    .filter((c) => c && c.type === 'text' && typeof c.text === 'string')
+    .map((c) => c.text)
+    .join(' ');
+}
+
+export const pi = {
+  name: 'pi',
+
+  detect() {
+    return existsSync(SESSIONS_DIR);
+  },
+
+  listSessions() {
+    if (!existsSync(SESSIONS_DIR)) return [];
+    return readdirSync(SESSIONS_DIR, { recursive: true })
+      .filter((f) => typeof f === 'string' && /\.jsonl$/.test(f))
+      .map((f) => {
+        const path = join(SESSIONS_DIR, f);
+        // filename: <iso>_<uuid>.jsonl — fall back to the uuid for the id.
+        const m = f.match(/([0-9a-f-]{36})\.jsonl$/i);
+        return { sessionId: m ? m[1] : f, ref: path, label: 'pi', mtime: statSync(path).mtimeMs };
+      })
+      .sort((a, b) => b.mtime - a.mtime);
+  },
+
+  // Cross-host distill: shell command TEXT + isError flag from the raw jsonl.
+  mineSignals(ref) {
+    try {
+      const file = typeof ref === 'string' ? ref : ref.ref;
+      const rows = readJsonl(file);
+      const errors = new Map(); // toolCallId -> isError
+      for (const r of rows) {
+        if (r.type !== 'message') continue;
+        const m = r.message || {};
+        if (m.role === 'toolResult' && m.toolCallId) errors.set(m.toolCallId, !!m.isError);
+      }
+      const shellCalls = [];
+      for (const r of rows) {
+        if (r.type !== 'message') continue;
+        const m = r.message || {};
+        if (m.role !== 'assistant' || !Array.isArray(m.content)) continue;
+        for (const c of m.content) {
+          if (!c || c.type !== 'toolCall' || !PI_SHELL.has(c.name)) continue;
+          const cmd = piCmdText(c.arguments);
+          if (cmd) shellCalls.push({ cmd, failed: errors.get(c.id) === true, tool: c.name });
+        }
+      }
+      return assembleSignals(shellCalls);
+    } catch {
+      return emptySignals();
+    }
+  },
+
+  parse(ref) {
+    const file = typeof ref === 'string' ? ref : ref.ref;
+    const rows = readJsonl(file);
+
+    const header = rows.find((r) => r.type === 'session') || {};
+    let sessionId = header.id || '';
+    const meta = { startMs: Infinity, endMs: -Infinity, model: '', cwd: header.cwd || '' };
+
+    // Pass 1: index toolResult messages by toolCallId (end time + size + error flag).
+    const results = new Map();
+    for (const r of rows) {
+      if (r.type !== 'message') continue;
+      const m = r.message || {};
+      if (m.role === 'toolResult' && m.toolCallId) {
+        const out = textOf(m.content);
+        results.set(m.toolCallId, { endMs: ms(r.timestamp), bytes: out.length, isError: !!m.isError });
+      }
+    }
+
+    // Pass 2: walk in order; turns from user messages, tools from assistant toolCalls.
+    const events = [];
+    const turnEnd = new Map();
+    let currentTurn = null;
+    let turnIdx = 0;
+
+    for (const r of rows) {
+      const t = ms(r.timestamp);
+      if (Number.isFinite(t)) {
+        meta.startMs = Math.min(meta.startMs, t);
+        meta.endMs = Math.max(meta.endMs, t);
+      }
+      if (r.type === 'model_change') meta.model ||= r.modelId || '';
+      if (r.type !== 'message') continue;
+
+      const m = r.message || {};
+
+      if (m.role === 'user') {
+        const text = clean(textOf(m.content));
+        const refId = r.id || `${sessionId || 'pi'}:turn:${turnIdx}`;
+        currentTurn = refId;
+        turnIdx++;
+        events.push(
+          event({
+            kind: EventKind.TURN,
+            refId,
+            parentRefId: sessionId || 'session',
+            name: 'turn: ' + (truncate(text, 60) || '(empty)'),
+            startMs: Number.isFinite(t) ? t : meta.startMs,
+            endMs: Number.isFinite(t) ? t : meta.startMs,
+            attributes: { 'turn.prompt.bytes': text.length },
+          }),
+        );
+      }
+
+      if (m.role === 'assistant' && Array.isArray(m.content)) {
+        for (const c of m.content) {
+          if (!c || c.type !== 'toolCall') continue;
+          const res = results.get(c.id) || {};
+          const startMs = Number.isFinite(t) ? t : meta.startMs;
+          const endMs = Number.isFinite(res.endMs) ? res.endMs : startMs;
+          const args = typeof c.arguments === 'string' ? c.arguments : JSON.stringify(c.arguments ?? {});
+          const parent = currentTurn || sessionId || 'session';
+          events.push(
+            event({
+              kind: EventKind.TOOL_CALL,
+              refId: c.id || `${sessionId}:call:${events.length}`,
+              parentRefId: parent,
+              name: 'tool: ' + (c.name || 'tool'),
+              startMs,
+              endMs,
+              status: res.isError ? Status.ERROR : Status.OK,
+              attributes: {
+                'gen_ai.operation.name': 'execute_tool',
+                'gen_ai.tool.name': c.name || '',
+                'host.tool.name': c.name || '',
+                'tool.input.bytes': args.length,
+                'tool.result.bytes': res.bytes ?? 0,
+              },
+            }),
+          );
+          turnEnd.set(parent, Math.max(turnEnd.get(parent) ?? 0, endMs));
+        }
+      }
+    }
+
+    sessionId ||= (file.match(/([0-9a-f-]{36})\.jsonl$/i) || [])[1] || file.split('/').pop();
+    if (!Number.isFinite(meta.startMs)) meta.startMs = ms(header.timestamp) || 0;
+    if (!Number.isFinite(meta.endMs)) meta.endMs = meta.startMs;
+
+    for (const e of events) {
+      if (e.kind === EventKind.TURN && turnEnd.has(e.refId)) e.endMs = Math.max(e.endMs, turnEnd.get(e.refId));
+    }
+
+    events.unshift(
+      event({
+        kind: EventKind.SESSION,
+        refId: sessionId,
+        parentRefId: null,
+        name: `session ${String(sessionId).slice(0, 8)} (pi)`,
+        startMs: meta.startMs,
+        endMs: meta.endMs,
+        attributes: { 'host.name': 'pi', 'host.session.model': meta.model, 'host.cwd': meta.cwd },
+      }),
+    );
+
+    return trace({ host: 'pi', sessionId: String(sessionId), title: meta.cwd, events });
+  },
+};

package/experiments/experiment-1-trace-capture/adapters/registry.mjs

@@ -0,0 +1,20 @@
+// Adapter registry. Routes by capability/detection, never by host name baked into
+// the core. Adding a host = add an adapter here; nothing else changes.
+
+import { assertAdapter } from './host-adapter.mjs';
+import { claudeCode } from './claude-code.mjs';
+import { geminiCli } from './gemini-cli.mjs';
+import { codex } from './codex.mjs';
+import { opencode } from './opencode.mjs';
+import { pi } from './pi.mjs';
+
+export const ADAPTERS = [claudeCode, geminiCli, codex, opencode, pi].map(assertAdapter);
+
+export function byName(name) {
+  return ADAPTERS.find((a) => a.name === name) || null;
+}
+
+/** Adapters whose host has on-disk data right now. */
+export function detected() {
+  return ADAPTERS.filter((a) => a.detect());
+}

package/experiments/experiment-1-trace-capture/adapters/signals.mjs

@@ -0,0 +1,44 @@
+// Shared cross-host signal-mining helpers.
+//
+// CROSS-HOST DISTILL: each adapter's `mineSignals(ref)` extracts the SAME shape
+// as the Claude miner (`{commands, files, failures, sequences, correctionTurns,
+// destructiveFailures}`) from that host's RAW transcript — command TEXT + a
+// failed flag + adjacent-command 2-gram sequences + destructive-failure shapes.
+// The aggregation thresholds live in `mns/knowledge/distill.mjs`; this is the
+// per-host extraction primitives, factored here so every adapter shares one
+// `norm`, one destructive-shape set, and one assembler (DRY, real-wire-built).
+
+export const norm = (cmd) => String(cmd).trim().replace(/\s+/g, ' ').slice(0, 200);
+
+const SEQ_SEP = ' && '; // joins adjacent shell commands into a 2-gram label
+const DESTRUCTIVE_SHAPES = [/\brm\s+-[a-z]*r/, /git\s+push\s+.*--force/, /DROP\s+TABLE/i, /chmod\s+-R/];
+export const isDestructive = (cmd) => DESTRUCTIVE_SHAPES.some((re) => re.test(cmd));
+
+/** The empty superset — what an unminable / malformed / prompt-only host returns. */
+export function emptySignals() {
+  return { commands: [], files: [], failures: [], sequences: [], correctionTurns: [], destructiveFailures: [] };
+}
+
+/**
+ * Assemble the signal superset from an ordered list of shell tool calls.
+ * @param {Array<{cmd:string, failed:boolean, tool?:string}>} shellCalls — in transcript order
+ * @returns the {commands, files, failures, sequences, correctionTurns, destructiveFailures} shape
+ */
+export function assembleSignals(shellCalls) {
+  const out = emptySignals();
+  const order = [];
+  for (const call of shellCalls) {
+    const cmd = norm(call.cmd);
+    if (!cmd) continue;
+    const failed = !!call.failed;
+    const tool = call.tool || 'bash';
+    out.commands.push({ cmd, failed });
+    order.push(cmd);
+    if (failed) {
+      out.failures.push(tool);
+      if (isDestructive(cmd)) out.destructiveFailures.push({ cmd, tool });
+    }
+  }
+  for (let i = 0; i + 1 < order.length; i++) out.sequences.push(order[i] + SEQ_SEP + order[i + 1]);
+  return out;
+}