@remnic/core 10.0.9 → 10.0.11

package/dist/{chunk-2K7D6EFT.js → chunk-L3G5CGL5.js}

@@ -1,32 +1,560 @@
 import {
   SharedFeedbackEntrySchema,
-  resolveSharedContextDir
-} from "./chunk-77HNHT6S.js";
+  migrateLegacyFeedbackInbox,
+  resolveFeedbackInboxPath
+} from "./chunk-E57LYSHI.js";
 import {
   composeSalvagedEnvelope
 } from "./chunk-ZSJGYC3C.js";
 import {
-  StorageManager
-} from "./chunk-WJLGUY27.js";
+  resolveDefaultNamespaceRoot
+} from "./chunk-D5UPBXZM.js";
+import {
+  StorageManager,
+  readRawMemoryDocument
+} from "./chunk-BD5QEP3T.js";
 import {
   parseContinuityImprovementLoops
 } from "./chunk-LDXUBPMO.js";
+import {
+  getKey,
+  secureStoreDir
+} from "./chunk-BJMBJZ2Y.js";
+import {
+  readMaybeEncryptedLines
+} from "./chunk-FQD2KPQH.js";
+import {
+  assertPathInsideRoot
+} from "./chunk-C7HJ3NEI.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
+import {
+  isSafeRouteNamespace
+} from "./chunk-PCXDUHQH.js";
+import {
+  namespaceIdentityFromToken
+} from "./chunk-VUFL7X3H.js";
 import {
   resolveConsolidationCapabilities,
   resolveConversationContextCapabilities,
   resolveQmdCapabilities
 } from "./chunk-2EMROIXS.js";
+import {
+  readMaybeEncryptedFile
+} from "./chunk-MAAL6OZV.js";
+import {
+  isErrnoCode
+} from "./chunk-KNA3BXXL.js";
 import {
   log
 } from "./chunk-3WCASNQZ.js";
 
 // src/compounding/engine.ts
 import { createHash } from "crypto";
-import { mkdir, readFile, readdir, unlink, writeFile } from "fs/promises";
+import { mkdir, readFile as readFile2, readdir as readdir2, unlink, writeFile } from "fs/promises";
+import path2 from "path";
+
+// src/compounding/iso-week.ts
+var DAY_MS = 864e5;
+var WEEK_MS = 7 * DAY_MS;
+function isoWeekId(d) {
+  const dt = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
+  const day = dt.getUTCDay() || 7;
+  dt.setUTCDate(dt.getUTCDate() + 4 - day);
+  const yearStart = new Date(Date.UTC(dt.getUTCFullYear(), 0, 1));
+  const week = Math.ceil(((dt.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
+  const yyyy = dt.getUTCFullYear();
+  return `${yyyy}-W${String(week).padStart(2, "0")}`;
+}
+function isIsoWeekId(weekId) {
+  if (weekId.length !== 8 || weekId[4] !== "-" || weekId[5] !== "W") return false;
+  const year = weekId.slice(0, 4);
+  const week = weekId.slice(6);
+  for (let i = 0; i < year.length; i += 1) {
+    const code = year.charCodeAt(i);
+    if (code < 48 || code > 57) return false;
+  }
+  for (let i = 0; i < week.length; i += 1) {
+    const code = week.charCodeAt(i);
+    if (code < 48 || code > 57) return false;
+  }
+  const weekNum = Number(week);
+  return weekNum >= 1 && weekNum <= 53;
+}
+
+// src/compounding/weekly-evidence.ts
+import { lstat, readFile, readdir, realpath } from "fs/promises";
 import path from "path";
+var DAY_MS2 = 864e5;
+var WEEKLY_CORRECTION_READ_LIMIT = 500;
+var WEEKLY_CORRECTION_SCAN_LIMIT = 2e3;
+var CORRECTION_FILE_BYTE_LIMIT = 256 * 1024;
+var CORRECTION_NOTE_LIMIT = 240;
+function isoWeekStartMs(weekId) {
+  if (!isIsoWeekId(weekId)) return null;
+  const year = Number(weekId.slice(0, 4));
+  const week = Number(weekId.slice(6));
+  const jan4 = Date.UTC(year, 0, 4);
+  const jan4Day = new Date(jan4).getUTCDay() || 7;
+  const start = jan4 - (jan4Day - 1) * DAY_MS2 + (week - 1) * 7 * DAY_MS2;
+  if (isoWeekId(new Date(start)) !== weekId) return null;
+  return start;
+}
+async function readFeedbackEntriesForWeekFile(inboxPath, weekId) {
+  const out = [];
+  try {
+    const raw = await readFile(inboxPath, "utf-8");
+    const lines = raw.split("\n");
+    for (let idx = 0; idx < lines.length; idx += 1) {
+      const line = lines[idx];
+      if (!line.trim()) continue;
+      try {
+        const obj = JSON.parse(line);
+        const parsed = SharedFeedbackEntrySchema.safeParse(obj);
+        if (!parsed.success) continue;
+        const d = new Date(parsed.data.date);
+        if (!Number.isFinite(d.getTime())) continue;
+        if (isoWeekId(d) !== weekId) continue;
+        const sourceLine = idx + 1;
+        out.push({
+          entry: parsed.data,
+          sourceLine,
+          sourcePath: inboxPath,
+          entryId: `${parsed.data.agent}-${parsed.data.date}-${sourceLine}`.replace(/[^a-zA-Z0-9._:-]/g, "_")
+        });
+      } catch {
+      }
+    }
+  } catch {
+  }
+  return out;
+}
+function buildActionFailurePatterns(events) {
+  const out = [];
+  for (const event of events) {
+    const failed = event.outcome === "failed" || event.outcome === "skipped";
+    if (!failed && event.policyDecision === null) continue;
+    const suffix = event.reason && event.reason.trim().length > 0 ? ` - ${event.reason.trim().slice(0, 140)}` : "";
+    out.push({
+      pattern: `memory-action/${event.namespace}: ${event.action} ${event.outcome}${event.policyDecision ? `/${event.policyDecision}` : ""}${suffix}`,
+      provenance: `${event.ledgerLabel}:*`
+    });
+  }
+  return out;
+}
+async function readWeeklyActionEvents(input) {
+  const seenActionIds = /* @__PURE__ */ new Set();
+  const out = [];
+  const rootRows = await input.storage.readMemoryActionEventRows(Number.MAX_SAFE_INTEGER);
+  for (const row of rootRows) {
+    pushActionEvent(out, seenActionIds, row.line, row.event, "default", "memory-actions.jsonl", input.weekId);
+  }
+  const rootReal = await realpath(input.memoryDir);
+  const namespaces = await listNamespaceStorageDirs(input.memoryDir, rootReal);
+  const key = getKey(secureStoreDir(input.memoryDir));
+  for (const ns of namespaces) {
+    const filePath = path.join(ns.root, "state", "memory-actions.jsonl");
+    const label = `namespaces/${ns.dirName}/state/memory-actions.jsonl`;
+    let entryStat;
+    try {
+      entryStat = await lstat(filePath);
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) continue;
+      throw err;
+    }
+    if (entryStat.isSymbolicLink() || !entryStat.isFile()) continue;
+    const fileReal = await realpath(filePath);
+    assertPathInsideRoot(rootReal, fileReal, filePath);
+    try {
+      let lineNumber = 0;
+      for await (const row of readMaybeEncryptedLines(
+        filePath,
+        () => readMaybeEncryptedFile(filePath, key, input.memoryDir)
+      )) {
+        lineNumber += 1;
+        const line = row.trim();
+        if (line.length === 0) continue;
+        const event = parseMemoryActionEventLine(line);
+        if (!event) continue;
+        pushActionEvent(out, seenActionIds, lineNumber, event, ns.namespace, label, input.weekId);
+      }
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) continue;
+      throw err;
+    }
+  }
+  return out;
+}
+async function readWeeklyCorrections(input) {
+  const weekStartMs = isoWeekStartMs(input.weekId);
+  if (weekStartMs === null) return [];
+  const rootReal = await realpath(input.memoryDir);
+  const candidates = [];
+  await collectCorrectionCandidates(candidates, input.memoryDir, "default", input.weekId, weekStartMs, rootReal);
+  const namespaces = await listNamespaceStorageDirs(input.memoryDir, rootReal);
+  for (const ns of namespaces) {
+    await collectCorrectionCandidates(candidates, ns.root, ns.namespace, input.weekId, weekStartMs, rootReal);
+  }
+  candidates.sort((a, b) => b.sortMs - a.sortMs || a.filePath.localeCompare(b.filePath));
+  const ordered = preferVisibleCorrectionCandidates(
+    candidates,
+    input.memoryDir,
+    input.defaultNamespacePrefix ?? null
+  );
+  const out = [];
+  let scanned = 0;
+  for (const candidate of ordered) {
+    if (out.length >= WEEKLY_CORRECTION_READ_LIMIT || scanned >= WEEKLY_CORRECTION_SCAN_LIMIT) break;
+    scanned += 1;
+    const evidence = await readCorrectionCandidate(input.storage, input.memoryDir, input.weekId, candidate);
+    if (evidence) out.push(evidence);
+  }
+  if (scanned < candidates.length) {
+    log.warn(
+      `weekly synthesis kept ${out.length} accepted corrections after scanning ${scanned} of ${candidates.length} in-week candidates`
+    );
+  }
+  return out;
+}
+function preferVisibleCorrectionCandidates(candidates, memoryDir, defaultNamespacePrefix) {
+  const visible = [];
+  const foreign = [];
+  for (const candidate of candidates) {
+    const relative = path.relative(memoryDir, candidate.filePath).split(path.sep).join("/");
+    if (provenanceVisibleInStoreRecall([relative], defaultNamespacePrefix)) visible.push(candidate);
+    else foreign.push(candidate);
+  }
+  return visible.concat(foreign);
+}
+function parseMemoryActionEventLine(line) {
+  let parsed;
+  try {
+    parsed = JSON.parse(line);
+  } catch {
+    return null;
+  }
+  if (parsed.recordKind !== void 0) return null;
+  const outcome = parsed.outcome === "applied" || parsed.outcome === "skipped" || parsed.outcome === "failed" ? parsed.outcome : null;
+  const timestamp = parsed.timestamp;
+  const action = parsed.action;
+  if (typeof timestamp !== "string" || typeof action !== "string" || outcome === null) return null;
+  return { ...parsed, timestamp, action, outcome };
+}
+function pushActionEvent(out, seenActionIds, line, event, fallbackNamespace, ledgerLabel, weekId) {
+  const ts = new Date(event.timestamp);
+  if (!Number.isFinite(ts.getTime()) || isoWeekId(ts) !== weekId) return;
+  const actionId = typeof event.actionId === "string" && event.actionId.length > 0 ? event.actionId : null;
+  if (actionId) {
+    if (seenActionIds.has(actionId)) return;
+    seenActionIds.add(actionId);
+  }
+  out.push({
+    line,
+    action: event.action,
+    outcome: event.outcome,
+    policyDecision: event.policyDecision === "deny" || event.policyDecision === "defer" ? event.policyDecision : null,
+    namespace: typeof event.namespace === "string" && event.namespace.length > 0 ? event.namespace : fallbackNamespace,
+    reason: typeof event.reason === "string" ? event.reason : null,
+    ledgerLabel,
+    actionId
+  });
+}
+async function listNamespaceStorageDirs(memoryDir, rootReal) {
+  const nsRoot = path.join(memoryDir, "namespaces");
+  let rootStat;
+  try {
+    rootStat = await lstat(nsRoot);
+  } catch (err) {
+    if (isErrnoCode(err, "ENOENT")) return [];
+    throw err;
+  }
+  if (rootStat.isSymbolicLink() || !rootStat.isDirectory()) return [];
+  const nsReal = await realpath(nsRoot);
+  assertPathInsideRoot(rootReal, nsReal, nsRoot);
+  const names = await readdir(nsRoot);
+  const out = [];
+  for (const dirName of names) {
+    const namespace = namespaceFromDirName(dirName);
+    if (!namespace) continue;
+    const root = path.join(nsRoot, dirName);
+    let entryStat;
+    try {
+      entryStat = await lstat(root);
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) continue;
+      throw err;
+    }
+    if (entryStat.isSymbolicLink() || !entryStat.isDirectory()) continue;
+    const dirReal = await realpath(root);
+    assertPathInsideRoot(rootReal, dirReal, root);
+    out.push({ dirName, namespace, root });
+  }
+  out.sort((a, b) => a.dirName.localeCompare(b.dirName));
+  return out;
+}
+function namespaceFromDirName(dirName) {
+  if (dirName.length === 0 || dirName.includes("/") || dirName.includes("\\") || dirName.includes("..")) {
+    return null;
+  }
+  if (dirName.startsWith("ns-")) {
+    const decoded = namespaceIdentityFromToken(dirName);
+    if (decoded === null) return null;
+    if (decoded.length === 0) return "default";
+    return isSafeRouteNamespace(decoded) ? decoded : null;
+  }
+  return isSafeRouteNamespace(dirName) ? dirName : null;
+}
+async function collectCorrectionCandidates(candidates, storageRoot, namespace, weekId, weekStartMs, rootReal) {
+  await collectCorrectionDir(
+    candidates,
+    path.join(storageRoot, "corrections"),
+    namespace,
+    weekId,
+    weekStartMs,
+    rootReal
+  );
+  const factsDir = path.join(storageRoot, "facts");
+  const dayNames = await readContainedDirNames(factsDir, rootReal);
+  if (!dayNames) return;
+  for (const dayName of dayNames) {
+    if (!utcDayDirInWeek(dayName, weekId)) continue;
+    await collectCorrectionDir(candidates, path.join(factsDir, dayName), namespace, weekId, weekStartMs, rootReal);
+  }
+}
+async function collectCorrectionDir(candidates, dir, namespace, weekId, weekStartMs, rootReal) {
+  const names = await readContainedDirNames(dir, rootReal);
+  if (!names) return;
+  for (const name of names) {
+    if (!name.startsWith("correction-") || !name.endsWith(".md")) continue;
+    const filenameMs = correctionFilenameTimestampMs(name);
+    if (filenameMs !== null && isoWeekId(new Date(filenameMs)) !== weekId) continue;
+    const filePath = path.join(dir, name);
+    let entryStat;
+    try {
+      entryStat = await lstat(filePath);
+    } catch (err) {
+      if (isErrnoCode(err, "ENOENT")) continue;
+      throw err;
+    }
+    if (entryStat.isSymbolicLink() || !entryStat.isFile()) continue;
+    if (entryStat.size > CORRECTION_FILE_BYTE_LIMIT) continue;
+    const fileReal = await realpath(filePath);
+    assertPathInsideRoot(rootReal, fileReal, filePath);
+    if (filenameMs !== null) {
+      candidates.push({ filePath, sortMs: filenameMs, namespace });
+      continue;
+    }
+    if (entryStat.mtimeMs < weekStartMs) continue;
+    candidates.push({ filePath, sortMs: entryStat.mtimeMs, namespace });
+  }
+}
+async function readContainedDirNames(dir, rootReal) {
+  let entryStat;
+  try {
+    entryStat = await lstat(dir);
+  } catch (err) {
+    if (isErrnoCode(err, "ENOENT")) return null;
+    throw err;
+  }
+  if (entryStat.isSymbolicLink() || !entryStat.isDirectory()) return null;
+  const dirReal = await realpath(dir);
+  assertPathInsideRoot(rootReal, dirReal, dir);
+  return readdir(dir);
+}
+function utcDayDirInWeek(name, weekId) {
+  if (name.length !== 10 || name[4] !== "-" || name[7] !== "-") return false;
+  for (let i = 0; i < name.length; i += 1) {
+    if (i === 4 || i === 7) continue;
+    const code = name.charCodeAt(i);
+    if (code < 48 || code > 57) return false;
+  }
+  const year = Number(name.slice(0, 4));
+  const month = Number(name.slice(5, 7));
+  const day = Number(name.slice(8, 10));
+  if (month < 1 || month > 12 || day < 1 || day > 31) return false;
+  const stamp = new Date(Date.UTC(year, month - 1, day));
+  if (stamp.getUTCFullYear() !== year || stamp.getUTCMonth() !== month - 1 || stamp.getUTCDate() !== day) {
+    return false;
+  }
+  return isoWeekId(stamp) === weekId;
+}
+function correctionFilenameTimestampMs(fileName) {
+  const prefix = "correction-";
+  if (!fileName.startsWith(prefix) || !fileName.endsWith(".md")) return null;
+  const rest = fileName.slice(prefix.length, fileName.length - 3);
+  let i = 0;
+  while (i < rest.length) {
+    const code = rest.charCodeAt(i);
+    if (code < 48 || code > 57) break;
+    i += 1;
+  }
+  if (i < 10) return null;
+  if (i < rest.length && rest[i] !== "-") return null;
+  const ms = Number(rest.slice(0, i));
+  if (!Number.isSafeInteger(ms)) return null;
+  return ms;
+}
+async function readCorrectionCandidate(storage, memoryDir, weekId, candidate) {
+  const memory = await storage.readMemoryByPath(candidate.filePath);
+  if (!memory) return null;
+  const raw = readRawMemoryDocument(memory);
+  if (!raw) return null;
+  if (rawFrontmatterScalar(raw, "category") !== "correction") return null;
+  const status = rawFrontmatterScalar(raw, "status");
+  if (status && status !== "active") return null;
+  const created = rawFrontmatterScalar(raw, "created");
+  if (!created) return null;
+  const createdDate = new Date(created);
+  if (!Number.isFinite(createdDate.getTime()) || isoWeekId(createdDate) !== weekId) return null;
+  const note = collapseWhitespace(memory.content).slice(0, CORRECTION_NOTE_LIMIT);
+  if (note.length === 0) return null;
+  const rawSource = rawFrontmatterScalar(raw, "source");
+  const source = rawSource && rawSource !== "unknown" ? rawSource : null;
+  const entityRef = typeof memory.frontmatter.entityRef === "string" && memory.frontmatter.entityRef.length > 0 ? memory.frontmatter.entityRef : null;
+  const confidence = rawConfidence(raw);
+  const tags = Array.isArray(memory.frontmatter.tags) ? memory.frontmatter.tags.filter((tag) => typeof tag === "string" && tag.length > 0) : [];
+  const id = typeof memory.frontmatter.id === "string" && memory.frontmatter.id.length > 0 ? memory.frontmatter.id : path.basename(candidate.filePath, ".md");
+  return {
+    id,
+    namespace: candidate.namespace,
+    pattern: `correction: ${note}`,
+    note,
+    created,
+    source,
+    entityRef,
+    confidence,
+    tags,
+    provenance: path.relative(memoryDir, candidate.filePath).split(path.sep).join("/")
+  };
+}
+async function defaultNamespaceRecallPrefix(config) {
+  const root = await resolveDefaultNamespaceRoot(config);
+  const rel = path.relative(path.resolve(config.memoryDir), path.resolve(root));
+  if (rel === "" || rel === "." || rel.startsWith("..") || path.isAbsolute(rel)) return null;
+  const posix = rel.split(path.sep).join("/");
+  if (!posix.startsWith("namespaces/")) return null;
+  return `${posix}/`;
+}
+function visibleRubricEntries(entries, observationsFor, defaultNamespacePrefix) {
+  return entries.flatMap((entry) => {
+    const visible = observationsFor(entry).filter(
+      (item) => provenanceVisibleInStoreRecall(item.provenance, defaultNamespacePrefix)
+    );
+    if (visible.length === 0) return [];
+    return [{
+      ...entry,
+      observations: visible.map((item) => item.note),
+      provenance: [...new Set(visible.flatMap((item) => item.provenance))],
+      observationEntries: visible
+    }];
+  });
+}
+function capWeeklyPatternDetails(details, categoryFor, defaultNamespacePrefix, limit = 500) {
+  const visibleActions = [];
+  const visibleOther = [];
+  const foreign = [];
+  for (const detail of details) {
+    if (!provenanceVisibleInStoreRecall(detail.provenance, defaultNamespacePrefix)) {
+      foreign.push(detail);
+      continue;
+    }
+    if (categoryFor(detail.pattern) === "action") visibleActions.push(detail);
+    else visibleOther.push(detail);
+  }
+  return [...visibleActions, ...visibleOther, ...foreign].slice(0, limit);
+}
+async function forgottenCorrectionPatterns(storage, memoryDir, registry, defaultNamespacePrefix) {
+  const out = /* @__PURE__ */ new Set();
+  for (const entry of registry) {
+    if (entry.category !== "correction" || entry.status !== "active") continue;
+    const visible = (entry.provenance ?? []).filter(
+      (item) => provenanceVisibleInStoreRecall([item], defaultNamespacePrefix)
+    );
+    if (visible.length === 0) continue;
+    let stillActive = false;
+    for (const rel of visible) {
+      if (rel.includes("..") || path.isAbsolute(rel)) {
+        stillActive = true;
+        break;
+      }
+      let memory;
+      try {
+        memory = await storage.readMemoryByPath(path.join(memoryDir, rel));
+      } catch {
+        stillActive = true;
+        break;
+      }
+      if (!memory) {
+        const sourcePath = path.join(memoryDir, rel);
+        try {
+          await lstat(sourcePath);
+          stillActive = true;
+          break;
+        } catch (err) {
+          if (!isErrnoCode(err, "ENOENT")) {
+            stillActive = true;
+            break;
+          }
+        }
+        continue;
+      }
+      const raw = readRawMemoryDocument(memory);
+      const status = raw ? rawFrontmatterScalar(raw, "status") : void 0;
+      if (!status || status === "active") {
+        stillActive = true;
+        break;
+      }
+    }
+    if (!stillActive) out.add(entry.pattern);
+  }
+  return out;
+}
+function provenanceVisibleInStoreRecall(provenance, defaultNamespacePrefix = null) {
+  return provenance.length === 0 || provenance.some((item) => {
+    if (!item.startsWith("namespaces/")) return true;
+    return defaultNamespacePrefix !== null && item.startsWith(defaultNamespacePrefix);
+  });
+}
+function actionEventsVisibleInStore(events, defaultNamespacePrefix) {
+  return events.filter(
+    (event) => provenanceVisibleInStoreRecall([`${event.ledgerLabel}:L${event.line}`], defaultNamespacePrefix)
+  );
+}
+function collapseWhitespace(value) {
+  return value.replace(/\s+/g, " ").trim();
+}
+function rawConfidence(raw) {
+  const text = rawFrontmatterScalar(raw, "confidence");
+  if (!text) return null;
+  const value = Number(text);
+  if (!Number.isFinite(value)) return null;
+  return Math.max(0, Math.min(1, value));
+}
+function rawFrontmatterScalar(raw, key) {
+  const newline = raw.startsWith("---\r\n") ? 5 : raw.startsWith("---\n") ? 4 : -1;
+  if (newline < 0) return void 0;
+  const headerEnd = raw.indexOf("\n---", newline);
+  if (headerEnd < 0) return void 0;
+  const block = raw.slice(newline, headerEnd);
+  const prefix = `${key}:`;
+  for (const line of block.split("\n")) {
+    const normalized = line.endsWith("\r") ? line.slice(0, -1) : line;
+    if (normalized.startsWith(" ") || normalized.startsWith("	")) continue;
+    if (!normalized.startsWith(prefix)) continue;
+    let value = normalized.slice(prefix.length).trim();
+    if (value.length >= 2) {
+      const quote = value[0];
+      if ((quote === '"' || quote === "'") && value.endsWith(quote)) {
+        value = value.slice(1, -1);
+      }
+    }
+    return value.length > 0 ? value : void 0;
+  }
+  return void 0;
+}
+
+// src/compounding/engine.ts
 var COMPOUNDING_VERSION = 2;
 var RETIREMENT_WINDOW_WEEKS = 8;
 function stableSlug(value) {
@@ -116,6 +644,13 @@ function inferLegacyMistakeMetadata(pattern) {
       workflow: "memory-actions"
     };
   }
+  if (pattern.startsWith("correction:")) {
+    return {
+      category: "correction",
+      agent: null,
+      workflow: "corrections"
+    };
+  }
   const scope = inferLegacyMistakeScope(pattern);
   return {
     category: "feedback",
@@ -184,15 +719,6 @@ function defaultTierMigrationCycleBudget(config, trigger) {
     minIntervalMs: resolveQmdCapabilities(config).qmdTierAutoBackfill ? 12e4 : 3e5
   };
 }
-function isoWeekId(d) {
-  const dt = new Date(Date.UTC(d.getUTCFullYear(), d.getUTCMonth(), d.getUTCDate()));
-  const day = dt.getUTCDay() || 7;
-  dt.setUTCDate(dt.getUTCDate() + 4 - day);
-  const yearStart = new Date(Date.UTC(dt.getUTCFullYear(), 0, 1));
-  const week = Math.ceil(((dt.getTime() - yearStart.getTime()) / 864e5 + 1) / 7);
-  const yyyy = dt.getUTCFullYear();
-  return `${yyyy}-W${String(week).padStart(2, "0")}`;
-}
 function isoMonthId(d) {
   return `${d.getUTCFullYear()}-${String(d.getUTCMonth() + 1).padStart(2, "0")}`;
 }
@@ -227,17 +753,16 @@ var CompoundingEngine = class {
   constructor(config, storage = new StorageManager(config.memoryDir)) {
     this.config = config;
     this.storage = storage;
-    this.weeklyDir = path.join(config.memoryDir, "compounding", "weekly");
-    this.rubricsDir = path.join(config.memoryDir, "compounding", "rubrics");
-    this.rubricsIndexPath = path.join(this.rubricsDir, "index.json");
-    this.rubricsAgentsDir = path.join(this.rubricsDir, "agents");
-    this.rubricsWorkflowsDir = path.join(this.rubricsDir, "workflows");
-    this.rubricsPath = path.join(config.memoryDir, "compounding", "rubrics.md");
-    this.mistakesPath = path.join(config.memoryDir, "compounding", "mistakes.json");
-    this.feedbackInboxPath = path.join(resolveSharedContextDir(config), "feedback", "inbox.jsonl");
-    this.identityAuditWeeklyDir = path.join(config.memoryDir, "identity", "audits", "weekly");
-    this.identityAuditMonthlyDir = path.join(config.memoryDir, "identity", "audits", "monthly");
-    this.memoryActionEventsPath = path.join(config.memoryDir, "state", "memory-actions.jsonl");
+    this.weeklyDir = path2.join(config.memoryDir, "compounding", "weekly");
+    this.rubricsDir = path2.join(config.memoryDir, "compounding", "rubrics");
+    this.rubricsIndexPath = path2.join(this.rubricsDir, "index.json");
+    this.rubricsAgentsDir = path2.join(this.rubricsDir, "agents");
+    this.rubricsWorkflowsDir = path2.join(this.rubricsDir, "workflows");
+    this.rubricsPath = path2.join(config.memoryDir, "compounding", "rubrics.md");
+    this.mistakesPath = path2.join(config.memoryDir, "compounding", "mistakes.json");
+    this.feedbackInboxPath = resolveFeedbackInboxPath(config);
+    this.identityAuditWeeklyDir = path2.join(config.memoryDir, "identity", "audits", "weekly");
+    this.identityAuditMonthlyDir = path2.join(config.memoryDir, "identity", "audits", "monthly");
   }
   config;
   storage;
@@ -251,11 +776,10 @@ var CompoundingEngine = class {
   feedbackInboxPath;
   identityAuditWeeklyDir;
   identityAuditMonthlyDir;
-  memoryActionEventsPath;
   async ensureDirs() {
     await mkdir(this.weeklyDir, { recursive: true });
-    await mkdir(path.dirname(this.mistakesPath), { recursive: true });
-    await mkdir(path.dirname(this.rubricsPath), { recursive: true });
+    await mkdir(path2.dirname(this.mistakesPath), { recursive: true });
+    await mkdir(path2.dirname(this.rubricsPath), { recursive: true });
     await mkdir(this.rubricsDir, { recursive: true });
     await mkdir(this.rubricsAgentsDir, { recursive: true });
     await mkdir(this.rubricsWorkflowsDir, { recursive: true });
@@ -263,14 +787,33 @@ var CompoundingEngine = class {
   async synthesizeWeekly(opts) {
     await this.ensureDirs();
     const weekId = opts?.weekId ?? isoWeekId(/* @__PURE__ */ new Date());
-    const entries = await this.readFeedbackEntriesForWeek(weekId);
-    const actionEvents = await this.readActionEventsForWeek(weekId);
-    const actionPatterns = this.buildActionFailurePatterns(actionEvents);
+    try {
+      await migrateLegacyFeedbackInbox(this.config);
+    } catch (error) {
+      log.warn(`[compounding] legacy feedback inbox migration failed (non-fatal): ${error instanceof Error ? error.message : String(error)}`);
+    }
+    const entries = await readFeedbackEntriesForWeekFile(this.feedbackInboxPath, weekId);
+    const actionEvents = await readWeeklyActionEvents({
+      storage: this.storage,
+      memoryDir: this.config.memoryDir,
+      weekId
+    });
+    const defaultPrefix = await defaultNamespaceRecallPrefix(this.config);
+    const corrections = await readWeeklyCorrections({
+      storage: this.storage,
+      memoryDir: this.config.memoryDir,
+      weekId,
+      defaultNamespacePrefix: defaultPrefix
+    });
+    const actionPatterns = buildActionFailurePatterns(actionEvents);
     const outcomeSummary = this.buildActionOutcomeSummary(actionEvents);
+    const storeOutcomeSummary = this.buildActionOutcomeSummary(actionEventsVisibleInStore(actionEvents, defaultPrefix));
     const previousMistakes = await this.readMistakes();
-    const mistakes = this.buildMistakes(entries, actionPatterns, weekId, previousMistakes?.registry ?? []);
-    const rubrics = this.buildRubricSnapshot(entries, outcomeSummary);
-    let promotionCandidates = resolveConsolidationCapabilities(this.config).compoundingSemantic ? this.derivePromotionCandidates(outcomeSummary, mistakes.registry, rubrics) : [];
+    const priorRegistry = previousMistakes?.registry ?? [];
+    const forgottenPatterns = await forgottenCorrectionPatterns(this.storage, this.config.memoryDir, priorRegistry, defaultPrefix);
+    const mistakes = this.buildMistakes(entries, actionPatterns, corrections, weekId, priorRegistry, defaultPrefix, forgottenPatterns);
+    const rubrics = this.buildRubricSnapshot(entries, storeOutcomeSummary, corrections);
+    let promotionCandidates = resolveConsolidationCapabilities(this.config).compoundingSemantic ? this.derivePromotionCandidates(storeOutcomeSummary, mistakes.registry, rubrics, defaultPrefix) : [];
     if (resolveConversationContextCapabilities(this.config).cmcConsolidation) {
       try {
         const { deriveCausalPromotionCandidates, materializeAfterCausalConsolidation } = await import("./causal-consolidation.js");
@@ -315,10 +858,10 @@ var CompoundingEngine = class {
       }
     }
     const continuity = resolveConsolidationCapabilities(this.config).continuityAudit ? await this.readContinuityAuditReferences(weekId) : { monthId: monthIdFromIsoWeek(weekId), weeklyPath: null, monthlyPath: null };
-    const reportPath = path.join(this.weeklyDir, `${weekId}.md`);
+    const reportPath = path2.join(this.weeklyDir, `${weekId}.md`);
     const md = this.formatWeeklyReport(weekId, entries, mistakes.patterns, mistakes.details, continuity, outcomeSummary, promotionCandidates);
     await writeFile(reportPath, md, "utf-8");
-    const reportJsonPath = path.join(this.weeklyDir, `${weekId}.json`);
+    const reportJsonPath = path2.join(this.weeklyDir, `${weekId}.json`);
     const weeklyArtifact = {
       version: COMPOUNDING_VERSION,
       generatedAt: mistakes.updatedAt,
@@ -340,7 +883,7 @@ var CompoundingEngine = class {
           severity: wrapped.entry.severity ?? null,
           confidence: normalizeConfidence(wrapped.entry.confidence),
           tags: normalizeTags(wrapped.entry.tags),
-          provenance: `${path.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`,
+          provenance: `${path2.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`,
           evidenceWindow: normalizeEvidenceWindow(wrapped.entry.evidenceWindowStart, wrapped.entry.evidenceWindowEnd)
         }))
       },
@@ -355,7 +898,7 @@ var CompoundingEngine = class {
       continuity
     };
     await writeFile(reportJsonPath, JSON.stringify(weeklyArtifact, null, 2) + "\n", "utf-8");
-    const rubricsMarkdown = this.formatRubrics(outcomeSummary, rubrics);
+    const rubricsMarkdown = this.formatRubrics(storeOutcomeSummary, rubrics);
     await writeFile(this.rubricsPath, rubricsMarkdown, "utf-8");
     await writeFile(this.rubricsIndexPath, JSON.stringify(rubrics, null, 2) + "\n", "utf-8");
     await this.syncRubricArtifacts(rubrics);
@@ -544,7 +1087,7 @@ var CompoundingEngine = class {
   }
   async readMistakes() {
     try {
-      const raw = await readFile(this.mistakesPath, "utf-8");
+      const raw = await readFile2(this.mistakesPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || !Array.isArray(parsed.patterns)) return null;
       if (!Array.isArray(parsed.registry)) {
@@ -578,7 +1121,7 @@ var CompoundingEngine = class {
   }
   async readRubrics() {
     try {
-      const raw = await readFile(this.rubricsIndexPath, "utf-8");
+      const raw = await readFile2(this.rubricsIndexPath, "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || !Array.isArray(parsed.agents) || !Array.isArray(parsed.workflows)) return null;
       parsed.agents = parsed.agents.map((entry) => this.normalizeRubricEntry(entry));
@@ -590,7 +1133,7 @@ var CompoundingEngine = class {
   }
   async readWeeklyArtifact(weekId) {
     try {
-      const raw = await readFile(path.join(this.weeklyDir, `${weekId}.json`), "utf-8");
+      const raw = await readFile2(path2.join(this.weeklyDir, `${weekId}.json`), "utf-8");
       const parsed = JSON.parse(raw);
       if (!parsed || parsed.weekId !== weekId || !Array.isArray(parsed.promotionCandidates)) {
         return null;
@@ -608,14 +1151,16 @@ var CompoundingEngine = class {
     const maxPatterns = Math.max(0, Math.floor(opts?.maxPatterns ?? 40));
     const maxRubrics = Math.max(0, Math.floor(opts?.maxRubrics ?? 4));
     const queryTokens = tokenizeRecallQuery(query);
-    const activePatterns = (mistakes?.registry ?? []).filter((entry) => entry.status === "active").sort(
+    const defaultPrefix = await defaultNamespaceRecallPrefix(this.config);
+    const activePatterns = (mistakes?.registry ?? []).filter((entry) => entry.status === "active" && provenanceVisibleInStoreRecall(entry.provenance, defaultPrefix)).sort(
       (a, b) => b.recurrenceCount - a.recurrenceCount || b.lastSeenAt.localeCompare(a.lastSeenAt) || a.pattern.localeCompare(b.pattern)
     );
     const topPatterns = activePatterns.slice(0, maxPatterns);
-    const allRubrics = [
-      ...rubrics?.workflows ?? [],
-      ...rubrics?.agents ?? []
-    ];
+    const allRubrics = visibleRubricEntries(
+      [...rubrics?.workflows ?? [], ...rubrics?.agents ?? []],
+      (entry) => this.getRubricObservationEntries(entry),
+      defaultPrefix
+    );
     const scoredRubrics = allRubrics.map((entry) => ({
       entry,
       score: this.scoreRubricForQuery(entry, queryTokens)
@@ -650,65 +1195,6 @@ var CompoundingEngine = class {
   tierMigrationCycleBudget(trigger) {
     return defaultTierMigrationCycleBudget(this.config, trigger);
   }
-  async readFeedbackEntriesForWeek(weekId) {
-    const out = [];
-    try {
-      const raw = await readFile(this.feedbackInboxPath, "utf-8");
-      const lines = raw.split("\n");
-      for (let idx = 0; idx < lines.length; idx += 1) {
-        const line = lines[idx];
-        if (!line.trim()) continue;
-        try {
-          const obj = JSON.parse(line);
-          const parsed = SharedFeedbackEntrySchema.safeParse(obj);
-          if (!parsed.success) continue;
-          const d = new Date(parsed.data.date);
-          if (!Number.isFinite(d.getTime())) continue;
-          if (isoWeekId(d) !== weekId) continue;
-          const sourceLine = idx + 1;
-          out.push({
-            entry: parsed.data,
-            sourceLine,
-            sourcePath: this.feedbackInboxPath,
-            entryId: `${parsed.data.agent}-${parsed.data.date}-${sourceLine}`.replace(/[^a-zA-Z0-9._:-]/g, "_")
-          });
-        } catch {
-        }
-      }
-    } catch {
-    }
-    return out;
-  }
-  buildActionFailurePatterns(events) {
-    const out = [];
-    for (const event of events) {
-      const failed = event.outcome === "failed" || event.outcome === "skipped";
-      if (!failed && event.policyDecision === null) continue;
-      const suffix = event.reason && event.reason.trim().length > 0 ? ` - ${event.reason.trim().slice(0, 140)}` : "";
-      out.push(
-        `memory-action/${event.namespace}: ${event.action} ${event.outcome}${event.policyDecision ? `/${event.policyDecision}` : ""}${suffix}`
-      );
-    }
-    return out;
-  }
-  async readActionEventsForWeek(weekId) {
-    const out = [];
-    const rows = await this.storage.readMemoryActionEventRows(Number.MAX_SAFE_INTEGER);
-    for (const row of rows) {
-      const event = row.event;
-      const ts = new Date(event.timestamp);
-      if (!Number.isFinite(ts.getTime()) || isoWeekId(ts) !== weekId) continue;
-      out.push({
-        line: row.line,
-        action: event.action,
-        outcome: event.outcome,
-        policyDecision: event.policyDecision === "deny" || event.policyDecision === "defer" ? event.policyDecision : null,
-        namespace: typeof event.namespace === "string" && event.namespace.length > 0 ? event.namespace : "default",
-        reason: typeof event.reason === "string" ? event.reason : null
-      });
-    }
-    return out;
-  }
   buildActionOutcomeSummary(events) {
     const byAction = /* @__PURE__ */ new Map();
     for (const event of events) {
@@ -720,7 +1206,7 @@ var CompoundingEngine = class {
       if (event.outcome === "applied") acc.counts.applied += 1;
       else if (event.outcome === "skipped") acc.counts.skipped += 1;
       else acc.counts.failed += 1;
-      acc.provenance.add(`${path.basename(this.memoryActionEventsPath)}:L${event.line}`);
+      acc.provenance.add(`${event.ledgerLabel}:L${event.line}`);
       byAction.set(key, acc);
     }
     const out = [];
@@ -739,7 +1225,7 @@ var CompoundingEngine = class {
     out.sort((a, b) => b.total - a.total || b.weightedScore - a.weightedScore || a.action.localeCompare(b.action));
     return out;
   }
-  derivePromotionCandidates(summary, mistakes, rubrics) {
+  derivePromotionCandidates(summary, mistakes, rubrics, defaultNamespacePrefix = null) {
     const deduped = /* @__PURE__ */ new Map();
     const upsert = (candidate) => {
       const key = `${candidate.category}:${canonicalPromotionContentKey(candidate.content)}`;
@@ -780,6 +1266,7 @@ var CompoundingEngine = class {
     }
     for (const entry of mistakes) {
       if (entry.status !== "active") continue;
+      if (!provenanceVisibleInStoreRecall(entry.provenance, defaultNamespacePrefix)) continue;
       if (entry.recurrenceCount < 2) continue;
       const content = normalizePromotedGuidanceContent(lessonContentFromPattern(entry.pattern, entry.agent));
       if (content.length === 0) continue;
@@ -802,6 +1289,7 @@ var CompoundingEngine = class {
     for (const rubric of [...rubrics.workflows, ...rubrics.agents]) {
       for (const observation of this.getRubricObservationEntries(rubric)) {
         if (this.isSyntheticOutcomeRubricObservation(observation.note)) continue;
+        if (!provenanceVisibleInStoreRecall(observation.provenance, defaultNamespacePrefix)) continue;
         const evidenceCount = observation.provenance.length;
         if (evidenceCount < 2) continue;
         const content = normalizePromotedGuidanceContent(observation.note);
@@ -824,14 +1312,14 @@ var CompoundingEngine = class {
     }
     return [...deduped.values()].sort((a, b) => b.score - a.score || a.subject.localeCompare(b.subject)).slice(0, 10);
   }
-  buildMistakes(entries, actionPatterns = [], weekId, previousRegistry = []) {
+  buildMistakes(entries, actionPatterns, corrections, weekId, previousRegistry = [], defaultNamespacePrefix = null, forgottenPatterns = /* @__PURE__ */ new Set()) {
     const patterns = [];
     const evidenceByPattern = /* @__PURE__ */ new Map();
     for (const wrapped of entries) {
       const e = wrapped.entry;
       const pattern = e.learning && e.learning.trim().length > 0 ? `${e.agent}: ${e.learning.trim()}` : e.decision === "rejected" ? `${e.agent}: ${e.reason.trim()}`.slice(0, 240) : null;
       if (!pattern) continue;
-      const provenance = [`${path.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
+      const provenance = [`${path2.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`];
       patterns.push({ pattern, provenance });
       const previous = evidenceByPattern.get(pattern) ?? {
         category: "feedback",
@@ -854,9 +1342,34 @@ var CompoundingEngine = class {
       previous.evidenceWindow = mergeEvidenceWindows(previous.evidenceWindow, nextEvidenceWindow);
       evidenceByPattern.set(pattern, previous);
     }
-    for (const pattern of actionPatterns) {
-      patterns.push({ pattern, provenance: [`${path.basename(this.memoryActionEventsPath)}:*`] });
-      const previous = evidenceByPattern.get(pattern) ?? {
+    for (const correction of corrections) {
+      patterns.push({ pattern: correction.pattern, provenance: [correction.provenance] });
+      const visible = provenanceVisibleInStoreRecall([correction.provenance], defaultNamespacePrefix);
+      const prev = evidenceByPattern.get(correction.pattern) ?? {
+        category: "correction",
+        agent: visible ? correction.source : null,
+        workflow: visible ? correction.entityRef ?? "corrections" : "corrections",
+        tags: /* @__PURE__ */ new Set(),
+        severity: null,
+        confidence: visible ? correction.confidence : null,
+        outcome: null,
+        timestamps: [],
+        evidenceWindow: { start: correction.created, end: correction.created }
+      };
+      if (visible) for (const tag of correction.tags) prev.tags.add(tag);
+      prev.timestamps.push(correction.created);
+      if (visible && prev.agent === null && correction.source) prev.agent = correction.source;
+      if (visible && correction.entityRef && prev.workflow === "corrections") prev.workflow = correction.entityRef;
+      if (visible && prev.confidence === null) prev.confidence = correction.confidence;
+      prev.evidenceWindow = mergeEvidenceWindows(prev.evidenceWindow, {
+        start: correction.created,
+        end: correction.created
+      });
+      evidenceByPattern.set(correction.pattern, prev);
+    }
+    for (const item of actionPatterns) {
+      patterns.push({ pattern: item.pattern, provenance: [item.provenance] });
+      const previous = evidenceByPattern.get(item.pattern) ?? {
         category: "action",
         agent: null,
         workflow: "memory-actions",
@@ -867,7 +1380,7 @@ var CompoundingEngine = class {
         timestamps: [],
         evidenceWindow: { start: null, end: null }
       };
-      evidenceByPattern.set(pattern, previous);
+      evidenceByPattern.set(item.pattern, previous);
     }
     const byPattern = /* @__PURE__ */ new Map();
     for (const item of patterns) {
@@ -875,7 +1388,11 @@ var CompoundingEngine = class {
       for (const provenance of item.provenance) existing.add(provenance);
       byPattern.set(item.pattern, existing);
     }
-    const details = [...byPattern.entries()].map(([pattern, provenance]) => ({ pattern, provenance: [...provenance].sort() })).slice(0, 500);
+    const details = capWeeklyPatternDetails(
+      [...byPattern.entries()].map(([pattern, provenance]) => ({ pattern, provenance: [...provenance].sort() })),
+      (pattern) => evidenceByPattern.get(pattern)?.category,
+      defaultNamespacePrefix
+    );
     const previousById = new Map(previousRegistry.map((entry) => [entry.id, entry]));
     const previousByPattern = new Map(previousRegistry.map((entry) => [entry.pattern, entry]));
     const registry = details.map((detail) => {
@@ -917,8 +1434,8 @@ var CompoundingEngine = class {
       const staleWeeks = weekIdToIndex(weekId) - weekIdToIndex(previous.lastWeekId);
       registry.push({
         ...previous,
-        status: staleWeeks >= RETIREMENT_WINDOW_WEEKS ? "retired" : previous.status,
-        retiredAt: staleWeeks >= RETIREMENT_WINDOW_WEEKS ? previous.retiredAt ?? (/* @__PURE__ */ new Date()).toISOString() : previous.retiredAt ?? null
+        status: forgottenPatterns.has(previous.pattern) || staleWeeks >= RETIREMENT_WINDOW_WEEKS ? "retired" : previous.status,
+        retiredAt: forgottenPatterns.has(previous.pattern) || staleWeeks >= RETIREMENT_WINDOW_WEEKS ? previous.retiredAt ?? (/* @__PURE__ */ new Date()).toISOString() : previous.retiredAt ?? null
       });
     }
     registry.sort(
@@ -961,7 +1478,7 @@ var CompoundingEngine = class {
         lines.push(`- approved: ${approved}`);
         lines.push(`- approved_with_feedback: ${awf}`);
         lines.push(`- rejected: ${rejected}`);
-        const provenance = list.slice(0, 3).map((e) => `${path.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
+        const provenance = list.slice(0, 3).map((e) => `${path2.basename(e.sourcePath)}:L${e.sourceLine}#${e.entryId}`);
         if (provenance.length > 0) {
           lines.push(`- provenance: ${provenance.join(", ")}`);
         }
@@ -1026,14 +1543,14 @@ var CompoundingEngine = class {
     }
     return lines.join("\n");
   }
-  buildRubricSnapshot(entries, outcomeSummary) {
+  buildRubricSnapshot(entries, outcomeSummary, corrections = []) {
     const updatedAt = (/* @__PURE__ */ new Date()).toISOString();
     const byAgent = /* @__PURE__ */ new Map();
     const byWorkflow = /* @__PURE__ */ new Map();
     for (const wrapped of entries) {
       const note = (wrapped.entry.learning && wrapped.entry.learning.trim().length > 0 ? wrapped.entry.learning : wrapped.entry.decision === "rejected" ? wrapped.entry.reason : "").trim();
       if (!note) continue;
-      const provenance = `${path.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`;
+      const provenance = `${path2.basename(wrapped.sourcePath)}:L${wrapped.sourceLine}#${wrapped.entryId}`;
       const agentEntry = byAgent.get(wrapped.entry.agent) ?? {
         id: stableRubricId("agent", wrapped.entry.agent),
         kind: "agent",
@@ -1063,6 +1580,37 @@ var CompoundingEngine = class {
       workflowEntry.tags = normalizeTags([...workflowEntry.tags, ...normalizeTags(wrapped.entry.tags)]);
       byWorkflow.set(workflow, workflowEntry);
     }
+    for (const correction of corrections) {
+      if (correction.source) {
+        const agentEntry = byAgent.get(correction.source) ?? {
+          id: stableRubricId("agent", correction.source),
+          kind: "agent",
+          subject: correction.source,
+          observations: [],
+          tags: [],
+          provenance: [],
+          observationEntries: [],
+          updatedAt
+        };
+        this.addRubricObservation(agentEntry, correction.note, correction.provenance);
+        agentEntry.tags = normalizeTags([...agentEntry.tags, ...correction.tags]);
+        byAgent.set(correction.source, agentEntry);
+      }
+      const workflow = correction.entityRef ?? "corrections";
+      const workflowEntry = byWorkflow.get(workflow) ?? {
+        id: stableRubricId("workflow", workflow),
+        kind: "workflow",
+        subject: workflow,
+        observations: [],
+        tags: [],
+        provenance: [],
+        observationEntries: [],
+        updatedAt
+      };
+      this.addRubricObservation(workflowEntry, correction.note, correction.provenance);
+      workflowEntry.tags = normalizeTags([...workflowEntry.tags, ...correction.tags]);
+      byWorkflow.set(workflow, workflowEntry);
+    }
     for (const item of outcomeSummary) {
       const workflowEntry = byWorkflow.get(item.action) ?? {
         id: stableRubricId("workflow", item.action),
@@ -1093,7 +1641,7 @@ var CompoundingEngine = class {
       "",
       `Generated: ${snapshot.updatedAt}`,
       "",
-      "Stable, deterministic rubric snapshot generated from weekly feedback + action outcomes.",
+      "Stable, deterministic rubric snapshot generated from weekly feedback, correction memories, and action outcomes.",
       ""
     ];
     lines.push("## Agent Rubrics");
@@ -1147,9 +1695,9 @@ var CompoundingEngine = class {
   async replaceRubricDirectory(dir, entries) {
     await mkdir(dir, { recursive: true });
     try {
-      const names = await readdir(dir);
+      const names = await readdir2(dir);
       await Promise.all(
-        names.filter((name) => name.endsWith(".md")).map((name) => unlink(path.join(dir, name)).catch(() => void 0))
+        names.filter((name) => name.endsWith(".md")).map((name) => unlink(path2.join(dir, name)).catch(() => void 0))
       );
     } catch {
     }
@@ -1173,7 +1721,7 @@ var CompoundingEngine = class {
         ""
       ].join("\n");
       const fileName = rubricArtifactFileName(entry, slugCollisions);
-      await writeFile(path.join(dir, fileName), body, "utf-8");
+      await writeFile(path2.join(dir, fileName), body, "utf-8");
     }));
   }
   scoreRubricForQuery(entry, queryTokens) {
@@ -1256,8 +1804,8 @@ var CompoundingEngine = class {
   }
   async readContinuityAuditReferences(weekId) {
     const monthId = monthIdFromIsoWeek(weekId);
-    const weeklyPath = path.join(this.identityAuditWeeklyDir, `${weekId}.md`);
-    const monthlyPath = path.join(this.identityAuditMonthlyDir, `${monthId}.md`);
+    const weeklyPath = path2.join(this.identityAuditWeeklyDir, `${weekId}.md`);
+    const monthlyPath = path2.join(this.identityAuditMonthlyDir, `${monthId}.md`);
     const [weeklyAudit, monthlyAudit] = await Promise.all([
       this.readOptionalIdentityAuditForReference("weekly", weekId),
       this.readOptionalIdentityAuditForReference("monthly", monthId)
@@ -1277,4 +1825,4 @@ export {
   defaultTierMigrationCycleBudget,
   CompoundingEngine
 };
-//# sourceMappingURL=chunk-2K7D6EFT.js.map
+//# sourceMappingURL=chunk-L3G5CGL5.js.map