@zuzuucodes/cli 1.5.0 → 1.6.0

package/zuzuu/faculty/generation.mjs

@@ -1,398 +0,0 @@
-// zuzuu/faculty/generation.mjs — the generation core (WS3-T1).
-//
-// A *generation* is an immutable, content-addressed snapshot of the agent's
-// pinned faculties (the lockfile). Minting freezes the current faculty state;
-// rollback restores any past generation by *content* (we copy each pinned item's
-// bytes into generations/snapshots/<id>/ at mint time, so a rollback works even
-// for items that were never committed). Identity: Agent → Generation → Run —
-// rollback = flip the active pointer + restore content; never `git revert`.
-//
-// Layout under .zuzuu/:
-//   generations/active             {active: "gen_NNN"}  — the live pointer
-//   generations/<id>.json          the lockfile (content-addressed manifest)
-//   generations/snapshots/<id>/<faculty>/...  pinned item bytes (rollback source)
-
-import { createHash } from 'node:crypto';
-import { join, dirname } from 'node:path';
-import {
-  existsSync, readFileSync, writeFileSync, readdirSync, statSync, mkdirSync, renameSync,
-} from 'node:fs';
-import { reindex } from '../knowledge/index.mjs';
-
-/** Hex sha256 of a string or Buffer. */
-export function sha256(buf) {
-  return createHash('sha256').update(buf).digest('hex');
-}
-
-const read = (p) => readFileSync(p, 'utf8');
-const readJson = (p) => JSON.parse(read(p));
-const writeJson = (p, obj) => {
-  mkdirSync(dirname(p), { recursive: true });
-  writeFileSync(p, JSON.stringify(obj, null, 2) + '\n');
-};
-
-// --- paths ------------------------------------------------------------------
-
-const generationsDir = (agentDir) => join(agentDir, 'generations');
-const snapshotsDir = (agentDir) => join(generationsDir(agentDir), 'snapshots');
-const activePath = (agentDir) => join(generationsDir(agentDir), 'active');
-const lockfilePath = (agentDir, id) => join(generationsDir(agentDir), `${id}.json`);
-const agentJsonPath = (agentDir) => join(agentDir, 'agent.json');
-
-// --- faculty file enumeration (the pinned set) ------------------------------
-// Each entry: { id, faculty, src (absolute live path), rel (path under the
-// faculty snapshot dir), hash }. `rel` is what we mirror into snapshots/<id>/.
-
-function sortDirents(dir) {
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir, { withFileTypes: true }).sort((a, b) => a.name.localeCompare(b.name));
-}
-
-function knowledgeFiles(agentDir) {
-  const dir = join(agentDir, 'knowledge', 'items');
-  return sortDirents(dir)
-    .filter((e) => e.isFile() && e.name.endsWith('.md'))
-    .map((e) => {
-      const src = join(dir, e.name);
-      return { id: e.name.replace(/\.md$/, ''), faculty: 'knowledge', src, rel: e.name, hash: sha256(readFileSync(src)) };
-    });
-}
-
-function actionFiles(agentDir) {
-  const dir = join(agentDir, 'actions');
-  return sortDirents(dir)
-    .filter((e) => e.isDirectory() && e.name !== 'inbox' && e.name !== 'proposals' && e.name !== '_rolledback')
-    .map((e) => {
-      const adir = join(dir, e.name);
-      // Hash the dir's defining files concatenated: the ACTION.md envelope
-      // (W24) + sibling scripts (*.mjs — run.mjs and any payload.exec module).
-      const parts = sortDirents(adir)
-        .filter((f) => f.isFile() && (f.name === 'ACTION.md' || f.name.endsWith('.mjs')))
-        .map((f) => join(adir, f.name));
-      const concat = Buffer.concat(parts.map((p) => readFileSync(p)));
-      return {
-        id: e.name, faculty: 'actions', files: parts.map((p) => p.slice(adir.length + 1)),
-        adir, hash: parts.length ? sha256(concat) : null,
-      };
-    });
-}
-
-/** Flat envelope-item faculties share one enumerator. */
-function mdItemFiles(agentDir, faculty, ...segments) {
-  const dir = join(agentDir, ...segments);
-  return sortDirents(dir)
-    .filter((e) => e.isFile() && e.name.endsWith('.md'))
-    .map((e) => {
-      const src = join(dir, e.name);
-      return { id: e.name.replace(/\.md$/, ''), faculty, src, rel: e.name, hash: sha256(readFileSync(src)) };
-    });
-}
-
-const guardrailFiles = (agentDir) => mdItemFiles(agentDir, 'guardrails', 'guardrails', 'items');
-const instructionFiles = (agentDir) => mdItemFiles(agentDir, 'instructions', 'instructions', 'items');
-
-function memoryFiles(agentDir) {
-  const dir = join(agentDir, 'memory', 'entries');
-  return sortDirents(dir)
-    .filter((e) => e.isFile() && e.name.endsWith('.md'))
-    .map((e) => {
-      const src = join(dir, e.name);
-      return { id: e.name.replace(/\.md$/, ''), faculty: 'memory', src, rel: e.name, hash: sha256(readFileSync(src)) };
-    });
-}
-
-function registryHash(agentDir) {
-  const dir = join(agentDir, 'knowledge', 'registry');
-  const files = sortDirents(dir).filter((e) => e.isFile() && e.name.endsWith('.json'));
-  if (!files.length) return null;
-  return sha256(Buffer.concat(files.map((e) => readFileSync(join(dir, e.name)))));
-}
-
-/**
- * Snapshot the current faculty state → the `faculties` manifest object.
- * Tolerates missing files (empty arrays / null hashes).
- */
-export function snapshotFaculties(agentDir) {
-  return {
-    knowledge: {
-      items: knowledgeFiles(agentDir).map(({ id, hash }) => ({ id, hash })),
-      registryHash: registryHash(agentDir),
-    },
-    actions: {
-      items: actionFiles(agentDir).map(({ id, hash }) => ({ id, hash })),
-    },
-    guardrails: {
-      items: guardrailFiles(agentDir).map(({ id, hash }) => ({ id, hash })),
-    },
-    instructions: {
-      items: instructionFiles(agentDir).map(({ id, hash }) => ({ id, hash })),
-    },
-    memory: {
-      items: memoryFiles(agentDir).map(({ id, hash }) => ({ id, hash })),
-    },
-  };
-}
-
-// --- agent identity ---------------------------------------------------------
-
-/** Stable agent id derived from the repo root: agt_<first12 of sha256(root)>. */
-export function agentId(agentDir) {
-  // agentDir is the .zuzuu/ dir; the repo root is its parent.
-  const root = dirname(agentDir);
-  return 'agt_' + sha256(root).slice(0, 12);
-}
-
-/** Add/repair the agent block in agent.json (bump to v2), preserving other fields. */
-export function ensureAgent(agentDir) {
-  const path = agentJsonPath(agentDir);
-  const m = existsSync(path) ? readJson(path) : {};
-  const id = agentId(agentDir);
-  if (!m.agent || !m.agent.id) {
-    m.agent = { id, createdAt: new Date().toISOString() };
-  }
-  m.version = 2;
-  writeJson(path, m);
-  return m.agent;
-}
-
-// --- generation read/list ---------------------------------------------------
-
-/** The active generation id, or null. */
-export function activeGeneration(agentDir) {
-  const p = activePath(agentDir);
-  if (!existsSync(p)) return null;
-  try { return readJson(p).active ?? null; } catch { return null; }
-}
-
-/** All generation ids in ascending order. */
-export function listGenerations(agentDir) {
-  const dir = generationsDir(agentDir);
-  if (!existsSync(dir)) return [];
-  return readdirSync(dir)
-    .filter((f) => /^gen_\d+\.json$/.test(f))
-    .map((f) => f.replace(/\.json$/, ''))
-    .sort();
-}
-
-/** Read one lockfile, or null. */
-export function readGeneration(agentDir, id) {
-  const p = lockfilePath(agentDir, id);
-  return existsSync(p) ? readJson(p) : null;
-}
-
-/** Diff two item-manifest arrays → {added, changed, removed} (id lists). */
-function diffItems(parentItems = [], childItems = []) {
-  const p = new Map(parentItems.map((i) => [i.id, i.hash]));
-  const c = new Map(childItems.map((i) => [i.id, i.hash]));
-  const added = [], changed = [], removed = [];
-  for (const [id, hash] of c) {
-    if (!p.has(id)) added.push(id);
-    else if (p.get(id) !== hash) changed.push(id);
-  }
-  for (const id of p.keys()) if (!c.has(id)) removed.push(id);
-  return { added: added.sort(), changed: changed.sort(), removed: removed.sort() };
-}
-
-/**
- * Per-faculty diff of generation `id` against its forkedFrom parent (pure).
- * ALL five faculties are item lists under the Faculty Standard (W24) —
- * added/changed/removed id lists per faculty; knowledge additionally reports
- * registryChanged. When there is no parent (forkedFrom null), everything
- * present counts as added. Returns null for an unknown id.
- */
-export function diffGenerations(agentDir, id) {
-  const child = readGeneration(agentDir, id);
-  if (!child) return null;
-  const parent = child.forkedFrom ? readGeneration(agentDir, child.forkedFrom) : null;
-  const cf = child.faculties || {};
-  const pf = parent?.faculties || {};
-  const faculties = {};
-  for (const f of ['knowledge', 'actions', 'memory', 'guardrails', 'instructions']) {
-    faculties[f] = diffItems(pf[f]?.items, cf[f]?.items);
-    // knowledge also has a registry hash
-    if (f === 'knowledge') {
-      faculties[f].registryChanged = (cf.knowledge?.registryHash ?? null) !== (pf.knowledge?.registryHash ?? null);
-    }
-  }
-  return {
-    id,
-    forkedFrom: child.forkedFrom ?? null,
-    mintedFrom: Array.isArray(child.mintedFrom) ? child.mintedFrom : [],
-    mintedAt: child.mintedAt ?? null,
-    faculties,
-  };
-}
-
-function nextGenId(agentDir) {
-  const ids = listGenerations(agentDir);
-  const max = ids.reduce((m, id) => Math.max(m, parseInt(id.slice(4), 10) || 0), 0);
-  return 'gen_' + String(max + 1).padStart(3, '0');
-}
-
-// --- mint -------------------------------------------------------------------
-
-function copySnapshot(agentDir, id) {
-  const base = join(snapshotsDir(agentDir), id);
-  for (const it of knowledgeFiles(agentDir)) {
-    const dest = join(base, 'knowledge', it.rel);
-    mkdirSync(dirname(dest), { recursive: true });
-    writeFileSync(dest, readFileSync(it.src));
-  }
-  for (const it of memoryFiles(agentDir)) {
-    const dest = join(base, 'memory', it.rel);
-    mkdirSync(dirname(dest), { recursive: true });
-    writeFileSync(dest, readFileSync(it.src));
-  }
-  for (const a of actionFiles(agentDir)) {
-    for (const rel of a.files) {
-      const dest = join(base, 'actions', a.id, rel);
-      mkdirSync(dirname(dest), { recursive: true });
-      writeFileSync(dest, readFileSync(join(a.adir, rel)));
-    }
-  }
-  for (const it of guardrailFiles(agentDir)) {
-    const dest = join(base, 'guardrails', it.rel);
-    mkdirSync(dirname(dest), { recursive: true });
-    writeFileSync(dest, readFileSync(it.src));
-  }
-  for (const it of instructionFiles(agentDir)) {
-    const dest = join(base, 'instructions', it.rel);
-    mkdirSync(dirname(dest), { recursive: true });
-    writeFileSync(dest, readFileSync(it.src));
-  }
-}
-
-/**
- * Mint a new generation: freeze the current faculty state into a content-addressed
- * lockfile + a byte-for-byte snapshot, and make it active.
- */
-export function mintGeneration(agentDir, { forkedFrom = null, mintedFrom = [] } = {}) {
-  const agent = ensureAgent(agentDir).id;
-  const id = nextGenId(agentDir);
-  const lockfile = {
-    id,
-    agent,
-    mintedAt: new Date().toISOString(),
-    forkedFrom,
-    mintedFrom,
-    faculties: snapshotFaculties(agentDir),
-  };
-  copySnapshot(agentDir, id);
-  writeJson(lockfilePath(agentDir, id), lockfile);
-  writeJson(activePath(agentDir), { active: id });
-  return lockfile;
-}
-
-// --- rollback ---------------------------------------------------------------
-
-function archive(agentDir, faculty, src) {
-  // Park (never delete) under <faculty>/_rolledback/<basename> — by basename so
-  // a restore is a simple, flat audit trail of what the rollback displaced.
-  const dest = join(agentDir, faculty, '_rolledback', src.slice(dirname(src).length + 1));
-  mkdirSync(dirname(dest), { recursive: true });
-  renameSync(src, dest);
-}
-
-/**
- * Restore a past generation by content: write each snapshotted item back to its
- * live faculty path; MOVE (never delete) active items absent from the target into
- * <faculty>/_rolledback/; reindex knowledge; flip the active pointer.
- */
-export function rollback(agentDir, id) {
-  const target = readGeneration(agentDir, id);
-  if (!target) throw new Error(`no generation '${id}'`);
-  const base = join(snapshotsDir(agentDir), id);
-  let restored = 0;
-
-  // 1) restore snapshotted knowledge items
-  const targetKnowledge = new Set((target.faculties.knowledge?.items ?? []).map((i) => i.id));
-  for (const i of target.faculties.knowledge?.items ?? []) {
-    const snap = join(base, 'knowledge', `${i.id}.md`);
-    if (existsSync(snap)) {
-      const dest = join(agentDir, 'knowledge', 'items', `${i.id}.md`);
-      mkdirSync(dirname(dest), { recursive: true });
-      writeFileSync(dest, readFileSync(snap));
-      restored++;
-    }
-  }
-  // archive live knowledge items not in the target
-  const kdir = join(agentDir, 'knowledge', 'items');
-  if (existsSync(kdir)) {
-    for (const e of readdirSync(kdir, { withFileTypes: true })) {
-      if (e.isFile() && e.name.endsWith('.md') && !targetKnowledge.has(e.name.replace(/\.md$/, ''))) {
-        archive(agentDir, 'knowledge', join(kdir, e.name));
-      }
-    }
-  }
-
-  // 2) restore snapshotted memory items + archive extras
-  const targetMemory = new Set((target.faculties.memory?.items ?? []).map((i) => i.id));
-  for (const i of target.faculties.memory?.items ?? []) {
-    const snap = join(base, 'memory', `${i.id}.md`);
-    if (existsSync(snap)) {
-      const dest = join(agentDir, 'memory', 'entries', `${i.id}.md`);
-      mkdirSync(dirname(dest), { recursive: true });
-      writeFileSync(dest, readFileSync(snap));
-      restored++;
-    }
-  }
-  const mdir = join(agentDir, 'memory', 'entries');
-  if (existsSync(mdir)) {
-    for (const e of readdirSync(mdir, { withFileTypes: true })) {
-      if (e.isFile() && e.name.endsWith('.md') && !targetMemory.has(e.name.replace(/\.md$/, ''))) {
-        archive(agentDir, 'memory', join(mdir, e.name));
-      }
-    }
-  }
-
-  // 3) restore snapshotted actions + archive extras
-  const targetActions = new Set((target.faculties.actions?.items ?? []).map((i) => i.id));
-  const asnap = join(base, 'actions');
-  if (existsSync(asnap)) {
-    for (const slugEnt of readdirSync(asnap, { withFileTypes: true })) {
-      if (!slugEnt.isDirectory()) continue;
-      const sdir = join(asnap, slugEnt.name);
-      for (const f of readdirSync(sdir)) {
-        const dest = join(agentDir, 'actions', slugEnt.name, f);
-        mkdirSync(dirname(dest), { recursive: true });
-        writeFileSync(dest, readFileSync(join(sdir, f)));
-      }
-      restored++;
-    }
-  }
-  const adir = join(agentDir, 'actions');
-  if (existsSync(adir)) {
-    for (const e of readdirSync(adir, { withFileTypes: true })) {
-      if (e.isDirectory() && e.name !== 'inbox' && e.name !== 'proposals' && e.name !== '_rolledback' && !targetActions.has(e.name)) {
-        archive(agentDir, 'actions', join(adir, e.name));
-      }
-    }
-  }
-
-  // 4) restore guardrails + instructions items (same item-list contract)
-  for (const [faculty, liveSeg] of [['guardrails', ['guardrails', 'items']], ['instructions', ['instructions', 'items']]]) {
-    const targetIds = new Set((target.faculties[faculty]?.items ?? []).map((i) => i.id));
-    for (const i of target.faculties[faculty]?.items ?? []) {
-      const snap = join(base, faculty, `${i.id}.md`);
-      if (existsSync(snap)) {
-        const dest = join(agentDir, ...liveSeg, `${i.id}.md`);
-        mkdirSync(dirname(dest), { recursive: true });
-        writeFileSync(dest, readFileSync(snap));
-        restored++;
-      }
-    }
-    const liveDir = join(agentDir, ...liveSeg);
-    if (existsSync(liveDir)) {
-      for (const e of readdirSync(liveDir, { withFileTypes: true })) {
-        if (e.isFile() && e.name.endsWith('.md') && !targetIds.has(e.name.replace(/\.md$/, ''))) {
-          archive(agentDir, faculty, join(liveDir, e.name));
-        }
-      }
-    }
-  }
-
-  // 5) regenerate the derived knowledge index + flip the pointer
-  try { reindex(agentDir); } catch { /* derived index; tolerate absence of node:sqlite features */ }
-  writeJson(activePath(agentDir), { active: id });
-  return { ok: true, restored };
-}

package/zuzuu/guardrails/adapter.mjs

@@ -1,103 +0,0 @@
-// zuzuu/guardrails/adapter.mjs
-// The Guardrails faculty adapter. 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, body? }
-//
-// apply: writes the rule as a Faculty Standard envelope item at
-//        .zuzuu/guardrails/items/<id>.md (upsert — same id replaces the file).
-//
-// Registers itself on import.
-
-import * as registry from '../faculty/registry.mjs';
-import { writeFacultyItem } from '../faculty/items.mjs';
-import { deriveTitle } from '../faculty/envelope.mjs';
-
-const name = 'guardrails';
-const VALID_ACTIONS = new Set(['deny', 'ask', 'allow']);
-
-// ---------------------------------------------------------------------------
-// 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: write the envelope item (upsert by id).
- * @returns {{ok:boolean, action:string, itemIds:string[]}}
- */
-function apply(agentDir, proposal) {
-  const rule = proposal?.payload ?? {};
-  const id = rule.id;
-  writeFacultyItem(agentDir, {
-    id,
-    faculty: name,
-    kind: 'rule',
-    title: deriveTitle(rule.reason, id),
-    status: 'active',
-    created_at: new Date().toISOString().replace(/\.\d+Z$/, 'Z'),
-    provenance: Array.isArray(proposal?.provenance) ? proposal.provenance : [],
-    payload: { action: rule.action, tool: rule.tool || '*', pattern: rule.pattern, reason: rule.reason },
-    body: rule.body ?? '',
-  });
-  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/instructions/adapter.mjs

@@ -1,93 +0,0 @@
-// zuzuu/instructions/adapter.mjs
-// The Instructions faculty adapter. 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:
-//   { id?, text }  — a line or paragraph of steering
-//
-// apply: writes the amendment as a Faculty Standard envelope item under
-//        .zuzuu/instructions/items/<id>.md (kind: amendment; body = the text).
-//        The pinned steering itself lives at items/steering.md; future
-//        amendments are MORE items, never edits to steering. Idempotent: a
-//        text already present in any instructions item is not duplicated.
-//
-// Registers itself on import.
-
-import * as registry from '../faculty/registry.mjs';
-import { listFacultyItems, writeFacultyItem } from '../faculty/items.mjs';
-import { deriveTitle } from '../faculty/envelope.mjs';
-import { slugify } from '../knowledge/items.mjs';
-
-const name = 'instructions';
-
-// ---------------------------------------------------------------------------
-// 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: write an amendment item (idempotent on
- * identical text — won't duplicate steering already present in any item).
- * @returns {{ok:boolean, action:string, itemIds:string[]}}
- */
-function apply(agentDir, proposal) {
-  const text = String(proposal?.payload?.text ?? '').trim();
-
-  // Idempotence: skip if the exact text already lives in an instructions item
-  const { items } = listFacultyItems(agentDir, 'instructions');
-  if (items.some((i) => String(i.body ?? '').includes(text))) {
-    return { ok: true, action: 'amended instructions (already present)', itemIds: [] };
-  }
-
-  const id = proposal?.payload?.id || slugify(text, 50);
-  writeFacultyItem(agentDir, {
-    id,
-    faculty: name,
-    kind: 'amendment',
-    title: deriveTitle(text, id),
-    status: 'active',
-    created_at: new Date().toISOString().replace(/\.\d+Z$/, 'Z'),
-    provenance: Array.isArray(proposal?.provenance) ? proposal.provenance : [],
-    payload: { scope: 'project' },
-    body: text,
-  });
-
-  return { ok: true, action: 'amended instructions', itemIds: [id] };
-}
-
-/**
- * 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);

package/zuzuu/knowledge/adapter.mjs

@@ -1,99 +0,0 @@
-// zuzuu/knowledge/adapter.mjs
-// The Knowledge faculty adapter (WS2-T2). Wraps the EXISTING Knowledge pipeline
-// (proposals/ER/registry/items/index) behind the faculty-spine adapter contract
-// — { name, ingest, validate, apply, render } — without changing any behaviour.
-//
-//   ingest   — run ER on a candidate, mirroring createProposal's analysis step
-//   validate — registry-based validation of an item
-//   apply    — IS the extracted approve apply body (applyKnowledgeProposal)
-//   render   — the human card the `zuzuu review` gate shows for a knowledge proposal
-//
-// Registers itself on import.
-
-import { resolve as erResolve } from './er.mjs';
-import { loadRegistry, validateItem } from './registry.mjs';
-import { allItems, slugify } from './items.mjs';
-import { applyKnowledgeProposal } from './proposals.mjs';
-import * as registry from '../faculty/registry.mjs';
-
-const name = 'knowledge';
-
-/**
- * Ingest a raw candidate: run ER against existing items and return the
- * normalised payload + analysis. Mirrors what createProposal computes today.
- * @param {string} agentDir
- * @param {{candidate:object, source?:string, evidence?:object}} raw
- */
-function ingest(agentDir, raw) {
-  const { items } = allItems(agentDir);
-  const candidate = { ...raw.candidate };
-  candidate.id = candidate.id || slugify(candidate.body);
-  const er = erResolve(candidate, items);
-  return { payload: candidate, analysis: { er }, dedupeKey: candidate.id };
-}
-
-/**
- * Validate an item against the Knowledge registry.
- * @returns {{ok:boolean, errors:string[], warnings:string[]}}
- */
-function validate(agentDir, payload) {
-  const reg = loadRegistry(agentDir);
-  const v = validateItem(reg, payload);
-  const warnings = [
-    ...v.unknownKeys.attributes.map((k) => `unregistered attribute '${k}'`),
-    ...v.unknownKeys.relations.map((t) => `unregistered relation type '${t}'`),
-  ];
-  return { ok: v.ok, errors: v.errors, warnings };
-}
-
-/**
- * Apply an approved proposal — delegates to the extracted approve apply body.
- * @returns {{ok:boolean, action:string, itemIds:string[], warnings:string[]}}
- */
-function apply(agentDir, proposal) {
-  // Bridge spine-shaped records (payload/analysis.er) onto applyKnowledgeProposal's
-  // legacy shape (candidate/er). Records that still carry candidate/er pass through.
-  const legacy = {
-    ...proposal,
-    candidate: proposal.candidate ?? proposal.payload,
-    er: proposal.er ?? proposal.analysis?.er,
-  };
-  const r = applyKnowledgeProposal(agentDir, legacy);
-  return {
-    ok: r.ok,
-    action: r.action,
-    itemIds: r.item ? [r.item] : [],
-    warnings: r.warnings ?? [],
-  };
-}
-
-/**
- * Render a proposal for the human gate. `card` mirrors the multi-line summary
- * `zuzuu review` shows for knowledge proposals (id, type, attrs/relations, ER
- * verdict); `line` is the one-line list form (`zuzuu proposals list`).
- * @returns {{line:string, card:string}}
- */
-function render(proposal) {
-  if (proposal.kind === 'registry') {
-    const what = `register ${String(proposal.registry).slice(0, -1)} '${proposal.key}'`;
-    return {
-      line: `${proposal.id}  [${proposal.kind}]  ${what}`,
-      card: `${what}  (seen ${proposal.evidence?.occurrences}× in candidates)`,
-    };
-  }
-  const c = proposal.candidate ?? {};
-  const er = proposal.er ?? {};
-  const lines = [];
-  lines.push(`${c.id ?? ''} ── ${c.type}: ${c.body?.slice(0, 100).replace(/\n/g, ' ')}`);
-  for (const [k, v] of Object.entries(c.attributes ?? {})) lines.push(`  · ${k} = ${v}`);
-  for (const r of c.relations ?? []) lines.push(`  → ${r.type} ${r.target}`);
-  lines.push(`  er: ${er.verdict}${er.match ? ` → ${er.match}` : ''}  (${(er.confidence ?? 0).toFixed(2)} · ${er.reason ?? ''})`);
-  return {
-    line: `${proposal.id}  [${er.verdict ?? proposal.kind}]  ${c.type}: ${c.body?.slice(0, 60).replace(/\n/g, ' ')}`,
-    card: lines.join('\n'),
-  };
-}
-
-export const adapter = { name, ingest, validate, apply, render };
-
-registry.register(adapter);