@zuzuucodes/cli 1.2.1 → 1.2.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zuzuucodes/cli",
-  "version": "1.2.1",
+  "version": "1.2.2",
   "private": false,
   "publishConfig": {
     "access": "public"

package/zuzuu/commands/distill.mjs

@@ -40,7 +40,10 @@ export function distill(args) {
   }
 
   const r = distillSessions(agentDir, pairs);
-  console.log(`distilled ${r.sessionsMined} session(s) → ${r.proposals.length} proposal(s)${r.registryProposals.length ? ` (+${r.registryProposals.length} registry)` : ''}`);
+  const skips = r.archivedSkips ?? [];
+  console.log(`distilled ${r.sessionsMined} session(s) → ${r.proposals.length} proposal(s)${r.registryProposals.length ? ` (+${r.registryProposals.length} registry)` : ''}${skips.length ? ` (${skips.length} archived-skip)` : ''}`);
   for (const p of r.proposals) console.log(`  ${p.er.verdict.padEnd(9)} ${p.id}`);
+  // already resolved (rejected/approved) in proposals/archive/ — not re-filed
+  for (const p of skips) console.log(`  archived-skip ${p.id} (${p.archived})`);
   if (r.proposals.length) console.log('next: zuzuu review');
 }

package/zuzuu/faculty/proposal.mjs

@@ -96,6 +96,32 @@ export function readProposal(agentDir, faculty, id) {
   }
 }
 
+/**
+ * Read and normalise a resolved proposal from the faculty's archive.
+ * Returns null if no archive record exists or it is unreadable (never throws).
+ */
+export function readArchived(agentDir, faculty, id) {
+  const path = join(archiveDir(agentDir, faculty), `${id}.json`);
+  if (!existsSync(path)) return null;
+  try {
+    return normalise(JSON.parse(readFileSync(path, 'utf8')), faculty);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * True when an id is already resolved in the archive (rejected OR approved).
+ * Policy: a rejection is remembered — filing layers must skip these ids so a
+ * re-distill over the same sessions never resurrects a resolved proposal.
+ * (Approved ids are skipped too: the work is done; ER handles enrichment.)
+ * Gate at the CALLERS — writeProposal stays a dumb writer.
+ */
+export function isArchivedResolved(agentDir, faculty, id) {
+  const rec = readArchived(agentDir, faculty, id);
+  return !!rec && (rec.status === 'rejected' || rec.status === 'approved');
+}
+
 /**
  * List all pending proposals for a faculty (files in proposals/ not in archive/).
  * Normalises each record. Skips unreadable files (fail-soft).

package/zuzuu/knowledge/distill.mjs

@@ -204,13 +204,17 @@ export function mineHostSession({ host, ref, sessionId }) {
   }
 }
 
-/** Run the full distill: mine sessions (all hosts) → candidates → ER → proposals. */
+/** Run the full distill: mine sessions (all hosts) → candidates → ER → proposals.
+ *  Candidates whose id is already resolved in proposals/archive/ are NOT
+ *  re-filed (a rejection is remembered) — they come back as `archivedSkips`. */
 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 results = candidates.map((c) => createProposal(agentDir, { candidate: c.candidate, source: 'distill', evidence: c.evidence }));
+  const proposals = results.filter((p) => p.status !== 'archived-skip');
+  const archivedSkips = results.filter((p) => p.status === 'archived-skip');
   const registryProposals = fileRegistryProposals(agentDir);
-  return { sessionsMined: mined.length, proposals, registryProposals };
+  return { sessionsMined: mined.length, proposals, registryProposals, archivedSkips };
 }
 
 /**

package/zuzuu/knowledge/proposals.mjs

@@ -15,6 +15,7 @@ import { allItems, readItem, writeItem, slugify } from './items.mjs';
 import { upsertItem } from './index.mjs';
 import { resolve as erResolve, merge } from './er.mjs';
 import { mechanicalScore } from '../eval/score.mjs';
+import { readArchived } from '../faculty/proposal.mjs';
 
 export const proposalsDir = (agentDir) => join(agentDir, 'knowledge', 'proposals');
 const archiveDir = (agentDir) => join(proposalsDir(agentDir), 'archive');
@@ -27,12 +28,20 @@ function writeProposal(agentDir, p) {
   return p;
 }
 
-/** Run ER for a candidate and file a pending proposal (deduped per candidate). */
+/** Run ER for a candidate and file a pending proposal (deduped per candidate).
+ *  A rejection is remembered: if the derived id is already RESOLVED in
+ *  proposals/archive/ (rejected or approved), nothing is filed — the call
+ *  returns `{ id, status: 'archived-skip', archived: <resolved status> }` so
+ *  callers can count/report the skip instead of resurrecting the proposal. */
 export function createProposal(agentDir, { candidate, source, evidence = {} }) {
   const { items } = allItems(agentDir);
   candidate.id = candidate.id || slugify(candidate.body);
   const er = erResolve(candidate, items);
   const id = `${candidate.id}-${shortHash(candidate.id + source)}`;
+  const archived = readArchived(agentDir, 'knowledge', id);
+  if (archived && (archived.status === 'rejected' || archived.status === 'approved')) {
+    return { id, status: 'archived-skip', archived: archived.status };
+  }
   const existing = join(proposalsDir(agentDir), `${id}.json`);
   if (existsSync(existing)) {
     // refresh evidence on the pending proposal instead of duplicating it

package/zuzuu/miners/guardrails.mjs

@@ -18,7 +18,7 @@
 import { join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
 import { slugify } from '../knowledge/items.mjs';
-import { makeProposal, writeProposal, listProposals } from '../faculty/proposal.mjs';
+import { makeProposal, writeProposal, listProposals, isArchivedResolved } from '../faculty/proposal.mjs';
 import { register } from './registry.mjs';
 
 // ---------------------------------------------------------------------------
@@ -127,6 +127,8 @@ export function aggregate(sessions, { minFailures = 3, minSessions = 2 } = {}) {
  * Idempotent:
  *   - skips if a guardrails proposal with the same payload.id already exists
  *   - skips if rules.json already has a rule with that id
+ *   - skips if the id is already resolved in proposals/archive/ — a rejection
+ *     is remembered; re-distilling never resurrects it
  *
  * The proposals flow through `zuzuu review` → guardrails adapter on approval.
  *
@@ -159,6 +161,9 @@ export function propose(agentDir, aggregated) {
       evidence,
     });
 
+    // A rejection is remembered: never resurrect an archive-resolved id.
+    if (isArchivedResolved(agentDir, 'guardrails', proposal.id)) continue;
+
     writeProposal(agentDir, proposal);
     count++;
   }

package/zuzuu/miners/instructions.mjs

@@ -11,7 +11,7 @@
 
 import { join } from 'node:path';
 import { existsSync, readFileSync } from 'node:fs';
-import { makeProposal, writeProposal, listProposals } from '../faculty/proposal.mjs';
+import { makeProposal, writeProposal, listProposals, isArchivedResolved } from '../faculty/proposal.mjs';
 import { register } from './registry.mjs';
 
 // ---------------------------------------------------------------------------
@@ -103,6 +103,8 @@ export function aggregate(sessions, { minSessions = 2 } = {}) {
  * Idempotent:
  *   - skips if an instructions proposal with the same derived id already exists
  *   - skips if the text is already present in project.md
+ *   - skips if the id is already resolved in proposals/archive/ — a rejection
+ *     is remembered; re-distilling never resurrects it
  *
  * @param {string} agentDir
  * @param {ReturnType<typeof aggregate>} aggregated
@@ -137,6 +139,9 @@ export function propose(agentDir, aggregated) {
       evidence,
     });
 
+    // A rejection is remembered: never resurrect an archive-resolved id.
+    if (isArchivedResolved(agentDir, 'instructions', proposal.id)) continue;
+
     writeProposal(agentDir, proposal);
     count++;
   }

package/zuzuu/miners/knowledge.mjs

@@ -7,12 +7,15 @@ import { aggregate } from '../knowledge/distill.mjs';
 import { createProposal } from '../knowledge/proposals.mjs';
 import { register } from './registry.mjs';
 
-/** File one knowledge proposal per aggregated candidate; return the count. */
+/** File one knowledge proposal per aggregated candidate; return the count of
+ *  actually-filed proposals (archive-resolved ids are skipped, not re-filed). */
 export function propose(agentDir, aggregated) {
+  let count = 0;
   for (const c of aggregated) {
-    createProposal(agentDir, { candidate: c.candidate, source: 'distill', evidence: c.evidence });
+    const p = createProposal(agentDir, { candidate: c.candidate, source: 'distill', evidence: c.evidence });
+    if (p && p.status !== 'archived-skip') count++;
   }
-  return aggregated.length;
+  return count;
 }
 
 export const miner = { faculty: 'knowledge', aggregate, propose };