@remnic/core 9.65.1 → 9.65.2

package/dist/{chunk-3PXVYJMC.js → chunk-SB7D4BT7.js}

@@ -8,20 +8,20 @@ import {
 } from "./chunk-GDB4J2H3.js";
 import {
   importCapsule
-} from "./chunk-PMVPCZJZ.js";
+} from "./chunk-6433HV72.js";
 import {
   buildCodingGraphInstallHint,
   tryLoadCodingGraphModule
 } from "./chunk-VQ7B2Q6M.js";
-import {
-  WriteQuarantineStore
-} from "./chunk-PJSK6OJM.js";
 import {
   WHO_KNOWS_DEFAULT_LIMIT,
   computeWhoKnows,
   loadWhoKnowsEntities,
   validateWhoKnowsInput
-} from "./chunk-R3AAOKR2.js";
+} from "./chunk-SPUJNJJC.js";
+import {
+  WriteQuarantineStore
+} from "./chunk-PJSK6OJM.js";
 import {
   trustResultFor
 } from "./chunk-GNVZQ5JN.js";
@@ -45,25 +45,25 @@ import {
 } from "./chunk-H7XKCNR6.js";
 import {
   toRecallExplainJson
-} from "./chunk-W6TSGWYS.js";
+} from "./chunk-7YQ4IYS2.js";
 import {
   estimateRecallTokens
-} from "./chunk-VPGRXEAB.js";
+} from "./chunk-3I7ASZN3.js";
 import {
   readAggregateExtractionWatermark
-} from "./chunk-4W6INNXO.js";
+} from "./chunk-PE255F4T.js";
+import {
+  ReplicaDivergenceMonitor
+} from "./chunk-CVILPI77.js";
 import {
   recordObjectiveStateSnapshotsFromObservedMessages
 } from "./chunk-2HIJHXB3.js";
 import {
   objectiveStateStoreOverrideForNamespace
 } from "./chunk-HTP6XRUI.js";
-import {
-  ReplicaDivergenceMonitor
-} from "./chunk-CVILPI77.js";
 import {
   recordMemoryOutcome
-} from "./chunk-EIR5VLIH.js";
+} from "./chunk-4K7IW3F7.js";
 import {
   coerceIncludedMemories
 } from "./chunk-2YA5N2BY.js";
@@ -90,13 +90,14 @@ import {
 } from "./chunk-IVKIODHO.js";
 import {
   buildProcedurePersistBody,
-  normalizeProcedureSteps
+  normalizeProcedureSteps,
+  parseProcedureStepsFromBody
 } from "./chunk-QDW3E4RD.js";
 import {
   persistExplicitCapture,
   queueExplicitCaptureForReview,
   validateExplicitCaptureInput
-} from "./chunk-NS5ETDYD.js";
+} from "./chunk-7BEPVIH3.js";
 import {
   boundRecallContextComposition,
   composeRecallContext,
@@ -116,18 +117,18 @@ import {
   listMemoryGovernanceRuns,
   readMemoryGovernanceRunArtifact,
   runMemoryGovernance
-} from "./chunk-SYJ6EKKE.js";
+} from "./chunk-JYYBA7TF.js";
 import {
   CorpusWatermarkCache,
   computeServiceCorpusCensus
-} from "./chunk-53ENM6F6.js";
+} from "./chunk-XRYZRW54.js";
 import {
   ExtractionDeadlineError,
   isActivityDigestPath,
   isArtifactMemoryPath,
   isLocationDayPath,
   isMeetingRecordPath
-} from "./chunk-S2VBSTTA.js";
+} from "./chunk-THG4GYIE.js";
 import {
   defaultCapsulesDir
 } from "./chunk-ZY2MNJR6.js";
@@ -141,21 +142,21 @@ import {
   enqueuePassiveCorrectionNotification,
   parseBriefingFocus,
   parseBriefingWindow
-} from "./chunk-3TMYV3LP.js";
+} from "./chunk-NTWN6HB2.js";
 import {
   parseEntityFile,
   parseFrontmatter,
   qmdCollectionPathParts,
   qmdResultPathCandidates,
   selfDeps
-} from "./chunk-DEFI2QBT.js";
+} from "./chunk-J275IYMG.js";
 import {
   namespaceCollectionName
-} from "./chunk-X5SDZMO7.js";
+} from "./chunk-YHCBJULX.js";
 import {
   DEFAULT_RECALL_DISCLOSURE,
   isRecallDisclosure
-} from "./chunk-JFJ3MHGV.js";
+} from "./chunk-SBDCZ2AX.js";
 import {
   normalizeProjectionPreview,
   normalizeProjectionTags
@@ -166,7 +167,7 @@ import {
   buildObserveRequestFingerprint,
   composeMemoryEnvelope,
   isMemoryCategory
-} from "./chunk-LCU5R6TQ.js";
+} from "./chunk-RAIUTAZZ.js";
 import {
   applyTagFilter,
   normalizeTags,
@@ -175,6 +176,9 @@ import {
 import {
   createVersion
 } from "./chunk-UFKPQBXH.js";
+import {
+  bumpMemoryCorpusVersionForDir
+} from "./chunk-XCB6QDL6.js";
 import {
   supersessionKeysForFact
 } from "./chunk-5WITETWU.js";
@@ -194,9 +198,12 @@ import {
 import {
   isExternalWikiCollectionName
 } from "./chunk-JV3C2MNQ.js";
+import {
+  computePromotionCandidates
+} from "./chunk-RIAM7DND.js";
 import {
   exportCapsule
-} from "./chunk-KQAFEZQX.js";
+} from "./chunk-VDX2J7OX.js";
 import {
   evaluateActionConfidence
 } from "./chunk-Z2YFLXHU.js";
@@ -225,7 +232,7 @@ import {
 } from "./chunk-LNEWDF2A.js";
 import {
   createOfflineSyncManifestStream
-} from "./chunk-I2HTKOOP.js";
+} from "./chunk-ODZG724P.js";
 import {
   offlineSyncStorageForSnapshot
 } from "./chunk-HZNYJN77.js";
@@ -243,6 +250,7 @@ import {
 } from "./chunk-KCT36JAW.js";
 import {
   inferMemoryStatus,
+  isActiveMemoryStatus,
   toMemoryPathRel
 } from "./chunk-7RJUVTVF.js";
 import {
@@ -251,13 +259,6 @@ import {
 import {
   displayErrorDetail
 } from "./chunk-RL6NEVXT.js";
-import {
-  computeContentHash
-} from "./chunk-5FVVY2EB.js";
-import {
-  serializeMutations,
-  withHeldFileLock
-} from "./chunk-FFAZ2XFU.js";
 import {
   SUPPORT_PASSPORT_ATTRIBUTE_KEYS,
   SUPPORT_PASSPORT_CARD_TAG,
@@ -284,6 +285,13 @@ import {
 import {
   stripAttributesSuffix
 } from "./chunk-JDSVLVCG.js";
+import {
+  computeContentHash
+} from "./chunk-5FVVY2EB.js";
+import {
+  serializeMutations,
+  withHeldFileLock
+} from "./chunk-FFAZ2XFU.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-5GKPFL3S.js";
@@ -374,6 +382,10 @@ import {
   raceAbort,
   throwIfAborted
 } from "./chunk-BTTPKDIL.js";
+import {
+  readJsonFile,
+  writeJsonFileAtomic
+} from "./chunk-P77QX3ID.js";
 import {
   AccessAuditAdapter
 } from "./chunk-TVVEYCNW.js";
@@ -5367,6 +5379,7 @@ var OPERATION_NAMES = [
   "recall_tier_explain",
   "recall_xray",
   "who_knows",
+  "promotion_candidates",
   "namespace_writable",
   "wearables_status",
   "wearables_sync",
@@ -5387,6 +5400,7 @@ var OPERATION_NAMES = [
   "procedure_mining_run",
   "pattern_reinforcement_run",
   "procedural_stats",
+  "procedure_library_maintenance",
   "memory_timeline",
   "suggestion_submit",
   "entity_get",
@@ -5558,10 +5572,10 @@ function formatZodIssues(error) {
   const parts = [];
   for (const issue of error.issues) {
     const hasNumeric = issue.path.some((p) => typeof p === "number");
-    const path16 = hasNumeric ? issue.path.filter((p) => typeof p === "string").join(".") || "(root)" : issue.path.length > 0 ? issue.path.join(".") : "(root)";
+    const path17 = hasNumeric ? issue.path.filter((p) => typeof p === "string").join(".") || "(root)" : issue.path.length > 0 ? issue.path.join(".") : "(root)";
     const options = enumOptionsFromIssue(issue);
     const suffix = options ? `. Valid: ${options.join(", ")}` : "";
-    parts.push(`${path16}: ${issue.message}${suffix}`);
+    parts.push(`${path17}: ${issue.message}${suffix}`);
   }
   return parts.length > 0 ? `request validation failed: ${parts.join("; ")}` : "request validation failed";
 }
@@ -6114,6 +6128,343 @@ async function promoteMemory(options) {
   };
 }
 
+// src/procedural/library-maintenance.ts
+import path10 from "path";
+var MAINTENANCE_ACTOR = "procedure-library-maintenance";
+var MAINTENANCE_RULE_VERSION = "procedure-library-maintenance:1";
+function maintenanceMarkerPath(memoryDir) {
+  return path10.join(memoryDir, "state", "procedure-maintenance.json");
+}
+async function readProcedureMaintenanceMarker(memoryDir) {
+  try {
+    const raw = await readJsonFile(maintenanceMarkerPath(memoryDir));
+    if (raw === null || typeof raw !== "object" || Array.isArray(raw)) return null;
+    const m = raw;
+    if (typeof m.lastRunAt !== "string") return null;
+    return {
+      schemaVersion: 1,
+      lastRunAt: m.lastRunAt,
+      lastApplyAt: typeof m.lastApplyAt === "string" ? m.lastApplyAt : null,
+      appliedCount: typeof m.appliedCount === "number" ? m.appliedCount : 0
+    };
+  } catch {
+    return null;
+  }
+}
+function evidenceFor(m) {
+  return {
+    memoryId: m.frontmatter.id,
+    mwSuccess: m.frontmatter.mw_success ?? 0,
+    mwFail: m.frontmatter.mw_fail ?? 0,
+    lastAccessed: m.frontmatter.lastAccessed ?? null,
+    updated: m.frontmatter.updated ?? null
+  };
+}
+function tsMs(value) {
+  if (typeof value !== "string") return null;
+  const ms = Date.parse(value);
+  return Number.isFinite(ms) ? ms : null;
+}
+function procedureTitle(content) {
+  const text = content.replace(/\r\n/g, "\n").trim();
+  const idx = text.search(/^##\s+Step\s+\d+\s*$/im);
+  return (idx === -1 ? text : text.slice(0, idx)).trim();
+}
+function normalizePhrase(s) {
+  return s.toLowerCase().replace(/[^a-z0-9]+/g, " ").trim();
+}
+function stepSignature(steps) {
+  if (steps === null) return "<unparsed>";
+  return steps.map(
+    (s) => `${s.order}|${normalizePhrase(s.intent)}|${s.toolCall?.kind ?? ""}|${s.toolCall?.signature ?? ""}`
+  ).join(";;");
+}
+function isUserEditedProcedure(content) {
+  const steps = parseProcedureStepsFromBody(content);
+  if (steps === null) return true;
+  const rebuilt = buildProcedurePersistBody(procedureTitle(content), steps);
+  return rebuilt.trim() !== content.replace(/\r\n/g, "\n").trim();
+}
+function compareCanonical(a, b) {
+  const aMs = tsMs(a.frontmatter.updated) ?? tsMs(a.frontmatter.created) ?? 0;
+  const bMs = tsMs(b.frontmatter.updated) ?? tsMs(b.frontmatter.created) ?? 0;
+  if (aMs !== bMs) return aMs > bMs ? -1 : 1;
+  const aId = a.frontmatter.id ?? "";
+  const bId = b.frontmatter.id ?? "";
+  if (aId !== bId) return aId < bId ? -1 : 1;
+  return 0;
+}
+function recentTrajectoryToolText(trajectories) {
+  return trajectories.map((r) => r.actionSummary).join("\n").toLowerCase();
+}
+async function runProcedureLibraryMaintenance(options) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const nowIso = now.toISOString();
+  const mode = options.apply === true ? "apply" : "shadow";
+  const cfg = options.config.procedural;
+  if (cfg?.enabled !== true || cfg.maintenance?.enabled !== true) {
+    return {
+      schemaVersion: 1,
+      generatedAt: nowIso,
+      mode,
+      scannedProcedures: 0,
+      proposed: [],
+      applied: [],
+      appliedCount: 0,
+      skippedReason: cfg?.enabled !== true ? "procedural_disabled" : "maintenance_disabled"
+    };
+  }
+  const maintenance = cfg.maintenance;
+  const all = await options.storage.readAllMemories();
+  const byId = /* @__PURE__ */ new Map();
+  for (const m of all) {
+    if (m.frontmatter.category !== "procedure") continue;
+    if (!isActiveMemoryStatus(m.frontmatter.status)) continue;
+    if (typeof m.frontmatter.id === "string" && m.frontmatter.id.length > 0) {
+      byId.set(m.frontmatter.id, m);
+    }
+  }
+  const activeProcedures = [...byId.values()];
+  const report = {
+    schemaVersion: 1,
+    generatedAt: nowIso,
+    mode,
+    scannedProcedures: activeProcedures.length,
+    proposed: [],
+    applied: [],
+    appliedCount: 0
+  };
+  if (activeProcedures.length === 0 && mode === "shadow") return report;
+  const mergeConsumed = /* @__PURE__ */ new Set();
+  if (maintenance.mergeEnabled) {
+    const clusters = /* @__PURE__ */ new Map();
+    for (const m of activeProcedures) {
+      const steps = parseProcedureStepsFromBody(m.content);
+      const key = `${normalizePhrase(procedureTitle(m.content))}
+@@
+${stepSignature(steps)}`;
+      const bucket = clusters.get(key);
+      if (bucket) bucket.push(m);
+      else clusters.set(key, [m]);
+    }
+    for (const cluster of clusters.values()) {
+      if (cluster.length < 2) continue;
+      const sortedCluster = [...cluster].sort(compareCanonical);
+      const userEdited = sortedCluster.filter((m) => isUserEditedProcedure(m.content));
+      if (userEdited.length > 0) {
+        report.proposed.push({
+          action: "flag_user_edited",
+          reasonCode: "user_edited_protected",
+          memoryIds: sortedCluster.map((m) => m.frontmatter.id),
+          reason: "duplicate-signature cluster contains user-edited bodies; merge skipped for manual review",
+          evidence: sortedCluster.map(evidenceFor)
+        });
+        continue;
+      }
+      const canonical = sortedCluster[0];
+      const duplicates = sortedCluster.slice(1);
+      for (const m of sortedCluster) mergeConsumed.add(m.frontmatter.id);
+      report.proposed.push({
+        action: "merge",
+        reasonCode: "merge_duplicate_signature",
+        memoryIds: [canonical.frontmatter.id, ...duplicates.map((m) => m.frontmatter.id)],
+        canonicalId: canonical.frontmatter.id,
+        reason: `near-identical trigger phrase + step signature across ${sortedCluster.length} active procedures`,
+        evidence: sortedCluster.map(evidenceFor)
+      });
+    }
+  }
+  const trajectoryDir = typeof options.config.causalTrajectoryStoreDir === "string" && options.config.causalTrajectoryStoreDir.trim().length > 0 ? options.config.causalTrajectoryStoreDir.trim() : void 0;
+  const { trajectories } = await readCausalTrajectoryRecords({
+    memoryDir: options.memoryDir,
+    causalTrajectoryStoreDir: trajectoryDir
+  });
+  const recentTrajectories = filterTrajectoriesByLookbackDays(
+    trajectories,
+    cfg.lookbackDays,
+    now.getTime()
+  );
+  const repairFlags = [];
+  const staleToolsByProcedure = /* @__PURE__ */ new Map();
+  if (recentTrajectories.length > 0) {
+    const toolText = recentTrajectoryToolText(recentTrajectories);
+    for (const m of activeProcedures) {
+      if (mergeConsumed.has(m.frontmatter.id)) continue;
+      const steps = parseProcedureStepsFromBody(m.content);
+      if (steps === null) continue;
+      const tools = [
+        ...new Set(
+          steps.map((s) => s.toolCall?.kind).filter((t) => typeof t === "string" && t.length > 0)
+        )
+      ];
+      if (tools.length === 0) continue;
+      const stale = tools.filter((t) => !toolText.includes(t.toLowerCase()));
+      if (stale.length === 0) continue;
+      staleToolsByProcedure.set(m.frontmatter.id, stale);
+      repairFlags.push({
+        action: "flag_repair",
+        reasonCode: "needs_repair_stale_tools",
+        memoryIds: [m.frontmatter.id],
+        reason: `tools absent from last ${cfg.lookbackDays}d of trajectories: ${stale.join(", ")}`,
+        evidence: [evidenceFor(m)]
+      });
+    }
+  }
+  const retireActions = [];
+  const retireIds = /* @__PURE__ */ new Set();
+  const idleMs = maintenance.retireIdleDays * 24 * 60 * 60 * 1e3;
+  for (const m of activeProcedures) {
+    if (mergeConsumed.has(m.frontmatter.id)) continue;
+    const mwSuccess = m.frontmatter.mw_success ?? 0;
+    const mwFail = m.frontmatter.mw_fail ?? 0;
+    const failureDominant = mwFail >= maintenance.retireMinOutcomes && mwFail > mwSuccess * maintenance.retireFailRatio;
+    const lastSignalMs = tsMs(m.frontmatter.lastAccessed) ?? tsMs(m.frontmatter.updated);
+    const idle = maintenance.retireIdleDays > 0 && mwSuccess + mwFail === 0 && lastSignalMs !== null && lastSignalMs < now.getTime() - idleMs;
+    const reasonCode = failureDominant ? "retire_failure_dominant" : idle ? "retire_idle" : null;
+    if (reasonCode === null) continue;
+    if (isUserEditedProcedure(m.content)) {
+      report.proposed.push({
+        action: "flag_user_edited",
+        reasonCode: "user_edited_protected",
+        memoryIds: [m.frontmatter.id],
+        reason: `user-edited body exempt from automatic retirement (${reasonCode} waived)`,
+        evidence: [evidenceFor(m)]
+      });
+      continue;
+    }
+    retireIds.add(m.frontmatter.id);
+    retireActions.push({
+      action: "retire",
+      reasonCode,
+      memoryIds: [m.frontmatter.id],
+      reason: reasonCode === "retire_failure_dominant" ? `mw_fail ${mwFail} >= ${maintenance.retireMinOutcomes} and > mw_success ${mwSuccess} * ${maintenance.retireFailRatio}` : `no access signal for ${maintenance.retireIdleDays}d and zero recorded outcomes`,
+      evidence: [evidenceFor(m)]
+    });
+  }
+  for (const flag of repairFlags) {
+    if (retireIds.has(flag.memoryIds[0])) continue;
+    report.proposed.push(flag);
+  }
+  report.proposed.push(...retireActions);
+  if (mode === "shadow") return report;
+  const applied = report.proposed;
+  let writes = 0;
+  for (const action of applied) {
+    try {
+      if (action.action === "merge") {
+        const canonicalId = action.canonicalId;
+        const canonical = canonicalId !== void 0 ? byId.get(canonicalId) : void 0;
+        if (!canonical || canonicalId === void 0) continue;
+        const memberIds = [...action.memoryIds].sort();
+        const previousCount = canonical.frontmatter.reinforcement_count ?? 0;
+        const newCount = Math.max(previousCount, memberIds.length);
+        if (newCount !== canonical.frontmatter.reinforcement_count || canonical.frontmatter.derived_via !== "pattern-reinforcement") {
+          await options.storage.writeMemoryFrontmatter(
+            canonical,
+            {
+              reinforcement_count: newCount,
+              last_reinforced_at: nowIso,
+              derived_via: "pattern-reinforcement",
+              derived_from: memberIds,
+              updated: nowIso
+            },
+            {
+              actor: MAINTENANCE_ACTOR,
+              reasonCode: action.reasonCode,
+              ruleVersion: MAINTENANCE_RULE_VERSION,
+              relatedMemoryIds: memberIds
+            }
+          );
+          writes += 1;
+        }
+        for (const memberId of action.memoryIds) {
+          if (memberId === canonicalId) continue;
+          const member = byId.get(memberId);
+          if (!member) continue;
+          await options.storage.writeMemoryFrontmatter(
+            member,
+            {
+              status: "superseded",
+              supersededBy: canonicalId,
+              supersededAt: nowIso,
+              updated: nowIso
+            },
+            {
+              actor: MAINTENANCE_ACTOR,
+              reasonCode: action.reasonCode,
+              ruleVersion: MAINTENANCE_RULE_VERSION,
+              relatedMemoryIds: [canonicalId]
+            }
+          );
+          writes += 1;
+        }
+      } else if (action.action === "retire") {
+        const memory = byId.get(action.memoryIds[0]);
+        if (!memory) continue;
+        const archivedPath = await options.storage.archiveMemory(memory, {
+          at: now,
+          actor: `${MAINTENANCE_ACTOR}.apply`,
+          reasonCode: action.reasonCode,
+          ruleVersion: MAINTENANCE_RULE_VERSION,
+          relatedMemoryIds: []
+        });
+        if (archivedPath !== null) writes += 1;
+      } else if (action.action === "flag_repair") {
+        const memory = byId.get(action.memoryIds[0]);
+        if (!memory) continue;
+        const existing = memory.frontmatter.structuredAttributes ?? {};
+        const prior = existing.needsRepair;
+        let priorReason = null;
+        if (typeof prior === "string") {
+          try {
+            const parsed = JSON.parse(prior);
+            if (typeof parsed.reason === "string") priorReason = parsed.reason;
+          } catch {
+            priorReason = prior;
+          }
+        }
+        if (priorReason === action.reason) continue;
+        const stamp = JSON.stringify({ reason: action.reason, detectedAt: nowIso });
+        await options.storage.writeMemoryFrontmatter(
+          memory,
+          {
+            structuredAttributes: { ...existing, needsRepair: stamp },
+            updated: nowIso
+          },
+          {
+            actor: MAINTENANCE_ACTOR,
+            reasonCode: action.reasonCode,
+            ruleVersion: MAINTENANCE_RULE_VERSION
+          }
+        );
+        writes += 1;
+      }
+      report.applied.push(action);
+    } catch (err) {
+      log.warn(
+        `procedure-library-maintenance: action ${action.reasonCode} on ${action.memoryIds.join(",")} failed: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  }
+  report.appliedCount = report.applied.length;
+  if (writes > 0) {
+    bumpMemoryCorpusVersionForDir(options.memoryDir);
+  }
+  try {
+    await writeJsonFileAtomic(maintenanceMarkerPath(options.memoryDir), {
+      schemaVersion: 1,
+      lastRunAt: nowIso,
+      lastApplyAt: nowIso,
+      appliedCount: report.appliedCount
+    });
+  } catch (err) {
+    log.warn(
+      `procedure-library-maintenance: failed to persist run marker: ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  return report;
+}
+
 // src/procedural/procedure-stats.ts
 function snapshotConfig(config) {
   const p = config.procedural;
@@ -6127,7 +6478,7 @@ function snapshotConfig(config) {
     recallMaxProcedures: typeof p?.recallMaxProcedures === "number" ? p.recallMaxProcedures : 0
   };
 }
-function tsMs(value) {
+function tsMs2(value) {
   if (typeof value !== "string") return null;
   const ms = Date.parse(value);
   return Number.isFinite(ms) ? ms : null;
@@ -6149,6 +6500,7 @@ async function computeProcedureStats(options) {
   let lastWriteMs = null;
   let writesLast7Days = 0;
   let minerSourced = 0;
+  let needsRepairFlags = 0;
   const known = [
     "active",
     "pending_review",
@@ -6172,8 +6524,8 @@ async function computeProcedureStats(options) {
     } else {
       counts.other += 1;
     }
-    const createdMs = tsMs(m.frontmatter.created);
-    const updatedMs = tsMs(m.frontmatter.updated);
+    const createdMs = tsMs2(m.frontmatter.created);
+    const updatedMs = tsMs2(m.frontmatter.updated);
     const latestMs = createdMs !== null && updatedMs !== null ? Math.max(createdMs, updatedMs) : updatedMs ?? createdMs;
     if (latestMs !== null) {
       if (lastWriteMs === null || latestMs > lastWriteMs) {
@@ -6186,7 +6538,11 @@ async function computeProcedureStats(options) {
     if (m.frontmatter.source === "procedure-miner") {
       minerSourced += 1;
     }
+    if (m.frontmatter.structuredAttributes?.needsRepair !== void 0 && isActiveMemoryStatus(m.frontmatter.status)) {
+      needsRepairFlags += 1;
+    }
   }
+  const maintenanceMarker = await readProcedureMaintenanceMarker(storage.dir);
   return {
     schemaVersion: 1,
     generatedAt: new Date(nowMs).toISOString(),
@@ -6196,7 +6552,9 @@ async function computeProcedureStats(options) {
       writesLast7Days,
       minerSourced
     },
-    config: snapshotConfig(config)
+    config: snapshotConfig(config),
+    lastMaintenanceAt: maintenanceMarker?.lastRunAt ?? null,
+    needsRepairFlags
   };
 }
 function formatProcedureStatsText(report) {
@@ -6231,6 +6589,10 @@ function formatProcedureStatsText(report) {
   lines.push(`    lastWriteAt:      ${recent.lastWriteAt ?? "(none)"}`);
   lines.push(`    writesLast7Days:  ${recent.writesLast7Days}`);
   lines.push(`    minerSourced:     ${recent.minerSourced}`);
+  lines.push("");
+  lines.push(`  maintenance:`);
+  lines.push(`    lastMaintenanceAt: ${report.lastMaintenanceAt ?? "(never)"}`);
+  lines.push(`    needsRepairFlags:  ${report.needsRepairFlags}`);
   return lines.join("\n") + "\n";
 }
 
@@ -8691,7 +9053,7 @@ import { createHash as createHash5 } from "crypto";
 import * as nodePath2 from "path";
 
 // src/orchestration/recall-result-formatter.ts
-import path10 from "path";
+import path11 from "path";
 function renderConnectorLabel(connector) {
   if (!isValidConnectorId(connector)) return null;
   return connector.length <= CONNECTOR_LABEL_MAX_LENGTH ? connector : `${connector.slice(0, CONNECTOR_LABEL_MAX_LENGTH - 1)}\u2026`;
@@ -8713,15 +9075,15 @@ function resolveEffectiveIdentityInjectionMode(options) {
   return { mode: options.configuredMode, shouldInject: true };
 }
 function displayResultPath(resultPath, memoryDir, namespace) {
-  if (!path10.isAbsolute(resultPath)) return resultPath;
-  const root = path10.resolve(memoryDir);
-  const nsRoot = path10.join(root, "namespaces");
-  if (namespace && (resultPath === nsRoot || resultPath.startsWith(nsRoot + path10.sep))) {
-    const afterNs = path10.relative(nsRoot, resultPath).split(path10.sep).slice(1).join("/");
+  if (!path11.isAbsolute(resultPath)) return resultPath;
+  const root = path11.resolve(memoryDir);
+  const nsRoot = path11.join(root, "namespaces");
+  if (namespace && (resultPath === nsRoot || resultPath.startsWith(nsRoot + path11.sep))) {
+    const afterNs = path11.relative(nsRoot, resultPath).split(path11.sep).slice(1).join("/");
     if (afterNs) return `${namespace}/${afterNs}`;
   }
-  const rel = path10.relative(root, resultPath);
-  return rel && !rel.startsWith("..") && !path10.isAbsolute(rel) ? rel.split(path10.sep).join("/") : resultPath;
+  const rel = path11.relative(root, resultPath);
+  return rel && !rel.startsWith("..") && !path11.isAbsolute(rel) ? rel.split(path11.sep).join("/") : resultPath;
 }
 function displaySafeRecallSnapshot(snapshot, memoryDir) {
   const includedMemories = coerceIncludedMemories(snapshot).map((memory) => ({
@@ -10180,14 +10542,14 @@ async function completeSupportPassportReplacementPrior(input) {
 }
 
 // src/support-passport/generated-batch.ts
-import path12 from "path";
+import path13 from "path";
 import { z as z2 } from "zod";
 
 // src/support-passport/private-file.ts
 import { randomUUID } from "crypto";
 import { constants as fsConstants } from "fs";
 import { lstat as lstat3, mkdir as mkdir3, open, rename as rename2, rm as rm2, stat as stat2 } from "fs/promises";
-import path11 from "path";
+import path12 from "path";
 var UNSUPPORTED_DIRECTORY_SYNC_ERRORS = /* @__PURE__ */ new Set(["EINVAL", "ENOSYS", "ENOTSUP", "EOPNOTSUPP"]);
 var NON_WRITABLE_ANCESTOR_SYNC_ERRORS = /* @__PURE__ */ new Set(["EROFS", "EPERM", "EACCES"]);
 function assertStableDirectory(before, opened, after, errorMessage) {
@@ -10213,8 +10575,8 @@ function openFlags(...flags) {
   return combined;
 }
 function assertContainedPath(trustedRoot, directory, errorMessage) {
-  const relative2 = path11.relative(path11.resolve(trustedRoot), path11.resolve(directory));
-  if (relative2 === ".." || relative2.startsWith(`..${path11.sep}`) || path11.isAbsolute(relative2)) {
+  const relative2 = path12.relative(path12.resolve(trustedRoot), path12.resolve(directory));
+  if (relative2 === ".." || relative2.startsWith(`..${path12.sep}`) || path12.isAbsolute(relative2)) {
     throw new Error(errorMessage);
   }
 }
@@ -10247,7 +10609,7 @@ async function syncDirectoryHandle(handle) {
 }
 async function resolvePrivateDirectoryPath(directory, handle, opened, errorMessage, platform = process.platform) {
   const descriptorRoot = requirePrivateFileDescriptorRoot(platform, errorMessage);
-  const pinnedPath = path11.join(descriptorRoot, String(handle.fd));
+  const pinnedPath = path12.join(descriptorRoot, String(handle.fd));
   const metadata = await stat2(pinnedPath);
   if (!metadata.isDirectory() || metadata.dev !== opened.dev || metadata.ino !== opened.ino) {
     throw new Error(errorMessage);
@@ -10263,12 +10625,12 @@ function requirePrivateFileDescriptorRoot(platform, errorMessage) {
   throw new Error(errorMessage);
 }
 async function openStableDirectoryFromRoot(trustedRoot, directory, errorMessage, platform = process.platform) {
-  const root = path11.resolve(trustedRoot);
-  const target = path11.resolve(directory);
+  const root = path12.resolve(trustedRoot);
+  const target = path12.resolve(directory);
   assertContainedPath(root, target, errorMessage);
   requirePrivateFileDescriptorRoot(platform, errorMessage);
-  const relative2 = path11.relative(root, target);
-  const components = relative2 === "" ? [] : relative2.split(path11.sep);
+  const relative2 = path12.relative(root, target);
+  const components = relative2 === "" ? [] : relative2.split(path12.sep);
   const handles = [];
   let currentPath = root;
   try {
@@ -10276,10 +10638,10 @@ async function openStableDirectoryFromRoot(trustedRoot, directory, errorMessage,
     handles.push(current.handle);
     for (const component of components) {
       const pinnedParent = await resolvePrivateDirectoryPath(currentPath, current.handle, current.opened, errorMessage);
-      const child = await openDirectoryNoFollow(path11.join(pinnedParent, component), errorMessage);
+      const child = await openDirectoryNoFollow(path12.join(pinnedParent, component), errorMessage);
       handles.push(child.handle);
       assertStableDirectory(current.before, current.opened, await lstat3(currentPath), errorMessage);
-      currentPath = path11.join(currentPath, component);
+      currentPath = path12.join(currentPath, component);
       current = child;
     }
     assertStableDirectory(current.before, current.opened, await lstat3(target), errorMessage);
@@ -10300,12 +10662,12 @@ async function openStableDirectoryFromRoot(trustedRoot, directory, errorMessage,
   }
 }
 async function ensurePrivateDirectoryNoFollow(trustedRoot, directory, errorMessage, syncVerifiedParent = syncDirectoryHandle, hardenExistingChildren = true, platform = process.platform) {
-  const root = path11.resolve(trustedRoot);
-  const target = path11.resolve(directory);
+  const root = path12.resolve(trustedRoot);
+  const target = path12.resolve(directory);
   assertContainedPath(root, target, errorMessage);
-  const relative2 = path11.relative(root, target);
+  const relative2 = path12.relative(root, target);
   requirePrivateFileDescriptorRoot(platform, errorMessage);
-  const components = relative2 === "" ? [] : relative2.split(path11.sep);
+  const components = relative2 === "" ? [] : relative2.split(path12.sep);
   const handles = [];
   let currentPath = root;
   try {
@@ -10313,7 +10675,7 @@ async function ensurePrivateDirectoryNoFollow(trustedRoot, directory, errorMessa
     handles.push(current.handle);
     for (const component of components) {
       const pinnedParent = await resolvePrivateDirectoryPath(currentPath, current.handle, current.opened, errorMessage);
-      const childPath = path11.join(pinnedParent, component);
+      const childPath = path12.join(pinnedParent, component);
       let created = false;
       try {
         await mkdir3(childPath, { mode: 448 });
@@ -10328,7 +10690,7 @@ async function ensurePrivateDirectoryNoFollow(trustedRoot, directory, errorMessa
         await child.handle.chmod(448);
       }
       assertStableDirectory(current.before, current.opened, await lstat3(currentPath), errorMessage);
-      currentPath = path11.join(currentPath, component);
+      currentPath = path12.join(currentPath, component);
       current = child;
     }
     assertStableDirectory(current.before, current.opened, await lstat3(target), errorMessage);
@@ -10337,8 +10699,8 @@ async function ensurePrivateDirectoryNoFollow(trustedRoot, directory, errorMessa
   }
 }
 async function ensurePrivateDirectoryTreeNoFollow(directory, errorMessage, syncVerifiedParent = syncDirectoryHandle, platform = process.platform) {
-  const target = path11.resolve(directory);
-  const filesystemRoot = path11.parse(target).root;
+  const target = path12.resolve(directory);
+  const filesystemRoot = path12.parse(target).root;
   const rootMetadata = await stat2(filesystemRoot);
   await ensurePrivateDirectoryNoFollow(
     filesystemRoot,
@@ -10373,15 +10735,15 @@ async function withPrivateDirectoryNoFollow(trustedRoot, directory, errorMessage
   }
 }
 async function readPrivateFileNoFollow(directory, filePath, errorMessage, trustedRoot = directory, platform = process.platform) {
-  if (path11.dirname(filePath) !== path11.resolve(directory)) throw new Error(errorMessage);
-  const targetName = path11.basename(filePath);
+  if (path12.dirname(filePath) !== path12.resolve(directory)) throw new Error(errorMessage);
+  const targetName = path12.basename(filePath);
   let directoryHandles = [];
   let fileHandle;
   try {
     const stableDirectory = await openStableDirectoryFromRoot(trustedRoot, directory, errorMessage, platform);
     directoryHandles = stableDirectory.handles;
     const pinnedDirectory = stableDirectory.pinnedDirectory;
-    const targetPath = path11.join(pinnedDirectory, targetName);
+    const targetPath = path12.join(pinnedDirectory, targetName);
     const before = await lstat3(targetPath);
     if (before.isSymbolicLink() || !before.isFile()) throw new Error(errorMessage);
     try {
@@ -10400,10 +10762,10 @@ async function readPrivateFileNoFollow(directory, filePath, errorMessage, truste
   }
 }
 async function appendPrivateFileAtPinnedDirectory(pinnedDirectory, targetName, content, errorMessage, directoryHandle, openFile) {
-  if (targetName.length === 0 || targetName === "." || targetName === ".." || path11.basename(targetName) !== targetName) {
+  if (targetName.length === 0 || targetName === "." || targetName === ".." || path12.basename(targetName) !== targetName) {
     throw new Error(errorMessage);
   }
-  const targetPath = path11.join(pinnedDirectory, targetName);
+  const targetPath = path12.join(pinnedDirectory, targetName);
   let fileHandle;
   try {
     try {
@@ -10439,8 +10801,8 @@ async function appendPrivateFileAtPinnedDirectory(pinnedDirectory, targetName, c
 }
 async function appendPrivateFileInPinnedDirectory(pinnedDirectory, fileName, content, errorMessage, platform = process.platform) {
   const descriptorRoot = requirePrivateFileDescriptorRoot(platform, errorMessage);
-  const resolvedDirectory = path11.resolve(pinnedDirectory);
-  const descriptor = path11.relative(descriptorRoot, resolvedDirectory);
+  const resolvedDirectory = path12.resolve(pinnedDirectory);
+  const descriptor = path12.relative(descriptorRoot, resolvedDirectory);
   if (!/^\d+$/.test(descriptor)) throw new Error(errorMessage);
   const before = await stat2(resolvedDirectory);
   if (!before.isDirectory()) throw new Error(errorMessage);
@@ -10456,8 +10818,8 @@ async function appendPrivateFileInPinnedDirectory(pinnedDirectory, fileName, con
   }
 }
 async function writePrivateFileAtomicallyNoFollow(directory, filePath, content, errorMessage, trustedRoot = directory, platform = process.platform, syncVerifiedDirectory = syncDirectoryHandle) {
-  if (path11.dirname(filePath) !== path11.resolve(directory)) throw new Error(errorMessage);
-  const targetName = path11.basename(filePath);
+  if (path12.dirname(filePath) !== path12.resolve(directory)) throw new Error(errorMessage);
+  const targetName = path12.basename(filePath);
   const tempName = `.${targetName}.${randomUUID()}.tmp`;
   let tempPath;
   let directoryHandles = [];
@@ -10466,8 +10828,8 @@ async function writePrivateFileAtomicallyNoFollow(directory, filePath, content,
     const stableDirectory = await openStableDirectoryFromRoot(trustedRoot, directory, errorMessage, platform);
     directoryHandles = stableDirectory.handles;
     const pinnedDirectory = stableDirectory.pinnedDirectory;
-    tempPath = path11.join(pinnedDirectory, tempName);
-    const targetPath = path11.join(pinnedDirectory, targetName);
+    tempPath = path12.join(pinnedDirectory, tempName);
+    const targetPath = path12.join(pinnedDirectory, targetName);
     try {
       fileHandle = await open(
         tempPath,
@@ -10504,7 +10866,7 @@ async function writePrivateFileAtomicallyNoFollow(directory, filePath, content,
 }
 async function removePrivateFilesNoFollow(directory, fileNames, errorMessage, trustedRoot = directory, platform = process.platform) {
   if (fileNames.some(
-    (fileName) => fileName.length === 0 || fileName === "." || fileName === ".." || path11.basename(fileName) !== fileName
+    (fileName) => fileName.length === 0 || fileName === "." || fileName === ".." || path12.basename(fileName) !== fileName
   )) {
     throw new Error(errorMessage);
   }
@@ -10514,7 +10876,7 @@ async function removePrivateFilesNoFollow(directory, fileNames, errorMessage, tr
     directoryHandles = stableDirectory.handles;
     const pinnedDirectory = stableDirectory.pinnedDirectory;
     for (const fileName of fileNames) {
-      await rm2(path11.join(pinnedDirectory, fileName), { force: true });
+      await rm2(path12.join(pinnedDirectory, fileName), { force: true });
     }
     assertStableDirectory(stableDirectory.before, stableDirectory.opened, await lstat3(directory), errorMessage);
     if (stableDirectory.handle) await syncDirectoryHandle(stableDirectory.handle);
@@ -10535,13 +10897,13 @@ var GeneratedBatchMarkerSchema = z2.object({
 }).strict();
 var BATCH_ERROR = "The generated draft batch state is not safe.";
 function batchDirectory(storage) {
-  return path12.join(storage.dir, "state", "support-passport", "generated-batches");
+  return path13.join(storage.dir, "state", "support-passport", "generated-batches");
 }
 function batchFileName(batchId) {
   return `${BatchIdSchema.parse(batchId)}.json`;
 }
 function batchPath(storage, batchId) {
-  return path12.join(batchDirectory(storage), batchFileName(batchId));
+  return path13.join(batchDirectory(storage), batchFileName(batchId));
 }
 function markerFor(context, batchId, size, complete) {
   return GeneratedBatchMarkerSchema.parse({
@@ -10966,7 +11328,7 @@ var SupportPassportAnswerModelInputSchema = z4.object({
 
 // src/support-passport/owner-lock.ts
 import { createHash as createHash6 } from "crypto";
-import path13 from "path";
+import path14 from "path";
 var CARD_MUTATION_LOCK_STALE_MS = 6e4;
 var CARD_MUTATION_LOCK_MAX_WAIT_MS = 3e4;
 function computeSupportPassportOwnerLockKey(namespace, principal) {
@@ -10977,7 +11339,7 @@ function supportPassportOwnerLockPath(storage, scope) {
   if (!/^[a-f0-9]{64}$/.test(ownerLockKey)) {
     throw new SupportPassportError("card_data_invalid", "The support passport owner scope is invalid.", 500);
   }
-  return path13.join(storage.dir, "state", `support-passport-cards-${ownerLockKey}.lock`);
+  return path14.join(storage.dir, "state", `support-passport-cards-${ownerLockKey}.lock`);
 }
 async function withSupportPassportOwnerLock(storage, scope, task) {
   const lockPath = supportPassportOwnerLockPath(storage, scope);
@@ -11875,7 +12237,7 @@ var SupportPassportCardService = class {
 // src/support-passport/grant-store.ts
 import { createHash as createHash7, randomBytes, randomUUID as randomUUID3, timingSafeEqual } from "crypto";
 import { lstat as lstat4, open as open2, readdir as readdir4 } from "fs/promises";
-import path14 from "path";
+import path15 from "path";
 var GRANT_LOCK_STALE_MS = 3e4;
 var GRANT_LOCK_WAIT_MS = 5e3;
 var GRANT_LOCK_HEARTBEAT_MS = 1e4;
@@ -11967,9 +12329,9 @@ var SupportPassportGrantStore = class {
   runWithHeldFileLock;
   syncDirectory;
   constructor(options) {
-    this.memoryDir = path14.resolve(expandTildePath(options.memoryDir));
-    this.grantsDir = path14.join(this.memoryDir, "state", "support-passport", "grants");
-    this.ownerIndexesDir = path14.join(this.grantsDir, "owners");
+    this.memoryDir = path15.resolve(expandTildePath(options.memoryDir));
+    this.grantsDir = path15.join(this.memoryDir, "state", "support-passport", "grants");
+    this.ownerIndexesDir = path15.join(this.grantsDir, "owners");
     this.now = options.now ?? (() => /* @__PURE__ */ new Date());
     this.makeSecret = options.makeSecret ?? (() => randomBytes(32));
     this.makeGrantId = options.makeGrantId ?? randomUUID3;
@@ -12182,11 +12544,11 @@ var SupportPassportGrantStore = class {
   }
   filePath(grantId) {
     const normalizedGrantId = normalizeGrantId(grantId);
-    return path14.join(this.grantsDir, `${normalizedGrantId}.json`);
+    return path15.join(this.grantsDir, `${normalizedGrantId}.json`);
   }
   ownerIndexPath(ownerHash) {
     if (!SAFE_OWNER_INDEX_HASH.test(ownerHash)) throw new Error("support passport owner index hash is invalid");
-    return path14.join(this.ownerIndexesDir, `${ownerHash}.json`);
+    return path15.join(this.ownerIndexesDir, `${ownerHash}.json`);
   }
   ownerHash(namespace, principalHash) {
     return sha256("support-passport-owner-index:v1", `${namespace}\0${principalHash}`);
@@ -12242,12 +12604,12 @@ var SupportPassportGrantStore = class {
       this.grantsDir,
       grantIds.map((grantId) => `${grantId}.json`),
       "support passport grant files must be regular files in a stable directory",
-      path14.parse(this.memoryDir).root
+      path15.parse(this.memoryDir).root
     );
   }
   ownerMembershipDirectory(ownerHash) {
     if (!SAFE_OWNER_INDEX_HASH.test(ownerHash)) throw new Error("support passport owner index hash is invalid");
-    return path14.join(this.ownerIndexesDir, ownerHash);
+    return path15.join(this.ownerIndexesDir, ownerHash);
   }
   async ensureOwnerMembershipDirectory(ownerHash) {
     const directory = this.ownerMembershipDirectory(ownerHash);
@@ -12262,11 +12624,11 @@ var SupportPassportGrantStore = class {
     const directory = await this.ensureOwnerMembershipDirectory(ownerHash);
     await writePrivateFileAtomicallyNoFollow(
       directory,
-      path14.join(directory, `${state.grantId}.json`),
+      path15.join(directory, `${state.grantId}.json`),
       `${JSON.stringify({ schemaVersion: 1, grantId: state.grantId })}
 `,
       "support passport owner membership must be regular files in a stable directory",
-      path14.parse(this.memoryDir).root
+      path15.parse(this.memoryDir).root
     );
   }
   async removeOwnerMembership(state) {
@@ -12276,7 +12638,7 @@ var SupportPassportGrantStore = class {
       directory,
       [`${state.grantId}.json`],
       "support passport owner membership must be regular files in a stable directory",
-      path14.parse(this.memoryDir).root
+      path15.parse(this.memoryDir).root
     );
   }
   async removeStoredGrant(state) {
@@ -12377,7 +12739,7 @@ var SupportPassportGrantStore = class {
     const ownerHash = this.ownerHash(namespace, principalHash);
     const directory = await this.ensureOwnerMembershipDirectory(ownerHash);
     const grantIds = await withPrivateDirectoryNoFollow(
-      path14.parse(this.memoryDir).root,
+      path15.parse(this.memoryDir).root,
       directory,
       "support passport owner membership must be regular files in a stable directory",
       async (pinnedDirectory) => {
@@ -12408,7 +12770,7 @@ var SupportPassportGrantStore = class {
         this.ownerIndexesDir,
         filePath,
         "support passport owner indexes must be regular files in a stable directory",
-        path14.parse(this.memoryDir).root
+        path15.parse(this.memoryDir).root
       );
     } catch (error) {
       if (error.code === "ENOENT") return [];
@@ -12448,7 +12810,7 @@ var SupportPassportGrantStore = class {
       `${JSON.stringify({ schemaVersion: 1, ownerHash, grantIds }, null, 2)}
 `,
       "support passport owner indexes must be regular files in a stable directory",
-      path14.parse(this.memoryDir).root
+      path15.parse(this.memoryDir).root
     );
   }
   async readState(grantId) {
@@ -12458,7 +12820,7 @@ var SupportPassportGrantStore = class {
       this.grantsDir,
       filePath,
       "support passport grant files must be regular files in a stable directory",
-      path14.parse(this.memoryDir).root
+      path15.parse(this.memoryDir).root
     );
     try {
       const state = SupportPassportGrantStateSchema.parse(JSON.parse(content));
@@ -12492,7 +12854,7 @@ var SupportPassportGrantStore = class {
       `${JSON.stringify(state, null, 2)}
 `,
       "support passport grant files must be regular files in a stable directory",
-      path14.parse(this.memoryDir).root
+      path15.parse(this.memoryDir).root
     );
   }
   async ensureSafeDirectories() {
@@ -12526,8 +12888,8 @@ var SupportPassportGrantStore = class {
           void 0
         );
         this.memoryDir = configuredMemoryDir;
-        this.grantsDir = path14.join(configuredMemoryDir, "state", "support-passport", "grants");
-        this.ownerIndexesDir = path14.join(this.grantsDir, "owners");
+        this.grantsDir = path15.join(configuredMemoryDir, "state", "support-passport", "grants");
+        this.ownerIndexesDir = path15.join(this.grantsDir, "owners");
       })();
     }
     const currentAttempt = this.memoryRootReady;
@@ -12541,12 +12903,12 @@ var SupportPassportGrantStore = class {
   async withMutationLock(task) {
     await this.ensureSafeDirectories();
     return await withPrivateDirectoryNoFollow(
-      path14.parse(this.memoryDir).root,
+      path15.parse(this.memoryDir).root,
       this.grantsDir,
       "support passport grant lock directory must remain inside the memory directory",
       async (pinnedDirectory) => await this.withExclusiveLock(
         `support-passport-grants:${this.grantsDir}`,
-        path14.join(pinnedDirectory, ".grants.lock"),
+        path15.join(pinnedDirectory, ".grants.lock"),
         task
       )
     );
@@ -12555,12 +12917,12 @@ var SupportPassportGrantStore = class {
     const normalizedGrantId = normalizeGrantId(grantId);
     await this.ensureSafeDirectories();
     return await withPrivateDirectoryNoFollow(
-      path14.parse(this.memoryDir).root,
+      path15.parse(this.memoryDir).root,
       this.grantsDir,
       "support passport grant lock directory must remain inside the memory directory",
       async (pinnedDirectory) => await this.withExclusiveLock(
         `support-passport-grant:${this.grantsDir}:${normalizedGrantId}`,
-        path14.join(pinnedDirectory, `.${normalizedGrantId}.lock`),
+        path15.join(pinnedDirectory, `.${normalizedGrantId}.lock`),
         task
       )
     );
@@ -12568,12 +12930,12 @@ var SupportPassportGrantStore = class {
   async withOwnerIndexLock(ownerHash, task) {
     await this.ensureSafeDirectories();
     return await withPrivateDirectoryNoFollow(
-      path14.parse(this.memoryDir).root,
+      path15.parse(this.memoryDir).root,
       this.ownerIndexesDir,
       "support passport owner lock directory must remain inside the memory directory",
       async (pinnedDirectory) => await this.withExclusiveLock(
         `support-passport-owner:${this.ownerIndexesDir}:${ownerHash}`,
-        path14.join(pinnedDirectory, `.${ownerHash}.lock`),
+        path15.join(pinnedDirectory, `.${ownerHash}.lock`),
         task
       )
     );
@@ -13411,7 +13773,7 @@ var SupportPassportModelAdapter = class {
 
 // src/support-passport/model-audit.ts
 import { createHash as createHash8 } from "crypto";
-import path15 from "path";
+import path16 from "path";
 import { z as z5 } from "zod";
 var HashSchema = z5.string().regex(/^[a-f0-9]{64}$/);
 var SupportPassportModelAuditRecordSchema = z5.object({
@@ -13456,15 +13818,15 @@ var SupportPassportModelAuditStore = class {
   memoryRootReady;
   runWithHeldFileLock;
   constructor(options) {
-    this.memoryDir = path15.resolve(expandTildePath(options.memoryDir));
-    this.auditDir = path15.join(this.memoryDir, "state", "support-passport", "audit");
+    this.memoryDir = path16.resolve(expandTildePath(options.memoryDir));
+    this.auditDir = path16.join(this.memoryDir, "state", "support-passport", "audit");
     this.runWithHeldFileLock = options.withHeldFileLock ?? withHeldFileLock;
   }
   async record(input) {
     const record = SupportPassportModelAuditRecordSchema.parse(input);
     await this.ensureSafeDirectories();
     const day = record.occurredAt.slice(0, 10);
-    const filePath = path15.join(this.auditDir, `${day}.jsonl`);
+    const filePath = path16.join(this.auditDir, `${day}.jsonl`);
     await serializeMutations(
       `support-passport-audit:${filePath}`,
       () => withPrivateDirectoryNoFollow(
@@ -13472,7 +13834,7 @@ var SupportPassportModelAuditStore = class {
         this.auditDir,
         "support passport audit directory must remain inside the memory directory",
         async (pinnedDirectory) => await this.runWithHeldFileLock(
-          path15.join(pinnedDirectory, `.${day}.lock`),
+          path16.join(pinnedDirectory, `.${day}.lock`),
           {
             staleMs: 3e4,
             maxWaitMs: 5e3,
@@ -13509,7 +13871,7 @@ var SupportPassportModelAuditStore = class {
           "support passport memory directory must be a stable directory"
         );
         this.memoryDir = configuredMemoryDir;
-        this.auditDir = path15.join(configuredMemoryDir, "state", "support-passport", "audit");
+        this.auditDir = path16.join(configuredMemoryDir, "state", "support-passport", "audit");
       })();
     }
     const currentAttempt = this.memoryRootReady;
@@ -15223,6 +15585,36 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
     ]);
     return computeWhoKnows({ topic, limit, memories, entities });
   }
+  /**
+   * Read-only promotion-candidate surfacing (issue #2372): agent-subject,
+   * active, reuse-signaled memories in the caller's namespace with no
+   * equivalent in the target layer. No auto-promotion — callers use the
+   * existing promotion commands.
+   */
+  async promotionCandidates(request) {
+    const limit = request.limit ?? 20;
+    if (!Number.isInteger(limit) || limit < 1 || limit > 100) {
+      throw new EngramAccessInputError(
+        `promotion_candidates: limit expects an integer in [1, 100] (got ${String(request.limit)})`
+      );
+    }
+    const resolvedNamespace = this.resolveReadableNamespace(request.namespace, request.authenticatedPrincipal);
+    const resolvedTarget = this.resolveReadableNamespace(
+      request.targetNamespace ?? this.orchestrator.config.sharedNamespace,
+      request.authenticatedPrincipal
+    );
+    const minAccessCount = this.orchestrator.config.promotionCandidates.minAccessCount;
+    const [memories, targetMemories] = await Promise.all([
+      (await this.orchestrator.getStorage(resolvedNamespace)).readAllMemories(),
+      (await this.orchestrator.getStorage(resolvedTarget)).readAllMemories()
+    ]);
+    return {
+      namespace: resolvedNamespace,
+      targetNamespace: resolvedTarget,
+      minAccessCount,
+      candidates: computePromotionCandidates({ memories, targetMemories, minAccessCount, limit })
+    };
+  }
   async memoryStore(request, hooks) {
     return this.accessObserveWriteSurface.memoryStore(request, hooks);
   }
@@ -15863,6 +16255,35 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
     });
     return { namespace: resolvedNamespace, ...report };
   }
+  /**
+   * Procedure library health maintenance (issue #2370). Shadow-first: the
+   * gate is checked BEFORE any storage read, so `maintenance.enabled=false`
+   * returns `{ enabled: false }` having touched nothing but config. Apply
+   * mode additionally requires `apply: true`; `dryRun: true` forces shadow.
+   *
+   * The authenticated principal (never a client-supplied actor) drives the
+   * namespace via the same writable resolver `procedureMiningRun` uses, so
+   * cross-tenant writes are impossible.
+   */
+  async procedureLibraryMaintenance(request, principal) {
+    const procedural = this.orchestrator.config.procedural;
+    if (procedural?.enabled !== true || procedural.maintenance?.enabled !== true) {
+      return { enabled: false };
+    }
+    const resolvedNamespace = this.writableNamespaceFor(
+      request.namespace,
+      void 0,
+      request.authenticatedPrincipal ?? principal
+    );
+    const storage = await this.orchestrator.getStorage(resolvedNamespace);
+    const report = await runProcedureLibraryMaintenance({
+      memoryDir: storage.dir,
+      storage,
+      config: this.orchestrator.config,
+      apply: request.apply === true && request.dryRun !== true
+    });
+    return { enabled: true, namespace: resolvedNamespace, report };
+  }
   async memorySummarizeHourly() {
     await this.orchestrator.summarizer.runHourly();
     return {
@@ -16987,7 +17408,7 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
     const resolvedNamespace = this.resolveReadableNamespace(options.namespace, options.principal);
     const storage = await offlineSyncStorageForSnapshot(this.orchestrator, resolvedNamespace);
     const storageHash = createHash10("sha256").update(storage.dir).digest("hex").slice(0, 16);
-    const deletions = [...await storage.readDeletionRevisions()].map(([path16, mtimeMs]) => ({ path: path16, mtimeMs }));
+    const deletions = [...await storage.readDeletionRevisions()].map(([path17, mtimeMs]) => ({ path: path17, mtimeMs }));
     const snapshotBuilder = options.includeContent === false && options.baseFiles && options.baseFiles.length > 0 ? buildOfflineSyncSnapshotFromBase : buildOfflineSyncSnapshot;
     const snapshot = await snapshotBuilder({
       root: storage.dir,
@@ -17013,7 +17434,7 @@ var EngramAccessService = class extends SupportPassportAccessServiceBase {
     const storageHash = createHash10("sha256").update(storage.dir).digest("hex").slice(0, 16);
     const deletions = await filterOfflineSyncDeletionRevisions({
       root: storage.dir,
-      deletions: [...await storage.readDeletionRevisions()].map(([path16, mtimeMs]) => ({ path: path16, mtimeMs })),
+      deletions: [...await storage.readDeletionRevisions()].map(([path17, mtimeMs]) => ({ path: path17, mtimeMs })),
       includeTranscripts: options.includeTranscripts !== false,
       userExcludeRegexps: this.offlineSyncUserExcludes
     });
@@ -17647,6 +18068,7 @@ export {
   resolveNamespaceWritablePreflight,
   resolveAuthorizedNamespaceWritablePreflight,
   resolveQueryNamespaceWritablePreflight,
+  runProcedureLibraryMaintenance,
   computeProcedureStats,
   formatProcedureStatsText,
   AccessIdentityContinuitySurface,
@@ -17705,4 +18127,4 @@ export {
   EngramAccessService,
   AccessAdminOpsSurface
 };
-//# sourceMappingURL=chunk-3PXVYJMC.js.map
+//# sourceMappingURL=chunk-SB7D4BT7.js.map