@zuzuucodes/cli 1.0.0

package/zuzuu/knowledge/adapter.mjs

@@ -0,0 +1,99 @@
+// 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);

package/zuzuu/knowledge/distill.mjs

@@ -0,0 +1,237 @@
+// `zuzuu distill` — source A: mechanical miners over real sessions.
+//
+// Reads HOST transcripts directly (not our OTLP traces — those carry byte
+// sizes only, by privacy design; mining is an internal on-machine read and
+// only the distilled FACT + provenance becomes knowledge). Claude Code first —
+// the richest log. Deterministic, zero-LLM: the cheap unambiguous signals.
+//
+// Miners (v1):
+//   commands  — normalized Bash commands recurring ≥3× across ≥2 sessions
+//               → `command` candidates ("a project command")
+//   hot-files — files Read/Edit/Written ≥5× → `entity` candidates
+//   failures  — tools failing ≥3× → `fact` candidates (worth knowing!)
+
+import { readFileSync } from 'node:fs';
+import * as registry from '../../experiments/experiment-1-trace-capture/adapters/registry.mjs';
+import { slugify } from './items.mjs';
+import { createProposal, fileRegistryProposals } from './proposals.mjs';
+
+const norm = (cmd) => String(cmd).trim().replace(/\s+/g, ' ').slice(0, 200);
+
+// Superset (WS5-T1) constants.
+const SEQ_SEP = ' && '; // joins adjacent Bash commands into a 2-gram label
+const CORRECTION_LEXICON = ["no, don't", "don't ", 'actually use', 'always ', 'never ', 'stop ', 'instead'];
+const DESTRUCTIVE_SHAPES = [/\brm\s+-[a-z]*r/, /git\s+push\s+.*--force/, /DROP\s+TABLE/i, /chmod\s+-R/];
+
+const isCorrection = (text) => {
+  const t = String(text).toLowerCase();
+  return CORRECTION_LEXICON.some((p) => t.includes(p));
+};
+const isDestructive = (cmd) => DESTRUCTIVE_SHAPES.some((re) => re.test(cmd));
+
+/** Extract a plain-text string from a user message content (string or block array). */
+function userText(content) {
+  if (typeof content === 'string') return content;
+  if (Array.isArray(content)) {
+    return content
+      .filter((b) => b && b.type === 'text' && typeof b.text === 'string')
+      .map((b) => b.text)
+      .join(' ');
+  }
+  return '';
+}
+/** True if a user message is a tool_result echo (not a real user turn). */
+const isToolResult = (content) => Array.isArray(content) && content.some((b) => b && b.type === 'tool_result');
+
+/**
+ * Extract raw mining signals from one Claude Code transcript.
+ * SUPERSET (WS5-T1): the original `commands/files/failures` keys are unchanged;
+ * `sequences/correctionTurns/destructiveFailures` are added for later faculties.
+ */
+export function mineTranscript(file) {
+  const out = { commands: [], files: [], failures: [], sequences: [], correctionTurns: [], destructiveFailures: [] };
+  let sessionId = '';
+  const results = new Map(); // tool_use_id -> is_error
+  const uses = []; // {id, name, input}
+  const bashOrder = []; // normalized Bash commands in transcript order
+  const userTurns = []; // {text, afterToolAction}
+  let sawToolAction = false;
+  for (const line of readFileSync(file, 'utf8').split('\n')) {
+    if (!line) continue;
+    let e;
+    try {
+      e = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (e.sessionId) sessionId ||= e.sessionId;
+    const content = e.message?.content;
+    // real user turn (text), not a tool_result echo → candidate correction turn
+    if (e.type === 'user' && content != null && !isToolResult(content)) {
+      const text = userText(content).trim();
+      if (text) userTurns.push({ text, afterToolAction: sawToolAction });
+    }
+    if (!Array.isArray(content)) continue;
+    for (const b of content) {
+      if (b.type === 'tool_use') {
+        const input = typeof b.input === 'string' ? safeParse(b.input) : b.input ?? {};
+        uses.push({ id: b.id, name: b.name, input });
+        sawToolAction = true;
+        if (b.name === 'Bash' && input?.command) bashOrder.push(norm(input.command));
+      } else if (b.type === 'tool_result') {
+        results.set(b.tool_use_id, !!b.is_error);
+      }
+    }
+  }
+  for (const u of uses) {
+    const failed = results.get(u.id) === true;
+    if (u.name === 'Bash' && u.input?.command) out.commands.push({ cmd: norm(u.input.command), failed });
+    const fp = u.input?.file_path || u.input?.path;
+    if (fp && ['Read', 'Write', 'Edit', 'NotebookEdit'].includes(u.name)) out.files.push(String(fp));
+    if (failed) out.failures.push(u.name);
+    if (failed && u.name === 'Bash' && u.input?.command) {
+      const cmd = norm(u.input.command);
+      if (isDestructive(cmd)) out.destructiveFailures.push({ cmd, tool: u.name });
+    }
+  }
+  // 2-gram Bash sequences (adjacent within the session)
+  for (let i = 0; i + 1 < bashOrder.length; i++) out.sequences.push(bashOrder[i] + SEQ_SEP + bashOrder[i + 1]);
+  // corrective user turns that follow an assistant tool action
+  for (const t of userTurns) if (t.afterToolAction && isCorrection(t.text)) out.correctionTurns.push({ text: t.text.slice(0, 500) });
+  return { sessionId, ...out };
+}
+
+function safeParse(s) {
+  try {
+    return JSON.parse(s);
+  } catch {
+    return {};
+  }
+}
+
+/**
+ * Aggregate signals across sessions → candidates.
+ * Pure (hermetically testable): takes mined per-session signals, returns candidates.
+ */
+export function aggregate(sessions, { minCmdCount = 3, minCmdSessions = 2, minFileTouches = 5, minFailures = 3 } = {}) {
+  const candidates = [];
+  // commands
+  const cmdStats = new Map(); // cmd -> {count, sessions:Set, failures}
+  for (const s of sessions) {
+    for (const { cmd, failed } of s.commands) {
+      const st = cmdStats.get(cmd) ?? { count: 0, sessions: new Set(), failures: 0 };
+      st.count++;
+      st.sessions.add(s.sessionId);
+      if (failed) st.failures++;
+      cmdStats.set(cmd, st);
+    }
+  }
+  for (const [cmd, st] of cmdStats) {
+    if (st.count >= minCmdCount && st.sessions.size >= minCmdSessions) {
+      candidates.push({
+        candidate: {
+          id: 'command-' + slugify(cmd, 40),
+          type: 'command',
+          body: `Recurring project command: \`${cmd}\` (used ${st.count}× across ${st.sessions.size} sessions${st.failures ? `, failed ${st.failures}×` : ''}).`,
+          attributes: { command: cmd },
+          relations: [],
+          provenance: [...st.sessions].slice(0, 5).map((id) => ({ session: id, ref: 'distill:commands' })),
+        },
+        evidence: { occurrences: st.count, sessions: st.sessions.size, failures: st.failures },
+      });
+    }
+  }
+  // hot files
+  const fileStats = new Map();
+  for (const s of sessions) {
+    for (const f of s.files) {
+      const st = fileStats.get(f) ?? { count: 0, sessions: new Set() };
+      st.count++;
+      st.sessions.add(s.sessionId);
+      fileStats.set(f, st);
+    }
+  }
+  for (const [path, st] of fileStats) {
+    if (st.count >= minFileTouches) {
+      const base = path.split('/').slice(-2).join('/');
+      candidates.push({
+        candidate: {
+          id: 'file-' + slugify(base, 40),
+          type: 'entity',
+          body: `Hot file in this project: \`${path}\` (touched ${st.count}× across ${st.sessions.size} sessions).`,
+          attributes: { path },
+          relations: [],
+          provenance: [...st.sessions].slice(0, 5).map((id) => ({ session: id, ref: 'distill:hot-files' })),
+        },
+        evidence: { occurrences: st.count, sessions: st.sessions.size },
+      });
+    }
+  }
+  // failing tools
+  const failStats = new Map();
+  for (const s of sessions) for (const t of s.failures) failStats.set(t, (failStats.get(t) ?? 0) + 1);
+  for (const [tool, n] of failStats) {
+    if (n >= minFailures) {
+      candidates.push({
+        candidate: {
+          id: 'failing-tool-' + slugify(tool, 30),
+          type: 'fact',
+          body: `Tool \`${tool}\` fails frequently in this project (${n} failures observed) — worth investigating why.`,
+          attributes: {},
+          relations: [],
+          provenance: sessions.filter((s) => s.failures.includes(tool)).slice(0, 5).map((s) => ({ session: s.sessionId, ref: 'distill:failures' })),
+        },
+        evidence: { occurrences: n },
+      });
+    }
+  }
+  return candidates;
+}
+
+/**
+ * Mine one {host, ref} pair into the per-session signal superset (tagged with a
+ * host-prefixed sessionId so cross-host provenance is legible). Tolerant.
+ */
+export function mineHostSession({ host, ref, sessionId }) {
+  try {
+    const adapter = registry.byName(host);
+    if (!adapter || typeof adapter.mineSignals !== 'function') return null;
+    const sig = adapter.mineSignals(ref);
+    const sid = sessionId || (typeof ref === 'string' ? ref : ref?.sessionId) || host;
+    return { sessionId: `${host}:${sid}`, host, ...sig };
+  } catch {
+    return null;
+  }
+}
+
+/** Run the full distill: mine sessions (all hosts) → candidates → ER → proposals. */
+export function distillSessions(agentDir, pairs) {
+  const mined = pairs.map(mineHostSession).filter(Boolean);
+  const candidates = aggregate(mined);
+  const proposals = candidates.map((c) => createProposal(agentDir, { candidate: c.candidate, source: 'distill', evidence: c.evidence }));
+  const registryProposals = fileRegistryProposals(agentDir);
+  return { sessionsMined: mined.length, proposals, registryProposals };
+}
+
+/**
+ * Resolve which transcripts to mine across ALL detected hosts.
+ * Returns `[{host, ref}]`, newest-first, honoring `scope` ('last'|'all') and a
+ * `session` substring filter. (Was claude-only — that starved 4 of 5 hosts.)
+ */
+export function transcriptsFor({ scope = 'all', session = null, cwd = process.cwd() }) {
+  const pairs = [];
+  for (const adapter of registry.detected()) {
+    let sessions = [];
+    try {
+      sessions = adapter.listSessions({ cwd });
+    } catch {
+      continue; // a flaky host (e.g. SQLite on old Node) must not break the rest
+    }
+    for (const s of sessions) pairs.push({ host: adapter.name, ref: s.ref, sessionId: s.sessionId, mtime: s.mtime ?? 0 });
+  }
+  pairs.sort((a, b) => (b.mtime ?? 0) - (a.mtime ?? 0));
+  let filtered = pairs;
+  if (session) filtered = pairs.filter((p) => String(p.sessionId).includes(session));
+  else if (scope === 'last') filtered = pairs.slice(0, 1);
+  return filtered.map((p) => ({ host: p.host, ref: p.ref, sessionId: p.sessionId }));
+}

package/zuzuu/knowledge/embed.mjs

@@ -0,0 +1,52 @@
+// Embeddings — ollama-if-present, else honestly absent.
+//
+// Zero-npm-dep rule holds: ollama is an OPTIONAL local service (default
+// :11434), probed at call time. No keys, nothing leaves the machine. When it's
+// absent, semantic search reports unavailable and lexical+graph carry the day —
+// the vector tier is *earned*, not faked.
+
+const BASE = process.env.OLLAMA_HOST || 'http://localhost:11434';
+// small, common embedding models — first one present wins
+const PREFERRED = ['nomic-embed-text', 'mxbai-embed-large', 'all-minilm'];
+
+async function get(path, opts = {}) {
+  const res = await fetch(BASE + path, { signal: AbortSignal.timeout(opts.timeout ?? 1500), ...opts });
+  if (!res.ok) throw new Error(`${path} → ${res.status}`);
+  return res.json();
+}
+
+/** Probe ollama + pick an embedding model. Never throws. */
+export async function detectEmbedder() {
+  try {
+    const tags = await get('/api/tags');
+    const names = (tags.models ?? []).map((m) => String(m.name));
+    const model = PREFERRED.map((p) => names.find((n) => n.startsWith(p))).find(Boolean);
+    if (!model) return { available: false, reason: `ollama up, no embedding model (pull one of: ${PREFERRED.join(', ')})` };
+    return { available: true, model };
+  } catch {
+    return { available: false, reason: 'ollama not reachable (optional — semantic search needs it)' };
+  }
+}
+
+/** Embed one text → Float array. Throws on failure (callers decide policy). */
+export async function embed(model, text) {
+  const out = await get('/api/embeddings', {
+    method: 'POST',
+    headers: { 'content-type': 'application/json' },
+    body: JSON.stringify({ model, prompt: text }),
+    timeout: 30_000,
+  });
+  if (!Array.isArray(out.embedding)) throw new Error('no embedding in response');
+  return out.embedding;
+}
+
+export function cosine(a, b) {
+  let dot = 0, na = 0, nb = 0;
+  const n = Math.min(a.length, b.length);
+  for (let i = 0; i < n; i++) {
+    dot += a[i] * b[i];
+    na += a[i] * a[i];
+    nb += b[i] * b[i];
+  }
+  return na && nb ? dot / Math.sqrt(na * nb) : 0;
+}

package/zuzuu/knowledge/er.mjs

@@ -0,0 +1,98 @@
+// Entity resolution — the gatekeeper between candidates and canonical items.
+//
+// Pure matcher: given a candidate and the existing items, decide
+//   new        — nothing like it exists
+//   duplicate  — an item already says this (candidate adds nothing)
+//   enrich     — an existing item is the same entity; candidate adds evidence/
+//                attributes/relations → merge into it
+//
+// Deliberately mechanical (v1): exact id → slug-normalized id → token-overlap
+// fuzzy on body+id with attribute corroboration. Deterministic, hermetically
+// testable; an LLM judge is a later, separate rung. Thresholds are conservative:
+// a false "duplicate" silently loses knowledge, a false "new" merely creates a
+// reviewable proposal the human can reject — so we bias toward "new"/"enrich".
+
+import { slugify } from './items.mjs';
+
+const STOP = new Set(['the', 'a', 'an', 'is', 'are', 'this', 'that', 'with', 'for', 'and', 'or', 'of', 'in', 'on', 'to', 'it', 'its', 'project', 's']);
+
+// light stemmer: trailing 's' off words >3 chars (tests→test, runs→run) —
+// enough to stop trivial morphology from sinking real overlaps; no more.
+const stem = (t) => (t.length > 3 && t.endsWith('s') && !t.endsWith('ss') ? t.slice(0, -1) : t);
+
+export function tokens(text) {
+  return new Set(
+    String(text)
+      .toLowerCase()
+      .split(/[^a-z0-9]+/)
+      .filter((t) => t.length > 1 && !STOP.has(t))
+      .map(stem),
+  );
+}
+
+export function jaccard(a, b) {
+  if (!a.size || !b.size) return 0;
+  let inter = 0;
+  for (const t of a) if (b.has(t)) inter++;
+  return inter / (a.size + b.size - inter);
+}
+
+/** Shared attribute VALUES count as strong corroboration (e.g. same command line). */
+function sharedAttrValues(a = {}, b = {}) {
+  let shared = 0;
+  for (const [k, v] of Object.entries(a)) if (k in b && String(b[k]) === String(v)) shared++;
+  return shared;
+}
+
+/**
+ * @param {object} candidate  {id?, type, body, attributes?}
+ * @param {Array}  items      existing canonical items
+ * @returns {{verdict:'new'|'duplicate'|'enrich', match?:string, confidence:number, reason:string}}
+ */
+export function resolve(candidate, items) {
+  const candId = candidate.id || slugify(candidate.body);
+  const candTokens = tokens(`${candId} ${candidate.body ?? ''}`);
+
+  let best = null;
+  for (const item of items) {
+    // 1. exact / slug-normalized id match
+    if (item.id === candId || slugify(item.id) === candId) {
+      best = { item, sim: 1, why: 'id match' };
+      break;
+    }
+    // 2. fuzzy: token overlap + attribute corroboration (same-type only)
+    if (item.type !== candidate.type) continue;
+    const sim = jaccard(candTokens, tokens(`${item.id} ${item.body ?? ''}`));
+    const corroboration = sharedAttrValues(candidate.attributes, item.attributes);
+    const score = sim + corroboration * 0.25;
+    if (!best || score > best.sim) best = { item, sim: score, why: corroboration ? `token overlap + ${corroboration} shared attribute(s)` : 'token overlap' };
+  }
+
+  if (!best || best.sim < 0.5) {
+    return { verdict: 'new', confidence: best ? 1 - best.sim : 1, reason: 'no sufficiently similar item' };
+  }
+  // same entity — duplicate (nothing new) or enrich (new attrs/relations/evidence)?
+  const item = best.item;
+  const newAttrs = Object.entries(candidate.attributes ?? {}).filter(([k, v]) => String(item.attributes?.[k]) !== String(v));
+  const newRels = (candidate.relations ?? []).filter((r) => !(item.relations ?? []).some((e) => e.type === r.type && e.target === r.target));
+  const addsSomething = newAttrs.length || newRels.length || (candidate.provenance ?? []).length;
+  return {
+    verdict: addsSomething ? 'enrich' : 'duplicate',
+    match: item.id,
+    confidence: Math.min(best.sim, 1),
+    reason: best.why,
+  };
+}
+
+/** Merge a candidate into an existing item (enrich verdict). Pure. */
+export function merge(item, candidate) {
+  const merged = { ...item, attributes: { ...item.attributes }, relations: [...(item.relations ?? [])], provenance: [...(item.provenance ?? [])] };
+  for (const [k, v] of Object.entries(candidate.attributes ?? {})) if (!(k in merged.attributes)) merged.attributes[k] = v;
+  for (const r of candidate.relations ?? []) {
+    if (!merged.relations.some((e) => e.type === r.type && e.target === r.target)) merged.relations.push(r);
+  }
+  for (const p of candidate.provenance ?? []) {
+    if (!merged.provenance.some((e) => e.session === p.session && e.ref === p.ref)) merged.provenance.push(p);
+  }
+  return merged;
+}

package/zuzuu/knowledge/inbox.mjs

@@ -0,0 +1,43 @@
+// The inbox — where candidates arrive. Agents (per the faculty block) drop one
+// fact per file into agent/knowledge/inbox/; `zuzuu distill` drops mined candidates
+// the same way. Processing wraps each into an ER'd proposal (the file's full
+// content is preserved inside the proposal JSON) and removes the inbox file.
+//
+// Tolerant input: plain text, or our frontmatter grammar for typed candidates.
+
+import { join, basename } from 'node:path';
+import { existsSync, readFileSync, readdirSync, rmSync } from 'node:fs';
+import { parseItem, slugify } from './items.mjs';
+import { createProposal, fileRegistryProposals } from './proposals.mjs';
+
+export const inboxDir = (agentDir) => join(agentDir, 'knowledge', 'inbox');
+
+/** Lenient candidate parse: full item grammar, or bare prose. */
+export function parseCandidate(text, filename = '') {
+  try {
+    const item = parseItem(text);
+    return { id: item.id, type: item.type, body: item.body, attributes: item.attributes, relations: item.relations, provenance: item.provenance };
+  } catch {
+    const body = text.trim();
+    return { id: slugify(body), type: 'fact', body, attributes: {}, relations: [], provenance: [] };
+  }
+}
+
+/**
+ * Process every inbox file → proposal. Returns {processed, proposals, registryProposals}.
+ * source tags where candidates came from ('agent' for inbox drops).
+ */
+export function processInbox(agentDir, { source = 'agent' } = {}) {
+  const dir = inboxDir(agentDir);
+  if (!existsSync(dir)) return { processed: 0, proposals: [], registryProposals: [] };
+  const proposals = [];
+  for (const f of readdirSync(dir).filter((f) => f.endsWith('.md') || f.endsWith('.txt'))) {
+    const path = join(dir, f);
+    const cand = parseCandidate(readFileSync(path, 'utf8'), f);
+    cand.provenance = [...(cand.provenance ?? []), { session: source, ref: `inbox/${basename(f)}` }];
+    proposals.push(createProposal(agentDir, { candidate: cand, source, evidence: { inboxFile: f } }));
+    rmSync(path); // full candidate now lives inside the proposal
+  }
+  const registryProposals = fileRegistryProposals(agentDir);
+  return { processed: proposals.length, proposals, registryProposals };
+}