@zuzuucodes/cli 1.0.0

package/zuzuu/faculty/proposal.mjs

@@ -0,0 +1,166 @@
+// zuzuu/faculty/proposal.mjs
+// Unified Proposal record for the faculty spine (WS2-T1).
+// Mirrors zuzuu/knowledge/proposals.mjs's id scheme (<slug>-<shortHash(slug+source)>)
+// and extends it to be faculty-agnostic.
+//
+// Dual-read: transparently normalises legacy {candidate, er} → {payload, analysis}
+// so old knowledge proposals are readable without a migration step.
+
+import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, readdirSync, mkdirSync, renameSync } from 'node:fs';
+import { createHash } from 'node:crypto';
+import { proposalsDir, archiveDir } from './contract.mjs';
+
+// ---------------------------------------------------------------------------
+// internal helpers
+// ---------------------------------------------------------------------------
+const shortHash = (s) => createHash('sha256').update(s).digest('hex').slice(0, 6);
+
+/** Normalise a raw JSON object from disk (handles legacy candidate/er keys). */
+function normalise(raw, faculty) {
+  if (!raw) return null;
+  const rec = { ...raw };
+  // faculty: always set (default to the arg if absent)
+  if (!rec.faculty) rec.faculty = faculty;
+  // dual-read: map legacy `candidate` → `payload`
+  if (!rec.payload && rec.candidate !== undefined) {
+    rec.payload = rec.candidate;
+  }
+  // dual-read: map legacy `er` → `analysis.er`
+  if (!rec.analysis && rec.er !== undefined) {
+    rec.analysis = { er: rec.er };
+  }
+  // ensure defaults
+  if (!rec.analysis) rec.analysis = {};
+  if (!rec.evidence) rec.evidence = {};
+  if (!rec.provenance) rec.provenance = [];
+  return rec;
+}
+
+// ---------------------------------------------------------------------------
+// public API
+// ---------------------------------------------------------------------------
+
+/**
+ * Deterministic proposal id: `<slug>-<shortHash(slug + source)>`.
+ * Replicates the scheme in zuzuu/knowledge/proposals.mjs exactly.
+ */
+export function proposalId(slug, source) {
+  return `${slug}-${shortHash(slug + source)}`;
+}
+
+/**
+ * Build a proposal record object (does not write to disk).
+ * Defaults: analysis={}, evidence={}, provenance=[].
+ */
+export function makeProposal({ faculty, kind, source, payload, analysis = {}, evidence = {}, provenance = [] }) {
+  const slug = (payload && payload.id) ? payload.id : kind;
+  const id = proposalId(slug, source);
+  return {
+    id,
+    faculty,
+    kind,
+    status: 'pending',
+    created_at: new Date().toISOString(),
+    source,
+    payload: payload ?? {},
+    analysis,
+    evidence,
+    provenance,
+  };
+}
+
+/**
+ * Write a proposal record to `agent/<faculty>/proposals/<id>.json`.
+ * Creates directories as needed. Returns the written path.
+ */
+export function writeProposal(agentDir, proposal) {
+  const dir = proposalsDir(agentDir, proposal.faculty);
+  mkdirSync(dir, { recursive: true });
+  const path = join(dir, `${proposal.id}.json`);
+  writeFileSync(path, JSON.stringify(proposal, null, 2) + '\n');
+  return path;
+}
+
+/**
+ * Read and normalise a single proposal by faculty + id.
+ * Returns null if the file does not exist (never throws).
+ */
+export function readProposal(agentDir, faculty, id) {
+  const path = join(proposalsDir(agentDir, faculty), `${id}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return normalise(JSON.parse(readFileSync(path, 'utf8')), faculty);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * List all pending proposals for a faculty (files in proposals/ not in archive/).
+ * Normalises each record. Skips unreadable files (fail-soft).
+ */
+export function listProposals(agentDir, faculty) {
+  const dir = proposalsDir(agentDir, faculty);
+  if (!existsSync(dir)) return [];
+  return readdirSync(dir)
+    .filter((f) => f.endsWith('.json'))
+    .map((f) => {
+      try {
+        return normalise(JSON.parse(readFileSync(join(dir, f), 'utf8')), faculty);
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean)
+    .sort((a, b) => String(a.created_at).localeCompare(String(b.created_at)));
+}
+
+/**
+ * Move a proposal from pending into archive/ with a resolved status.
+ * @param {string} status - 'approved' | 'rejected'
+ * @param {string} [reason] - human-readable reason
+ * @param {string} [applied] - what was done on approval
+ * @returns the resolved record
+ */
+export function archiveProposal(agentDir, faculty, id, { status, reason = '', applied = '' } = {}) {
+  const pending = join(proposalsDir(agentDir, faculty), `${id}.json`);
+  const archDir = archiveDir(agentDir, faculty);
+  mkdirSync(archDir, { recursive: true });
+
+  // read & normalise the pending record (or whatever we can find)
+  let proposal;
+  if (existsSync(pending)) {
+    try {
+      proposal = normalise(JSON.parse(readFileSync(pending, 'utf8')), faculty);
+    } catch {
+      proposal = { id, faculty };
+    }
+  } else {
+    proposal = { id, faculty };
+  }
+
+  const resolved = {
+    ...proposal,
+    status,
+    resolved_at: new Date().toISOString(),
+    reason,
+    applied,
+  };
+
+  const archPath = join(archDir, `${id}.json`);
+  writeFileSync(archPath, JSON.stringify(resolved, null, 2) + '\n');
+
+  // remove the pending file (rename is atomic; fall back to just leaving archive)
+  if (existsSync(pending)) {
+    try {
+      renameSync(pending, archPath);
+      // re-write with resolved fields (rename replaces content, so write again)
+      writeFileSync(archPath, JSON.stringify(resolved, null, 2) + '\n');
+    } catch {
+      // archive already written above; ignore rename failure
+    }
+  }
+
+  return resolved;
+}

package/zuzuu/faculty/provenance.mjs

@@ -0,0 +1,35 @@
+// zuzuu/faculty/provenance.mjs
+// Lightweight provenance helpers for the faculty spine.
+// A provenance entry is { session, trace, ref } (all optional fields).
+
+/**
+ * Build a provenance entry, dropping any undefined keys.
+ * @param {{ session?: string, trace?: string, ref?: string }} opts
+ * @returns {{ session?: string, trace?: string, ref?: string }}
+ */
+export function prov({ session, trace, ref } = {}) {
+  const entry = {};
+  if (session !== undefined) entry.session = session;
+  if (trace !== undefined) entry.trace = trace;
+  if (ref !== undefined) entry.ref = ref;
+  return entry;
+}
+
+/**
+ * Merge two provenance arrays, deduplicating by `${session}|${ref}`.
+ * @param {Array} [a=[]]
+ * @param {Array} [b=[]]
+ * @returns {Array}
+ */
+export function mergeProvenance(a = [], b = []) {
+  const seen = new Set();
+  const result = [];
+  for (const entry of [...a, ...b]) {
+    const key = `${entry.session ?? ''}|${entry.ref ?? ''}`;
+    if (!seen.has(key)) {
+      seen.add(key);
+      result.push(entry);
+    }
+  }
+  return result;
+}

package/zuzuu/faculty/registry.mjs

@@ -0,0 +1,33 @@
+// zuzuu/faculty/registry.mjs
+// Faculty adapter registry — a module-level Map keyed by adapter.name.
+// Adapters register themselves on import; consumers query by name or list all.
+//
+// This is the registration surface only. Adapters are added in later work units.
+
+/** @type {Map<string, object>} */
+const _registry = new Map();
+
+/**
+ * Register an adapter (keyed by adapter.name). Overwrites if already registered.
+ * @param {{ name: string, [key: string]: any }} adapter
+ */
+export function register(adapter) {
+  _registry.set(adapter.name, adapter);
+}
+
+/**
+ * Retrieve a registered adapter by name. Returns undefined if not found.
+ * @param {string} name
+ * @returns {{ name: string, [key: string]: any } | undefined}
+ */
+export function get(name) {
+  return _registry.get(name);
+}
+
+/**
+ * Return all registered adapters as an array.
+ * @returns {Array<{ name: string, [key: string]: any }>}
+ */
+export function all() {
+  return [..._registry.values()];
+}

package/zuzuu/faculty/trail.mjs

@@ -0,0 +1,27 @@
+// zuzuu/faculty/trail.mjs
+// Generalised faculty observability trail (WS2-T1).
+// Extends the pattern from zuzuu/actions/trail.mjs to any faculty:
+// each faculty gets its own agent/.live/<faculty>.jsonl file.
+//
+// Fail-soft: a logging failure must never affect the caller.
+
+import { join } from 'node:path';
+import { mkdirSync, appendFileSync } from 'node:fs';
+import { liveDir } from '../store.mjs';
+
+/**
+ * Append a trail entry for a faculty. Never throws.
+ * @param {string} agentDir  - path to the faculty home (agent/)
+ * @param {string} faculty - e.g. 'knowledge', 'actions', 'guardrails'
+ * @param {object} entry   - arbitrary fields; `at` is stamped automatically
+ */
+export function recordTrail(agentDir, faculty, entry = {}) {
+  try {
+    const dir = liveDir(agentDir);
+    mkdirSync(dir, { recursive: true });
+    const rec = { at: new Date().toISOString(), ...entry };
+    appendFileSync(join(dir, `${faculty}.jsonl`), JSON.stringify(rec) + '\n');
+  } catch {
+    /* logging must never affect the caller */
+  }
+}

package/zuzuu/guardrails/adapter.mjs

@@ -0,0 +1,134 @@
+// zuzuu/guardrails/adapter.mjs
+// The Guardrails faculty adapter (WS2-T4). Wraps the rules engine behind the
+// faculty-spine adapter contract — { name, ingest, validate, apply, render } —
+// so `zuzuu review` can surface and approve/reject rule proposals the same way it
+// does Knowledge proposals.
+//
+// A guardrails proposal payload is a single rule record:
+//   { id, action: deny|ask|allow, tool, pattern, reason }
+//
+// apply: loads agent/guardrails/rules.json (seeding {version:1,rules:[]} if
+//        absent), appends the rule or replaces an existing one with the same id,
+//        then writes the file back.
+//
+// Registers itself on import.
+
+import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import * as registry from '../faculty/registry.mjs';
+
+const name = 'guardrails';
+const VALID_ACTIONS = new Set(['deny', 'ask', 'allow']);
+
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+
+function rulesPath(agentDir) {
+  return join(agentDir, 'guardrails', 'rules.json');
+}
+
+function loadRulesFile(agentDir) {
+  const path = rulesPath(agentDir);
+  if (!existsSync(path)) return { version: 1, rules: [] };
+  try {
+    return JSON.parse(readFileSync(path, 'utf8'));
+  } catch {
+    return { version: 1, rules: [] };
+  }
+}
+
+// ---------------------------------------------------------------------------
+// adapter contract
+// ---------------------------------------------------------------------------
+
+/**
+ * Ingest a raw rule object. Pass-through: rule fields are the payload.
+ * @param {string} agentDir
+ * @param {object} raw  — expected shape: { id, action, tool, pattern, reason }
+ *                         or { payload: { ... } } from the spine
+ */
+function ingest(_agentDir, raw) {
+  const payload = raw?.payload ?? raw ?? {};
+  return { payload, analysis: {}, dedupeKey: payload.id };
+}
+
+/**
+ * Validate a rule payload.
+ * @returns {{ok:boolean, errors:string[], warnings:string[]}}
+ */
+function validate(_agentDir, payload) {
+  const errors = [];
+  if (!payload?.id || typeof payload.id !== 'string' || !payload.id.trim()) {
+    errors.push('rule id is required (non-empty string slug)');
+  }
+  if (!VALID_ACTIONS.has(payload?.action)) {
+    errors.push(`action must be one of deny|ask|allow (got '${payload?.action}')`);
+  }
+  if (!payload?.tool || typeof payload.tool !== 'string') {
+    errors.push('tool is required (exact tool name or \'*\')');
+  }
+  if (typeof payload?.pattern !== 'string' || !payload.pattern) {
+    errors.push('pattern is required (a non-empty regex string)');
+  } else {
+    try {
+      new RegExp(payload.pattern); // eslint-disable-line no-new
+    } catch (e) {
+      errors.push(`pattern does not compile as a RegExp: ${e.message}`);
+    }
+  }
+  if (!payload?.reason || !String(payload.reason).trim()) {
+    errors.push('reason is required (non-empty)');
+  }
+  return { ok: errors.length === 0, errors, warnings: [] };
+}
+
+/**
+ * Apply an approved rule proposal: upsert into rules.json.
+ * @returns {{ok:boolean, action:string, itemIds:string[]}}
+ */
+function apply(agentDir, proposal) {
+  const rule = proposal?.payload ?? {};
+  const id = rule.id;
+
+  // Ensure the guardrails dir exists
+  mkdirSync(join(agentDir, 'guardrails'), { recursive: true });
+
+  const data = loadRulesFile(agentDir);
+  if (!Array.isArray(data.rules)) data.rules = [];
+
+  const idx = data.rules.findIndex((r) => r.id === id);
+  // Store only the canonical fields (id, action, tool, pattern, reason)
+  const entry = {
+    id: rule.id,
+    action: rule.action,
+    tool: rule.tool,
+    pattern: rule.pattern,
+    reason: rule.reason,
+  };
+  if (idx >= 0) {
+    data.rules[idx] = entry;
+  } else {
+    data.rules.push(entry);
+  }
+
+  writeFileSync(rulesPath(agentDir), JSON.stringify(data, null, 2) + '\n');
+  return { ok: true, action: `added rule ${id}`, itemIds: [id] };
+}
+
+/**
+ * Render a rule proposal for the human gate.
+ * @returns {{line:string, card:string}}
+ */
+function render(proposal) {
+  const r = proposal?.payload ?? {};
+  const summary = `${r.action ?? '?'} ${r.tool ?? '*'} /${r.pattern ?? ''}/ — ${r.reason ?? ''}`;
+  return {
+    line: `${r.id ?? ''}  [rule]  ${summary}`,
+    card: summary,
+  };
+}
+
+export const adapter = { name, ingest, validate, apply, render };
+
+registry.register(adapter);

package/zuzuu/guardrails.mjs

@@ -0,0 +1,89 @@
+// The Guardrails faculty — v1 rule engine (pure; I/O lives in the hook command).
+//
+// Rules are DATA, not code: agent/guardrails/rules.json, ordered, declarative —
+// a *definition* in the pin-definitions sense (versioned in git, graduates via
+// proposals like every faculty's contents).
+//
+//   { "version": 1,
+//     "rules": [ { "id": "no-root-wipe", "action": "deny",
+//                  "tool": "Bash",              // exact tool name, or "*"
+//                  "pattern": "rm\\s+-rf\\s+/", // regex over the tool INPUT (stringified)
+//                  "reason": "destructive root delete" } ] }
+//
+// Evaluation: collect every matching rule, then severity wins — deny > ask >
+// allow (an explicit allow can whitelist past a later ask/deny only if it is
+// NOT outweighed; severity beats file order so a sloppy rule ordering can never
+// silently disarm a deny).
+//
+// FAIL-OPEN: any malformed rule/file yields { ok:false } and no decision — the
+// host proceeds through its normal permission flow. A guardrail bug must never
+// brick the agent; misses are logged, not fatal.
+
+import { readFileSync } from 'node:fs';
+
+const SEVERITY = { deny: 3, ask: 2, allow: 1 };
+const ACTIONS = new Set(Object.keys(SEVERITY));
+
+/** Parse + validate a rules file. Fail-open: returns ok:false on any problem. */
+export function loadRules(path) {
+  try {
+    const data = JSON.parse(readFileSync(path, 'utf8'));
+    if (!Array.isArray(data.rules)) return { ok: false, rules: [], error: 'rules is not an array' };
+    const rules = [];
+    for (const r of data.rules) {
+      if (!r || typeof r !== 'object' || !ACTIONS.has(r.action) || typeof r.pattern !== 'string') {
+        return { ok: false, rules: [], error: `malformed rule: ${JSON.stringify(r).slice(0, 80)}` };
+      }
+      try {
+        rules.push({ id: String(r.id ?? `rule-${rules.length}`), action: r.action, tool: r.tool || '*', re: new RegExp(r.pattern, 'i'), reason: String(r.reason ?? '') });
+      } catch (e) {
+        return { ok: false, rules: [], error: `bad pattern in ${r.id}: ${e.message}` };
+      }
+    }
+    return { ok: true, rules };
+  } catch (e) {
+    return { ok: false, rules: [], error: e.message };
+  }
+}
+
+/**
+ * Evaluate a tool call against loaded rules.
+ * @param {Array} rules        from loadRules().rules
+ * @param {{tool:string, input:any}} call
+ * @returns {null | {action:'deny'|'ask'|'allow', rule:string, reason:string}}
+ *          null = no rule matched → defer to the host's normal permission flow
+ */
+export function evaluate(rules, { tool, input }) {
+  const haystack = typeof input === 'string' ? input : JSON.stringify(input ?? {});
+  let winner = null;
+  for (const r of rules) {
+    if (r.tool !== '*' && r.tool !== tool) continue;
+    if (!r.re.test(haystack)) continue;
+    if (!winner || SEVERITY[r.action] > SEVERITY[winner.action]) {
+      winner = { action: r.action, rule: r.id, reason: r.reason || `matched guardrail ${r.id}` };
+    }
+  }
+  return winner;
+}
+
+/**
+ * Gemini CLI block shape: stdout JSON { decision: "deny", reason } (exit 0).
+ * Gemini has no "ask" decision → defer (null) so its own approval flow runs.
+ * Only an explicit deny blocks.
+ */
+export function toGeminiDecision(verdict) {
+  if (!verdict || verdict.action !== 'deny') return null;
+  return { decision: 'deny', reason: `guardrail ${verdict.rule}: ${verdict.reason}` };
+}
+
+/** Map a verdict to Claude Code's PreToolUse hookSpecificOutput (verified schema). */
+export function toPreToolUseDecision(verdict) {
+  if (!verdict || verdict.action === 'allow') return null; // no output → normal flow (fail-open / explicit allow)
+  return {
+    hookSpecificOutput: {
+      hookEventName: 'PreToolUse',
+      permissionDecision: verdict.action, // 'deny' | 'ask'
+      permissionDecisionReason: `guardrail ${verdict.rule}: ${verdict.reason}`,
+    },
+  };
+}

package/zuzuu/inject.mjs

@@ -0,0 +1,46 @@
+// Delimiter-block injection for host instruction files (CLAUDE.md / AGENTS.md /
+// GEMINI.md) — the supermemory coexistence pattern: our content lives between
+// versioned markers; injecting again replaces OUR block only and never touches
+// the user's surrounding text. Pure string functions; I/O stays in the command.
+
+const BEGIN = (v) => `<!-- >>> zuzuu:faculties:v${v} >>> -->`;
+const END = '<!-- <<< zuzuu:faculties <<< -->';
+// Matches our block at ANY version, so an older block is replaced in place by
+// the current `zuzuu:faculties` block — never duplicated.
+const BLOCK_RE = /[ \t]*<!-- >>> zuzuu:faculties:v\d+ >>> -->[\s\S]*?<!-- <<< zuzuu:faculties <<< -->[ \t]*\n?/;
+
+export const BLOCK_VERSION = 8;
+
+/** The block content served to host agents. Keep short — it's steering, not docs. */
+export function facultiesBlock(version = BLOCK_VERSION) {
+  return `${BEGIN(version)}
+## zuzuu — agent faculty home
+
+This project has a zuzuu faculty home at \`agent/\` (managed by the zuzuu CLI). Work to this contract:
+
+- **Ground.** At session start, read \`agent/.live/digest.md\` if it exists — your *zuzuu digest* (instructions, knowledge, actions, proposals, guardrails), regenerated each session. Trust it as ground truth; don't re-derive what it states or re-read faculty files it already summarized. (On Claude Code the same brief also arrives inline at session start.)
+- **Cite in-flight.** When an answer draws on a stored fact, say \`from knowledge: <id>\`; when you follow a runbook/action, name it. Make the faculty visible.
+- **Harvest at close.** Before ending, propose durable learnings as one-fact files in \`agent/knowledge/inbox/\` (plain text is fine), and propose any reusable procedure with \`zuzuu act propose <slug>\` (it lands in \`actions/inbox/\`). A human reviews both via \`zuzuu review\`. Never write \`knowledge/items/\` or active \`actions/\` directly.
+- **Respect \`agent/guardrails/\`** — hard rules, *enforced* on tool calls by the zuzuu gate; a refusal there is policy, not preference.
+- Do **not** read \`agent/.traces/\` or \`agent/.live/\` (zuzuu observability internals) — **except \`agent/.live/digest.md\`, which is written for you.**
+${END}`;
+}
+
+export function hasBlock(text) {
+  return BLOCK_RE.test(text);
+}
+
+/**
+ * Insert or replace our block in `text`. User content is never modified:
+ * existing block → replaced in place; no block → appended with one blank line.
+ */
+export function injectBlock(text, block = facultiesBlock()) {
+  if (hasBlock(text)) return text.replace(BLOCK_RE, block + '\n');
+  const sep = text.length === 0 ? '' : text.endsWith('\n\n') ? '' : text.endsWith('\n') ? '\n' : '\n\n';
+  return text + sep + block + '\n';
+}
+
+/** Remove our block (for the future `zuzuu deinit`); user content untouched. */
+export function removeBlock(text) {
+  return text.replace(BLOCK_RE, '');
+}

package/zuzuu/instructions/adapter.mjs

@@ -0,0 +1,93 @@
+// zuzuu/instructions/adapter.mjs
+// The Instructions faculty adapter (WS2-T4). Wraps steering-amendment proposals
+// behind the faculty-spine adapter contract — { name, ingest, validate, apply,
+// render } — so `zuzuu review` can surface and approve them uniformly.
+//
+// An instructions proposal payload is a steering amendment:
+//   { text }  — a line or paragraph to append to project.md
+//
+// apply: appends the text as a line to agent/instructions/project.md (creates
+//        the file if absent; never duplicates an already-present line).
+//
+// Registers itself on import.
+
+import { join } from 'node:path';
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+import * as registry from '../faculty/registry.mjs';
+
+const name = 'instructions';
+
+// ---------------------------------------------------------------------------
+// helpers
+// ---------------------------------------------------------------------------
+
+function projectMdPath(agentDir) {
+  return join(agentDir, 'instructions', 'project.md');
+}
+
+// ---------------------------------------------------------------------------
+// adapter contract
+// ---------------------------------------------------------------------------
+
+/**
+ * Ingest a raw amendment object. Pass-through: the payload IS the amendment.
+ */
+function ingest(_agentDir, raw) {
+  const payload = raw?.payload ?? raw ?? {};
+  return { payload, analysis: {} };
+}
+
+/**
+ * Validate an amendment payload.
+ * @returns {{ok:boolean, errors:string[], warnings:string[]}}
+ */
+function validate(_agentDir, payload) {
+  const errors = [];
+  if (!payload?.text || !String(payload.text).trim()) {
+    errors.push('text is required (non-empty steering amendment)');
+  }
+  return { ok: errors.length === 0, errors, warnings: [] };
+}
+
+/**
+ * Apply an approved amendment: append text to project.md (idempotent on
+ * identical lines — won't duplicate a line already present).
+ * @returns {{ok:boolean, action:string, itemIds:string[]}}
+ */
+function apply(agentDir, proposal) {
+  const text = proposal?.payload?.text ?? '';
+
+  // Ensure the instructions dir exists
+  mkdirSync(join(agentDir, 'instructions'), { recursive: true });
+
+  const path = projectMdPath(agentDir);
+  const existing = existsSync(path) ? readFileSync(path, 'utf8') : '';
+
+  // Idempotence: skip if the exact text is already present
+  if (existing.includes(text)) {
+    return { ok: true, action: 'amended instructions (already present)', itemIds: [] };
+  }
+
+  // Append (with trailing newline)
+  const separator = existing && !existing.endsWith('\n') ? '\n' : '';
+  writeFileSync(path, existing + separator + text + '\n');
+
+  return { ok: true, action: 'amended instructions', itemIds: [] };
+}
+
+/**
+ * Render an amendment proposal for the human gate.
+ * @returns {{line:string, card:string}}
+ */
+function render(proposal) {
+  const text = proposal?.payload?.text ?? '';
+  const preview = text.slice(0, 80).replace(/\n/g, ' ');
+  return {
+    line: `[amendment]  ${preview}`,
+    card: text,
+  };
+}
+
+export const adapter = { name, ingest, validate, apply, render };
+
+registry.register(adapter);