@zuzuucodes/cli 1.4.0 → 1.6.0

package/zuzuu/commands/migrations/items.mjs

@@ -0,0 +1,360 @@
+// zuzuu/commands/migrations/items.mjs — the Faculty Standard migrator (W24):
+// legacy per-faculty shapes → one envelope. knowledge/memory frontmatter keys
+// standardised, rules.json exploded into guardrails/items/, action.json+SKILL.md
+// → ACTION.md, instructions/project.md → items/steering.md. Idempotent,
+// fail-soft per item. Auto-runs from `zuzuu init` when old shapes are detected.
+
+import { existsSync, readdirSync, readFileSync, writeFileSync, rmSync, statSync, mkdirSync } from 'node:fs';
+import { join } from 'node:path';
+import { serializeEnvelope, deriveTitle } from '../../faculty/envelope.mjs';
+import { serializeItem } from '../../knowledge/items.mjs';
+import { FACULTIES } from '../../faculty/contract.mjs';
+import { BUILTIN_MODULES } from '../../faculty/registry.mjs';
+
+/** Does this file's frontmatter already carry the envelope (a `faculty:` key)? */
+function isEnvelopeText(text) {
+  const m = String(text).match(/^---\r?\n([\s\S]*?)\r?\n---/);
+  return !!m && /^faculty:/m.test(m[1]);
+}
+
+const unquoteLegacy = (s) => {
+  const t = String(s).trim();
+  return (t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'")) ? t.slice(1, -1) : t;
+};
+
+/**
+ * Parse the PRE-standard knowledge/memory frontmatter grammar (top-level
+ * scalars; ONE nested map `attributes`/`provenance`; arrays of flat maps).
+ * Kept here (and only here) — the live parsers are envelope-only (clean break).
+ * Throws on violations; the caller fail-softs per item.
+ */
+function parseLegacyFrontmatter(text) {
+  const m = String(text).match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+  if (!m) throw new Error('no frontmatter block');
+  const [, fm, body] = m;
+  const item = { scalars: {}, maps: {}, lists: {}, body: body.trim() };
+  let section = null;   // current nested key
+  let mode = null;      // 'map' | 'list'
+  let current = null;
+  for (const raw of fm.split('\n')) {
+    if (!raw.trim()) continue;
+    const indent = raw.match(/^ */)[0].length;
+    const line = raw.trim();
+    const kv = line.match(/^([A-Za-z_][\w-]*):\s*(.*)$/);
+    if (indent === 0) {
+      current = null;
+      if (!kv) throw new Error(`bad line: ${line}`);
+      const [, key, val] = kv;
+      if (val === '') { section = key; mode = null; }
+      else { section = null; item.scalars[key] = unquoteLegacy(val); }
+    } else if (section) {
+      if (line.startsWith('- ')) {
+        mode = mode ?? 'list';
+        if (!item.lists[section]) item.lists[section] = [];
+        const ekv = line.slice(2).match(/^([A-Za-z_][\w-]*):\s*(.*)$/);
+        if (ekv) { current = { [ekv[1]]: unquoteLegacy(ekv[2]) }; item.lists[section].push(current); }
+        else { current = null; item.lists[section].push(unquoteLegacy(line.slice(2))); }
+      } else if (current && kv) {
+        current[kv[1]] = unquoteLegacy(kv[2]);
+      } else if (kv) {
+        mode = mode ?? 'map';
+        if (!item.maps[section]) item.maps[section] = {};
+        item.maps[section][kv[1]] = unquoteLegacy(kv[2]);
+      } else {
+        throw new Error(`bad nested line: ${line}`);
+      }
+    } else {
+      throw new Error(`unexpected indented line: ${line}`);
+    }
+  }
+  return item;
+}
+
+/** Parse a legacy inline list: `[a, b]` or an already-array value. */
+function legacyList(v) {
+  if (Array.isArray(v)) return v.map(String);
+  const t = String(v ?? '').trim();
+  if (t.startsWith('[') && t.endsWith(']')) {
+    return t.slice(1, -1).split(',').map((s) => unquoteLegacy(s)).filter(Boolean);
+  }
+  return t ? [t] : [];
+}
+
+/** knowledge/items/*.md: legacy keys → envelope (ids unchanged). */
+function migrateKnowledgeItems(agentDir, out) {
+  const dir = join(agentDir, 'knowledge', 'items');
+  if (!existsSync(dir)) return;
+  for (const f of readdirSync(dir).filter((f) => f.endsWith('.md'))) {
+    const path = join(dir, f);
+    try {
+      const text = readFileSync(path, 'utf8');
+      if (isEnvelopeText(text)) { out.skipped++; continue; }
+      const legacy = parseLegacyFrontmatter(text);
+      const item = {
+        id: legacy.scalars.id || f.replace(/\.md$/, ''),
+        type: legacy.scalars.type,
+        created_at: legacy.scalars.created_at,
+        updated_at: legacy.scalars.updated_at,
+        status: legacy.scalars.status ?? 'active',
+        attributes: legacy.maps.attributes ?? {},
+        relations: (legacy.lists.relations ?? []).filter((r) => typeof r === 'object'),
+        provenance: (legacy.lists.provenance ?? []).filter((r) => typeof r === 'object'),
+        body: legacy.body,
+      };
+      if (!item.type) throw new Error('item missing type');
+      writeFileSync(path, serializeItem(item)); // envelope via the knowledge wrapper
+      out.knowledge++;
+    } catch (e) {
+      out.errors.push({ file: `knowledge/items/${f}`, error: e.message });
+    }
+  }
+}
+
+/** memory/entries/*.md: legacy episode keys → envelope (kind: episode). */
+function migrateMemoryEntries(agentDir, out) {
+  const dir = join(agentDir, 'memory', 'entries');
+  if (!existsSync(dir)) return;
+  for (const f of readdirSync(dir).filter((f) => f.endsWith('.md'))) {
+    const path = join(dir, f);
+    try {
+      const text = readFileSync(path, 'utf8');
+      if (isEnvelopeText(text)) { out.skipped++; continue; }
+      const legacy = parseLegacyFrontmatter(text);
+      const id = legacy.scalars.id || f.replace(/\.md$/, '');
+      const payload = {};
+      const prov = legacy.maps.provenance ?? {};
+      const sessions = legacyList(prov.sessions ?? legacy.scalars.sessions ?? '');
+      const hosts = legacyList(prov.hosts ?? legacy.scalars.hosts ?? '');
+      const tags = legacyList(legacy.scalars.tags ?? '');
+      if (sessions.length) payload.sessions = sessions;
+      if (hosts.length) payload.hosts = hosts;
+      if (tags.length) payload.tags = tags;
+      writeFileSync(path, serializeEnvelope({
+        id,
+        faculty: 'memory',
+        kind: 'episode',
+        title: legacy.scalars.title ?? deriveTitle(legacy.body, id),
+        status: 'active', // curated/proposed lifecycles fold into active
+        created_at: legacy.scalars.date ?? legacy.scalars.created_at,
+        payload,
+        body: legacy.body,
+      }));
+      out.memory++;
+    } catch (e) {
+      out.errors.push({ file: `memory/entries/${f}`, error: e.message });
+    }
+  }
+}
+
+/** guardrails/rules.json: EXPLODE into items/<id>.md, then delete rules.json. */
+function migrateGuardrails(agentDir, out) {
+  const rulesPath = join(agentDir, 'guardrails', 'rules.json');
+  if (!existsSync(rulesPath)) return;
+  let data;
+  try {
+    data = JSON.parse(readFileSync(rulesPath, 'utf8'));
+  } catch (e) {
+    out.errors.push({ file: 'guardrails/rules.json', error: e.message });
+    return; // unreadable → leave the file for the human, never destroy it
+  }
+  const rules = Array.isArray(data?.rules) ? data.rules : [];
+  const itemsDir = join(agentDir, 'guardrails', 'items');
+  let failed = 0;
+  for (let i = 0; i < rules.length; i++) {
+    const r = rules[i] ?? {};
+    try {
+      const id = String(r.id ?? `rule-${i}`);
+      mkdirSync(itemsDir, { recursive: true });
+      writeFileSync(join(itemsDir, `${id}.md`), serializeEnvelope({
+        id,
+        faculty: 'guardrails',
+        kind: 'rule',
+        title: deriveTitle(r.reason, id),
+        status: 'active',
+        created_at: new Date().toISOString().replace(/\.\d+Z$/, 'Z'),
+        payload: { action: r.action, tool: r.tool || '*', pattern: String(r.pattern ?? ''), reason: String(r.reason ?? '') },
+        body: '',
+      }));
+      out.guardrails++;
+    } catch (e) {
+      failed++;
+      out.errors.push({ file: `guardrails/rules.json#${r.id ?? i}`, error: e.message });
+    }
+  }
+  // rules.json goes away only when every rule landed as an item (fail-soft)
+  if (failed === 0) {
+    try { rmSync(rulesPath, { force: true }); } catch { /* fail-soft */ }
+  }
+}
+
+/** One action dir: action.json (+SKILL.md) → ACTION.md; legacy files removed on success. */
+function migrateActionDir(dir, slug, out) {
+  const actionMd = join(dir, 'ACTION.md');
+  if (existsSync(actionMd)) { out.skipped++; return; }
+  const manPath = join(dir, 'action.json');
+  const skillPath = join(dir, 'SKILL.md');
+  if (!existsSync(manPath) && !existsSync(skillPath)) return; // not an action dir
+  try {
+    let man = {};
+    if (existsSync(manPath)) man = JSON.parse(readFileSync(manPath, 'utf8'));
+    let skillFm = {};
+    let skillBody = '';
+    if (existsSync(skillPath)) {
+      const text = readFileSync(skillPath, 'utf8');
+      const m = text.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n?([\s\S]*)$/);
+      if (m) {
+        for (const line of m[1].split('\n')) {
+          const kv = line.match(/^(\w+):\s*(.*)$/);
+          if (kv) skillFm[kv[1]] = kv[2].trim();
+        }
+        skillBody = m[2].trim();
+      } else {
+        skillBody = text.trim();
+      }
+    }
+    const isScript = existsSync(join(dir, 'run.mjs'));
+    const payload = {};
+    if (isScript) payload.exec = 'run.mjs';
+    // default_args survive as payload.args (flat scalars only — the envelope grammar)
+    const args = {};
+    for (const [k, v] of Object.entries(man.default_args ?? {})) {
+      if (v == null || typeof v === 'object') continue;
+      args[k] = String(v);
+    }
+    if (Object.keys(args).length) payload.args = args;
+    const snippet = man.promptSnippet ?? man.description ?? skillFm.description ?? slug;
+    const bodyParts = [snippet];
+    if (man.description && man.description !== snippet) bodyParts.push('', man.description);
+    if (skillBody) bodyParts.push('', skillBody);
+    writeFileSync(actionMd, serializeEnvelope({
+      id: slug,
+      faculty: 'actions',
+      kind: isScript ? 'script' : 'runbook',
+      title: man.title ?? skillFm.name ?? slug,
+      status: 'active',
+      created_at: new Date().toISOString().replace(/\.\d+Z$/, 'Z'),
+      payload,
+      body: bodyParts.join('\n'),
+    }));
+    // legacy files leave only after ACTION.md landed
+    rmSync(manPath, { force: true });
+    rmSync(skillPath, { force: true });
+    out.actions++;
+  } catch (e) {
+    out.errors.push({ file: `actions/${slug}`, error: e.message });
+  }
+}
+
+/** All action dirs: active + inbox (proposed) — same conversion. */
+function migrateActions(agentDir, out) {
+  for (const base of [join(agentDir, 'actions'), join(agentDir, 'actions', 'inbox')]) {
+    if (!existsSync(base)) continue;
+    for (const name of readdirSync(base)) {
+      if (name === 'inbox' || name === 'proposals' || name === '_rolledback') continue;
+      const dir = join(base, name);
+      let isDir = false;
+      try { isDir = statSync(dir).isDirectory(); } catch { continue; }
+      if (isDir) migrateActionDir(dir, name, out);
+    }
+  }
+}
+
+/** instructions/project.md → items/steering.md. A customized steering item is
+ *  never clobbered — project.md then stays put for the human to reconcile. */
+function migrateInstructions(agentDir, out) {
+  const projPath = join(agentDir, 'instructions', 'project.md');
+  if (!existsSync(projPath)) return;
+  const steeringPath = join(agentDir, 'instructions', 'items', 'steering.md');
+  try {
+    const existing = existsSync(steeringPath) ? readFileSync(steeringPath, 'utf8') : null;
+    const placeholder = existing != null && existing.includes('<!-- Fill in:');
+    if (existing != null && !placeholder) {
+      out.errors.push({ file: 'instructions/project.md', error: 'a customized steering item already exists — merge by hand, then delete project.md' });
+      return;
+    }
+    const body = readFileSync(projPath, 'utf8').trim();
+    mkdirSync(join(agentDir, 'instructions', 'items'), { recursive: true });
+    writeFileSync(steeringPath, serializeEnvelope({
+      id: 'steering',
+      faculty: 'instructions',
+      kind: 'steering',
+      title: 'Project steering',
+      status: 'active',
+      created_at: new Date().toISOString().replace(/\.\d+Z$/, 'Z'),
+      payload: { scope: 'project' },
+      body,
+    }));
+    out.instructions++;
+    rmSync(projPath, { force: true });
+  } catch (e) {
+    out.errors.push({ file: 'instructions/project.md', error: e.message });
+  }
+}
+
+/** Seed missing <faculty>/faculty.json manifests into an existing home (the
+ *  Faculty Module contract, 2026-06-13). Only faculties whose dir exists get
+ *  one — a migrator repairs, it never scaffolds. Idempotent, fail-soft. */
+function seedFacultyManifests(agentDir, out) {
+  for (const f of FACULTIES) {
+    try {
+      const dir = join(agentDir, f);
+      if (!existsSync(dir)) continue;
+      const p = join(dir, 'faculty.json');
+      if (existsSync(p)) continue;
+      writeFileSync(p, JSON.stringify(BUILTIN_MODULES[f].manifest, null, 2) + '\n');
+      out.manifests++;
+    } catch (e) {
+      out.errors.push({ file: `${f}/faculty.json`, error: e.message });
+    }
+  }
+}
+
+/**
+ * Are pre-standard shapes present? Cheap checks gate the init auto-run.
+ */
+export function needsItemsMigration(agentDir) {
+  for (const f of FACULTIES) {
+    if (existsSync(join(agentDir, f)) && !existsSync(join(agentDir, f, 'faculty.json'))) return true;
+  }
+  if (existsSync(join(agentDir, 'guardrails', 'rules.json'))) return true;
+  if (existsSync(join(agentDir, 'instructions', 'project.md'))) return true;
+  for (const base of [join(agentDir, 'actions'), join(agentDir, 'actions', 'inbox')]) {
+    if (!existsSync(base)) continue;
+    for (const name of readdirSync(base)) {
+      if (name === 'inbox' || name === 'proposals' || name === '_rolledback') continue;
+      const dir = join(base, name);
+      try { if (!statSync(dir).isDirectory()) continue; } catch { continue; }
+      if (existsSync(join(dir, 'ACTION.md'))) continue;
+      if (existsSync(join(dir, 'action.json')) || existsSync(join(dir, 'SKILL.md'))) return true;
+    }
+  }
+  for (const seg of [['knowledge', 'items'], ['memory', 'entries']]) {
+    const dir = join(agentDir, ...seg);
+    if (!existsSync(dir)) continue;
+    for (const f of readdirSync(dir).filter((f) => f.endsWith('.md'))) {
+      try {
+        if (!isEnvelopeText(readFileSync(join(dir, f), 'utf8'))) return true;
+      } catch { /* unreadable file never forces a migration */ }
+    }
+  }
+  return false;
+}
+
+/**
+ * One-shot Faculty Standard migration for a home. Idempotent (already-envelope
+ * files are skipped) and fail-soft per item (an unconvertible item is reported,
+ * never fatal; its legacy source is left in place).
+ * @returns {{knowledge:number, memory:number, guardrails:number, actions:number,
+ *            instructions:number, manifests:number, skipped:number, errors:Array<{file,error}>}}
+ */
+export function migrateItems(agentDir) {
+  const out = { knowledge: 0, memory: 0, guardrails: 0, actions: 0, instructions: 0, manifests: 0, skipped: 0, errors: [] };
+  migrateKnowledgeItems(agentDir, out);
+  migrateMemoryEntries(agentDir, out);
+  migrateGuardrails(agentDir, out);
+  migrateActions(agentDir, out);
+  migrateInstructions(agentDir, out);
+  seedFacultyManifests(agentDir, out);
+  return out;
+}
+

package/zuzuu/commands/migrations/proposals.mjs

@@ -0,0 +1,100 @@
+// zuzuu/commands/migrations/proposals.mjs — legacy proposal-schema migrator.
+// {candidate, er} → spine {payload, analysis, faculty} (WS2-T5). Pure core:
+// migrateProposals(agentDir) → { scanned, migrated, skipped }. Fail-soft per file.
+
+import { existsSync, readdirSync, readFileSync, writeFileSync } from 'node:fs';
+import { join } from 'node:path';
+import { proposalsDir, archiveDir } from '../../faculty/contract.mjs';
+
+/**
+ * Determine whether a parsed JSON record is already in the new shape.
+ * A record is "new" when it has `payload` AND `faculty` set.
+ * If it only has `candidate` and/or lacks `faculty` it is legacy.
+ */
+function isLegacy(rec) {
+  if (!rec || typeof rec !== 'object') return false;
+  // already migrated: has payload and faculty
+  if (rec.payload !== undefined && rec.faculty !== undefined) return false;
+  // legacy if it has candidate or er keys, or is simply missing faculty/payload
+  return rec.candidate !== undefined || rec.er !== undefined || rec.faculty === undefined;
+}
+
+/**
+ * Convert a legacy record to the new unified shape.
+ * Returns the migrated record (caller writes it back).
+ */
+function migrateRecord(rec) {
+  const out = { ...rec };
+
+  // payload = candidate (drop candidate)
+  if (out.candidate !== undefined) {
+    if (out.payload === undefined) out.payload = out.candidate;
+    delete out.candidate;
+  }
+
+  // analysis = { er } (drop er)
+  if (out.er !== undefined) {
+    if (out.analysis === undefined) out.analysis = { er: out.er };
+    delete out.er;
+  }
+
+  // faculty defaults to 'knowledge' (only knowledge proposals exist pre-spine)
+  if (!out.faculty) out.faculty = 'knowledge';
+
+  return out;
+}
+
+/**
+ * Scan one directory of *.json files and migrate legacy records in-place.
+ * Fail-soft: bad JSON files are counted as skipped and never throw.
+ * Returns { migrated, scanned, skipped } for this directory.
+ */
+function migrateDir(dir) {
+  if (!existsSync(dir)) return { migrated: 0, scanned: 0, skipped: 0 };
+
+  const files = readdirSync(dir).filter((f) => f.endsWith('.json'));
+  let migrated = 0;
+  let skipped = 0;
+
+  for (const file of files) {
+    const fpath = join(dir, file);
+    let rec;
+    try {
+      rec = JSON.parse(readFileSync(fpath, 'utf8'));
+    } catch {
+      skipped++;
+      continue;
+    }
+
+    if (!isLegacy(rec)) {
+      skipped++;
+      continue;
+    }
+
+    try {
+      const migrated_rec = migrateRecord(rec);
+      writeFileSync(fpath, JSON.stringify(migrated_rec, null, 2) + '\n');
+      migrated++;
+    } catch {
+      skipped++;
+    }
+  }
+
+  return { migrated, scanned: files.length, skipped };
+}
+
+/**
+ * Scan both pending and archived Knowledge proposals.
+ * Returns { scanned, migrated, skipped }.
+ */
+export function migrateProposals(agentDir) {
+  const pending = migrateDir(proposalsDir(agentDir, 'knowledge'));
+  const archived = migrateDir(archiveDir(agentDir, 'knowledge'));
+
+  return {
+    scanned: pending.scanned + archived.scanned,
+    migrated: pending.migrated + archived.migrated,
+    skipped: pending.skipped + archived.skipped,
+  };
+}
+

package/zuzuu/commands/proposals.mjs

@@ -0,0 +1,131 @@
+// `zuzuu proposals` — the human gate, non-interactive: list|show|approve|reject.
+// The same adapter-driven path `zuzuu review` walks, minus the ceremony. Pure
+// data fns (proposalsListData/approveData/rejectData) feed the --json surface
+// and the web workbench.
+
+import { paths } from '../core/store.mjs';
+import { processInbox } from '../knowledge/inbox.mjs';
+import { getProposal } from '../knowledge/proposals.mjs';
+import * as registry from '../faculty/registry.mjs';
+import * as gate from '../faculty/gate.mjs';
+import { pendingByFaculty } from '../faculty/pending.mjs';
+import { knowledgeLine, proposalTitle } from '../faculty/render.mjs';
+
+/**
+ * Resolve which faculty owns a given proposal id (used when --faculty is omitted).
+ * Defaults to 'knowledge' (the historical path) when no other faculty claims it.
+ */
+function facultyOf(agentDir, id, only) {
+  if (only) return only;
+  for (const { adapter, proposals } of pendingByFaculty(agentDir)) {
+    if (proposals.some((p) => p.id === id)) return adapter.name;
+  }
+  return 'knowledge';
+}
+
+/**
+ * Pure: the structured object for `proposals approve --json`.
+ * Calls gate.approve and returns the result object the branch prints.
+ * @param {string} agentDir
+ * @param {string} id
+ * @param {string} faculty
+ * @returns {object}  the gate result (contains ok, action, etc.)
+ */
+export function approveData(agentDir, id, faculty) {
+  return gate.approve(agentDir, faculty, id);
+}
+
+/**
+ * Pure: the structured object for `proposals reject --json`.
+ * Calls gate.reject and returns the result object the branch prints.
+ * @param {string} agentDir
+ * @param {string} id
+ * @param {string} faculty
+ * @param {string} [reason]
+ * @returns {object}  { ok, id, ... }
+ */
+export function rejectData(agentDir, id, faculty, reason = '') {
+  const r = gate.reject(agentDir, faculty, id, reason);
+  return { ...r, id };
+}
+
+/**
+ * Pure: list pending proposals as structured data — the zuzuu-web /proposals source.
+ * @param {string} agentDir
+ * @param {string} [only]  optional faculty filter
+ * @returns {{ pending: Array<{id, faculty, title}> }}
+ */
+export function proposalsListData(agentDir, only) {
+  const groups = pendingByFaculty(agentDir).filter((g) => !only || g.adapter.name === only);
+  const pending = [];
+  for (const { adapter, proposals } of groups) {
+    for (const p of proposals) {
+      pending.push({ id: p.id, faculty: adapter.name, title: proposalTitle(adapter, p) });
+    }
+  }
+  return { pending };
+}
+
+/** Non-interactive: zuzuu proposals list|show <id>|approve <id>|reject <id> [--reason r] [--faculty f] */
+export function proposals(args) {
+  const agentDir = paths().dir;
+  const sub = args._[0] || 'list';
+  const only = args.faculty; // optional filter; default = all
+  if (sub === 'list') {
+    if (args.json) {
+      processInbox(agentDir);  // promote plain-text inbox candidates, same as text path
+      const d = proposalsListData(agentDir, only);
+      console.log(JSON.stringify(d));
+      return;
+    }
+    const inbox = processInbox(agentDir);
+    if (inbox.processed) console.log(`(processed ${inbox.processed} inbox candidate(s))`);
+    const groups = pendingByFaculty(agentDir).filter((g) => !only || g.adapter.name === only);
+    const any = groups.some((g) => g.proposals.length);
+    if (!any) return console.log('no pending proposals');
+    for (const { adapter, proposals } of groups) {
+      for (const p of proposals) {
+        // knowledge keeps its historical one-liner; other faculties use adapter.render
+        if (adapter.name === 'knowledge') {
+          console.log(knowledgeLine(p));
+        } else {
+          console.log(`  ${adapter.render(p).line}`);
+        }
+      }
+    }
+    return;
+  }
+  const id = args._[1];
+  if (sub === 'show') {
+    const faculty = facultyOf(agentDir, id, only);
+    const a = registry.get(faculty);
+    const p = (a && typeof a.getProposal === 'function') ? a.getProposal(agentDir, id) : getProposal(agentDir, id);
+    if (!p) return console.error('not found');
+    // show always prints JSON (both with and without --json flag)
+    console.log(JSON.stringify(p, null, 2));
+    return;
+  }
+  if (sub === 'approve') {
+    const faculty = facultyOf(agentDir, id, only);
+    const r = approveData(agentDir, id, faculty);
+    if (args.json) {
+      console.log(JSON.stringify(r));
+    } else {
+      console.log(r.ok ? `✓ ${r.action}` : `✗ ${(r.errors ?? [r.action]).join('; ')}`);
+      for (const w of r.warnings ?? []) console.log(`⚠ ${w}`);
+    }
+    process.exit(r.ok ? 0 : 1);
+  }
+  if (sub === 'reject') {
+    const faculty = facultyOf(agentDir, id, only);
+    const r = rejectData(agentDir, id, faculty, args.reason || '');
+    if (args.json) {
+      console.log(JSON.stringify(r));
+    } else {
+      console.log(r.ok ? '✓ rejected' : '✗ not found');
+    }
+    process.exit(r.ok ? 0 : 1);
+  }
+  console.error('usage: zuzuu proposals list|show <id>|approve <id>|reject <id> [--reason r] [--faculty f]');
+  process.exit(1);
+}