@remnic/core 9.65.0 → 9.65.2

package/dist/who-knows.js

@@ -9,27 +9,27 @@ import {
   loadWhoKnowsEntities,
   tokenizeTopic,
   validateWhoKnowsInput
-} from "./chunk-KLPVXLQJ.js";
-import "./chunk-ZAI5R6DW.js";
+} from "./chunk-SPUJNJJC.js";
+import "./chunk-J275IYMG.js";
 import "./chunk-UHVXE24Y.js";
 import "./chunk-46WM6JX2.js";
 import "./chunk-SXIMQLGV.js";
-import "./chunk-LWVG6U7L.js";
-import "./chunk-ZFBZ4QTS.js";
+import "./chunk-YHCBJULX.js";
+import "./chunk-DJZWNKFO.js";
+import "./chunk-N37X5RU7.js";
+import "./chunk-NNBZS3DY.js";
 import "./chunk-CYEPCZN5.js";
-import "./chunk-ML3U4KPR.js";
-import "./chunk-VYISFWVX.js";
-import "./chunk-6KTXE6A3.js";
-import "./chunk-OQIRBGUU.js";
-import "./chunk-VANZKHTN.js";
+import "./chunk-GIC6BASP.js";
+import "./chunk-YQNNHLCG.js";
 import "./chunk-W7IGLX4G.js";
+import "./chunk-6KTXE6A3.js";
 import "./chunk-GUMZC2BO.js";
 import "./chunk-227UFSEQ.js";
 import "./chunk-ET356KSB.js";
 import "./chunk-72A4L5JJ.js";
 import "./chunk-A7Q43EUZ.js";
 import "./chunk-S2V7RUCL.js";
-import "./chunk-VRYEXPRX.js";
+import "./chunk-SBDCZ2AX.js";
 import "./chunk-SCU65EZI.js";
 import "./chunk-PO7NXBG2.js";
 import "./chunk-S2HLHAZ4.js";
@@ -37,12 +37,13 @@ import "./chunk-DM2T26WE.js";
 import "./chunk-LDXUBPMO.js";
 import "./chunk-UG6VXIOK.js";
 import "./chunk-AAD2ZS6P.js";
-import "./chunk-MUJ4QFUQ.js";
-import "./chunk-LCU5R6TQ.js";
+import "./chunk-W4BMEGQA.js";
+import "./chunk-RAIUTAZZ.js";
 import "./chunk-BT7NVCML.js";
 import "./chunk-3ONXXHQO.js";
 import "./chunk-YXZG5TVN.js";
 import "./chunk-5GINB5LC.js";
+import "./chunk-3WU7XOFN.js";
 import "./chunk-UFKPQBXH.js";
 import "./chunk-XCB6QDL6.js";
 import "./chunk-RBOJCG4T.js";
@@ -50,8 +51,8 @@ import "./chunk-ZVPVTPGI.js";
 import "./chunk-5WITETWU.js";
 import "./chunk-6CIAGZ6X.js";
 import "./chunk-G7D6GZ5J.js";
-import "./chunk-VYEPACWY.js";
-import "./chunk-URS5GSM7.js";
+import "./chunk-C24UZSFW.js";
+import "./chunk-JXN77SGO.js";
 import "./chunk-ZLQ37WJX.js";
 import "./chunk-IUM3VSHI.js";
 import "./chunk-C64XATK7.js";
@@ -63,6 +64,7 @@ import "./chunk-45GF7Y3V.js";
 import "./chunk-RGMVMVMF.js";
 import "./chunk-N7RWREIQ.js";
 import "./chunk-NXH34IPL.js";
+import "./chunk-RIAM7DND.js";
 import "./chunk-ZIKENA2C.js";
 import "./chunk-PQVCH2AE.js";
 import "./chunk-6Q3ZTEF6.js";
@@ -79,13 +81,13 @@ import "./chunk-DVYRD4HY.js";
 import "./chunk-ZA53AZND.js";
 import "./chunk-GCASGYIO.js";
 import "./chunk-7RJUVTVF.js";
-import "./chunk-JOEJG4SD.js";
 import "./chunk-2LWQSV6A.js";
 import "./chunk-RL6NEVXT.js";
-import "./chunk-5FVVY2EB.js";
-import "./chunk-FFAZ2XFU.js";
 import "./chunk-XDL5CYZN.js";
 import "./chunk-JDSVLVCG.js";
+import "./chunk-JOEJG4SD.js";
+import "./chunk-5FVVY2EB.js";
+import "./chunk-FFAZ2XFU.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
 import "./chunk-P7FMDTKL.js";

package/dist/write-envelope.d.ts

@@ -1,4 +1,4 @@
-import { x as MemoryCategory } from './types-D9gKdB79.js';
+import { x as MemoryCategory, N as MemorySubject } from './types-Pi0lfaEt.js';
 import './message-parts/index.js';
 import './bounded-jsonl-state.js';
 import './types-CM86alG1.js';
@@ -62,6 +62,8 @@ interface MemoryWriteInput {
     sourceConnector?: string;
     /** Origin class stamped at creation time (issue #1955). */
     origin?: string;
+    /** Whom the memory models (issue #2372): "user" or "agent". */
+    subject?: MemorySubject;
     /** Human-readable provenance note. */
     sourceReason?: string;
 }
@@ -150,6 +152,7 @@ interface SealedMemoryEnvelope {
     readonly validAt: string | undefined;
     readonly sourceConnector: string | undefined;
     readonly origin: string | undefined;
+    readonly subject: MemorySubject | undefined;
     readonly sourceReason: string | undefined;
     readonly source: string;
     /** ISO timestamp the envelope was composed (from ctx.now). */
@@ -227,7 +230,7 @@ declare const WRITE_FINGERPRINT_FIELDS: readonly ["content", "category", "tags",
  * is a visible, reviewable decision — this list exists so the exhaustiveness
  * guard can force every new `MemoryWriteInput` field to be classified.
  */
-declare const FINGERPRINT_EXEMPT_FIELDS: readonly ["confidence", "origin", "sourceReason"];
+declare const FINGERPRINT_EXEMPT_FIELDS: readonly ["confidence", "origin", "subject", "sourceReason"];
 /** Scope keys always folded into the fingerprint payload. */
 declare const FINGERPRINT_SCOPE_FIELDS: readonly ["surface", "namespace", "principal", "codingContext"];
 /**

package/dist/write-envelope.js

@@ -11,12 +11,21 @@ import {
   isMemoryCategory,
   isSealedMemoryEnvelope,
   sealedWriteToLegacyArgs
-} from "./chunk-LCU5R6TQ.js";
+} from "./chunk-RAIUTAZZ.js";
 import "./chunk-BT7NVCML.js";
+import "./chunk-RIAM7DND.js";
 import "./chunk-JDSVLVCG.js";
+import "./chunk-JOEJG4SD.js";
+import "./chunk-5FVVY2EB.js";
+import "./chunk-FFAZ2XFU.js";
 import "./chunk-5GKPFL3S.js";
 import "./chunk-JAKIDQB2.js";
 import "./chunk-P7FMDTKL.js";
+import "./chunk-XQ3HXAQH.js";
+import "./chunk-A6XUJE5D.js";
+import "./chunk-5UZXUTVO.js";
+import "./chunk-VS2IYZRU.js";
+import "./chunk-3WCASNQZ.js";
 import "./chunk-PZ5AY32C.js";
 export {
   FINGERPRINT_EXEMPT_FIELDS,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remnic/core",
-  "version": "9.65.0",
+  "version": "9.65.2",
   "description": "Framework-agnostic Remnic memory engine — orchestrator, storage, extraction, search, trust zones",
   "type": "module",
   "main": "dist/index.js",
@@ -3166,7 +3166,7 @@
     "core"
   ],
   "peerDependencies": {
-    "@remnic/coding-graph": "^9.65.0"
+    "@remnic/coding-graph": "^9.65.2"
   },
   "peerDependenciesMeta": {
     "@remnic/coding-graph": {

package/scripts/build-with-heap.mjs

@@ -9,7 +9,7 @@ import { cp, mkdir, rm } from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
 
-const HEAP_DEFAULT = "--max-old-space-size=8192";
+const HEAP_DEFAULT = "--max-old-space-size=12288";
 const existing = process.env.NODE_OPTIONS?.trim();
 // Caller-supplied NODE_OPTIONS goes last so V8's last-wins parsing lets
 // callers override the default heap limit.

package/src/access-boundary.ts

@@ -68,6 +68,7 @@ export const OPERATION_NAMES = [
   "recall_tier_explain",
   "recall_xray",
   "who_knows",
+  "promotion_candidates",
   "namespace_writable",
   "wearables_status",
   "wearables_sync",
@@ -88,6 +89,7 @@ export const OPERATION_NAMES = [
   "procedure_mining_run",
   "pattern_reinforcement_run",
   "procedural_stats",
+  "procedure_library_maintenance",
   "memory_timeline",
   "suggestion_submit",
   "entity_get",

package/src/access-mcp-admin-tools.ts

@@ -168,4 +168,18 @@ export const MCP_ADMIN_OPS_TOOLS: Array<{
     additionalProperties: false,
   },
 },
+{
+  name: "engram.procedure_library_maintenance",
+  description:
+    "Run procedure library health maintenance (issue #2370): merge near-duplicate active procedures, flag stale-tool procedures for repair, and retire failure-dominant or idle ones — from Memory Worth + trajectory telemetry. Shadow-first: default run writes nothing and returns a proposed-transition report. apply=true (and procedural.maintenance.enabled) executes transitions; dryRun=true forces shadow.",
+  inputSchema: {
+    type: "object",
+    properties: {
+      namespace: { type: "string" },
+      apply: { type: "boolean" },
+      dryRun: { type: "boolean" },
+    },
+    additionalProperties: false,
+  },
+},
 ];

package/src/access-mcp-output-schemas.ts

@@ -55,6 +55,7 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
   recall_tier_explain: objectSchema({ snapshotFound: T_BOOLEAN, tierExplain: T_NULLABLE_OBJECT }),
   recall_xray: objectSchema({ snapshotFound: T_BOOLEAN, snapshot: T_OBJECT }),
   who_knows: objectSchema({ topic: T_STRING, results: T_ARRAY }),
+  promotion_candidates: objectSchema({ namespace: T_STRING, targetNamespace: T_STRING, candidates: T_ARRAY }),
   set_coding_context: objectSchema({ ok: T_BOOLEAN }),
   wearables_status: objectSchema({
     enabled: T_BOOLEAN,
@@ -132,6 +133,11 @@ const TOOL_OUTPUT_SCHEMAS: Readonly<Record<string, Record<string, unknown>>> = {
     duplicatesSuperseded: T_NUMBER,
   }),
   procedural_stats: objectSchema({ namespace: T_STRING, counts: T_OBJECT, recent: T_OBJECT }),
+  procedure_library_maintenance: objectSchema({
+    enabled: T_BOOLEAN,
+    namespace: T_STRING,
+    report: T_OBJECT,
+  }),
   memory_get: objectSchema({ found: T_BOOLEAN, namespace: T_STRING, memory: T_NULLABLE_OBJECT }),
   memory_timeline: objectSchema({ found: T_BOOLEAN, namespace: T_STRING, count: T_NUMBER, timeline: T_ARRAY }),
   memory_store: objectSchema({

package/src/access-mcp.ts

@@ -46,6 +46,7 @@ import { MCP_READ_ONLY_TOOL_SUFFIXES } from "./mcp-read-only-tools.js";
 import { MEETINGS_MCP_TOOLS } from "./meetings/mcp-tools.js";
 import { WEARABLES_MCP_TOOLS } from "./wearables/mcp-tools.js";
 import { WHO_KNOWS_MCP_TOOLS } from "./who-knows.js";
+import { PROMOTION_CANDIDATES_MCP_TOOLS } from "./memory-subject.js";
 import { EXTERNAL_WIKI_MCP_TOOLS } from "./external-wiki-mcp-tools.js";
 import { abortError, isAbortError } from "./abort-error.js";
 import { SUPPORT_PASSPORT_MCP_MIGRATED_OPERATIONS, SUPPORT_PASSPORT_MCP_TOOLS } from "./support-passport/mcp-tools.js";
@@ -156,7 +157,7 @@ function withToolAliases(tool: McpTool, emitLegacyTools = true): McpTool[] {
   return emitLegacyTools ? [canonicalTool, tool] : [canonicalTool];
 }
 
-const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
+export const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   "engram.memory_get": "memory_get",
   "engram.memory_search": "memory_search",
   "engram.external_wiki_search": "external_wiki_search",
@@ -185,9 +186,8 @@ const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   // Fully migrated through the strict-schema boundary (#1668).
   "engram.recall": "recall",
   "engram.recall_explain": "recall_explain",
-  "engram.set_coding_context": "set_coding_context",
-  "engram.recall_tier_explain": "recall_tier_explain",
-  "engram.recall_xray": "recall_xray", "engram.who_knows": "who_knows",
+  "engram.set_coding_context": "set_coding_context", "engram.recall_tier_explain": "recall_tier_explain",
+  "engram.recall_xray": "recall_xray", "engram.who_knows": "who_knows", "engram.promotion_candidates": "promotion_candidates",
   "engram.wearables_status": "wearables_status",
   "engram.wearables_sync": "wearables_sync",
   "engram.transcript_day": "transcript_day",
@@ -203,7 +203,7 @@ const MCP_MIGRATED_OPERATIONS: Readonly<Record<string, OperationName>> = {
   "engram.entity_synthesis_run": "entity_synthesis_run",
   "engram.procedure_mining_run": "procedure_mining_run",
   "engram.pattern_reinforcement_run": "pattern_reinforcement_run",
-  "engram.procedural_stats": "procedural_stats",
+  "engram.procedural_stats": "procedural_stats", "engram.procedure_library_maintenance": "procedure_library_maintenance",
   "engram.memory_timeline": "memory_timeline",
   "engram.suggestion_submit": "suggestion_submit",
   "engram.entity_get": "entity_get",
@@ -706,7 +706,7 @@ export class EngramMcpServer {
           additionalProperties: false,
         },
       },
-      ...WEARABLES_MCP_TOOLS, ...MEETINGS_MCP_TOOLS, ...WHO_KNOWS_MCP_TOOLS,
+      ...WEARABLES_MCP_TOOLS, ...MEETINGS_MCP_TOOLS, ...WHO_KNOWS_MCP_TOOLS, ...PROMOTION_CANDIDATES_MCP_TOOLS,
       ...(service.supportPassportEnabled ? SUPPORT_PASSPORT_MCP_TOOLS : []),
       {
         name: "engram.action_confidence",

package/src/access-operations-batch.ts

@@ -147,6 +147,13 @@ defineOperation({ name: "who_knows", description: "Rank entities by demonstrated
     return { result: await ctx.service.whoKnows({ topic, ...(limit !== undefined ? { limit } : {}), namespace: optStr(input.namespace), authenticatedPrincipal: ctx.authenticatedPrincipal }) };
   },
 });
+defineOperation({ name: "promotion_candidates", description: "List agent-subject reuse-signaled promotion candidates (#2372).", schema: strictSchema({ namespace: S.str, targetNamespace: S.str, limit: S.flexNum }),
+  handler: async (input, ctx) => {
+    let limit: number | undefined;
+    if (input.limit !== undefined) { const p = typeof input.limit === "number" ? input.limit : Number(input.limit); if (!Number.isInteger(p) || p < 1 || p > 100) throw new EngramAccessInputError("promotion_candidates: limit expects an integer in [1, 100]"); limit = p; }
+    return { result: await ctx.service.promotionCandidates({ ...(limit !== undefined ? { limit } : {}), namespace: optStr(input.namespace), targetNamespace: optStr(input.targetNamespace), authenticatedPrincipal: ctx.authenticatedPrincipal }) };
+  },
+});
 defineOperation({ name: "namespace_writable", description: "Read-only preflight: is a namespace writable for the caller's principal?", allowedByOps: ["namespace_writable", "observe", "memory_store"], schema: strictSchema({ namespace: S.str, sessionKey: S.str, op: S.str, cwd: S.str, projectTag: S.str }), handler: async (input, ctx) => {
   const writeOp = parseNamespacePreflightWriteOp(optStr(input.op));
   const namespace = optStr(input.namespace);
@@ -213,6 +220,7 @@ defineOperation({ name: "entity_synthesis_run", description: "Bulk-drain the ent
 defineOperation({ name: "procedure_mining_run", description: "Run procedure mining.", schema: strictSchema({ namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.procedureMiningRun({ namespace: optStr(input.namespace), authenticatedPrincipal: ctx.authenticatedPrincipal }, ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "pattern_reinforcement_run", description: "Run pattern reinforcement.", schema: strictSchema({ namespace: S.str, force: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.patternReinforcementRun({ namespace: optStr(input.namespace), force: input.force === true, authenticatedPrincipal: ctx.authenticatedPrincipal }, ctx.authenticatedPrincipal) }) });
 defineOperation({ name: "procedural_stats", description: "Procedural stats.", schema: strictSchema({ namespace: S.str }), handler: async (input, ctx) => ({ result: await ctx.service.procedureStats({ namespace: optStr(input.namespace) }, ctx.authenticatedPrincipal) }) });
+defineOperation({ name: "procedure_library_maintenance", description: "Run procedure library maintenance (issue #2370): shadow-first merge / repair-flag / retire from outcome telemetry. apply=true plus procedural.maintenance.enabled required for writes.", schema: strictSchema({ namespace: S.str, apply: S.bool, dryRun: S.bool }), handler: async (input, ctx) => ({ result: await ctx.service.procedureLibraryMaintenance({ namespace: optStr(input.namespace), apply: input.apply === true, dryRun: input.dryRun === true, authenticatedPrincipal: ctx.authenticatedPrincipal }, ctx.authenticatedPrincipal) }) });
 
 // === MEMORY/ENTITY/OBSERVE/LCM ===
 defineOperation({ name: "memory_timeline", description: "Memory timeline.", schema: strictSchema({ memoryId: S.str, namespace: S.str, limit: S.num }), handler: async (input, ctx) => ({ result: await ctx.service.memoryTimeline(optStr(input.memoryId) ?? "", optStr(input.namespace), optNum(input.limit) ?? 200, ctx.authenticatedPrincipal) }) });

package/src/access-service.ts

@@ -201,6 +201,10 @@ import type {
   RecallInvocationOptions,
 } from "./orchestrator.js";
 import { type ProcedureStatsReport, computeProcedureStats } from "./procedural/procedure-stats.js";
+import {
+  runProcedureLibraryMaintenance,
+  type ProcedureLibraryMaintenanceReport,
+} from "./procedural/library-maintenance.js";
 import type { RecallContextComposition } from "./recall-context-composition.js";
 import type { LastRecallSnapshot } from "./recall-state.js";
 import {
@@ -305,6 +309,7 @@ import { toRecallExplainJson } from "./recall-explain-renderer.js";
 import { type TagMatchMode, applyTagFilter, normalizeTags, parseTagMatch } from "./recall-tag-filter.js";
 import { type RecallXraySnapshot, estimateRecallTokens } from "./recall-xray.js";
 import { computeWhoKnows, loadWhoKnowsEntities, validateWhoKnowsInput, WHO_KNOWS_DEFAULT_LIMIT, type WhoKnowsResult } from "./who-knows.js";
+import { computePromotionCandidates, type PromotionCandidatesResult } from "./memory-subject.js";
 import { SupportPassportAccessServiceBase } from "./support-passport/access-service-base.js";
 import {
   type ExportCapsuleOptions,
@@ -2738,6 +2743,41 @@ export class EngramAccessService 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: {
+    namespace?: string;
+    targetNamespace?: string;
+    limit?: number;
+    authenticatedPrincipal?: string;
+  }): Promise<PromotionCandidatesResult> {
+    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: EngramAccessMemoryStoreRequest,
     hooks?: { enforceWriteQuota?: () => void | Promise<void> }
@@ -3580,6 +3620,51 @@ export class EngramAccessService 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: {
+      namespace?: string;
+      apply?: boolean;
+      dryRun?: boolean;
+      authenticatedPrincipal?: string;
+    },
+    principal?: string
+  ): Promise<
+    | { enabled: false }
+    | {
+        enabled: true;
+        namespace: string;
+        report: ProcedureLibraryMaintenanceReport;
+      }
+  > {
+    const procedural = this.orchestrator.config.procedural;
+    if (procedural?.enabled !== true || procedural.maintenance?.enabled !== true) {
+      return { enabled: false };
+    }
+    const resolvedNamespace = this.writableNamespaceFor(
+      request.namespace,
+      undefined,
+      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(): Promise<{
     ok: true;
     message: string;

package/src/access-surface-catalog.ts

@@ -57,6 +57,7 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "recall_tier_explain", operation: "recall_tier_explain" },
   { tool: "recall_xray", operation: "recall_xray" },
   { tool: "who_knows", operation: "who_knows" },
+  { tool: "promotion_candidates", operation: "promotion_candidates" },
   { tool: "wearables_status", operation: "wearables_status" },
   { tool: "wearables_sync", operation: "wearables_sync" },
   { tool: "transcript_day", operation: "transcript_day" },
@@ -76,6 +77,7 @@ export const MCP_TOOLS: readonly McpToolEntry[] = [
   { tool: "procedure_mining_run", operation: "procedure_mining_run" },
   { tool: "pattern_reinforcement_run", operation: "pattern_reinforcement_run" },
   { tool: "procedural_stats", operation: "procedural_stats" },
+  { tool: "procedure_library_maintenance", operation: "procedure_library_maintenance" },
   { tool: "memory_get", operation: "memory_get" },
   { tool: "memory_timeline", operation: "memory_timeline" },
   { tool: "memory_store", operation: "memory_store" },

package/src/config.ts

@@ -37,10 +37,12 @@ import { expandTildePath } from "./utils/path.js";
 // lives in connectors/coerce.ts (a tiny, dependency-free module) so neither
 // config.ts → connectors/index.ts nor the reverse circular import arises.
 import { coerceBool, coerceBooleanLike, coerceInstallExtension, coerceNumber } from "./connectors/coerce.js";
+import { parseSubjectRuntimeConfig } from "./subject-config.js";
 import { parseRecallConcurrencyConfig } from "./recall-concurrency-config.js";
 import { parseExtractionLivenessConfig } from "./extraction-liveness.js";
 import { parseReplicaPeersConfig } from "./replica-peers-config.js";
 import { parseDependencyPropagationConfig } from "./dependency-propagation-config.js";
+import { parseProceduralMaintenanceConfig } from "./procedural/maintenance-config.js";
 import {
   parseContradictionLocalizationConfig,
   parseContradictionScanConfig,
@@ -1123,16 +1125,9 @@ export function parseConfig(
     recallMaxCoerced !== undefined && Number.isFinite(recallMaxCoerced)
       ? Math.min(10, Math.max(1, Math.floor(recallMaxCoerced)))
       : 2;
-  // Default-on procedural memory (issue #567 PR 4/5): if the user has NOT
-  // explicitly set `procedural.enabled`, enable it. Explicit `false` (or any
-  // value coerceBool reads as false: `"0"`, `"no"`, `"off"`, `false`) keeps
-  // the feature off. CLAUDE.md rules:
-  //   - #30 — escape hatch remains for operators who want to stay opt-out.
-  //   - #36 — "false"-ish strings coerce to false via coerceBool.
-  //   - #51 — when the key IS present but the value can't be understood
-  //     (typo like `"fales"` or a number like `0`), reject loudly instead
-  //     of silently flipping the default. Silent fallback on bad input is
-  //     how procedural memory would end up "fail-open" for typos.
+  const maintenance = parseProceduralMaintenanceConfig(rawProcedural.maintenance);
+  // Default-on procedural memory (issue #567 PR 4/5). Explicit false-ish
+  // values stay off. Unknown values throw.
   const rawEnabledValue = rawProcedural.enabled;
   let proceduralEnabled: boolean;
   if (rawEnabledValue === undefined) {
@@ -1147,6 +1142,7 @@ export function parseConfig(
     proceduralEnabled = enabledCoerced;
   }
   const procedural: ProceduralConfig = {
+    maintenance,
     enabled: proceduralEnabled,
     /** `0` skips all mining (`minOccurrences_zero`); otherwise clusters need at least this many members. */
     minOccurrences: Math.min(1000, Math.max(0, proceduralMinRaw)),
@@ -2755,11 +2751,11 @@ export function parseConfig(
       }
       return "low";
     })(),
-    // Extraction scope classification. When enabled, the extraction prompt
-    // asks the LLM to classify each fact as "project" or "global". Global
-    // facts are promoted to the shared namespace. Default true (rule 30 gate).
+    // Extraction scope classification (rule 30 gate): "global" facts promote
+    // to the shared namespace. Default true.
     extractionScopeClassificationEnabled:
       coerceBool(cfg.extractionScopeClassificationEnabled) !== false,
+    ...parseSubjectRuntimeConfig(cfg),
     // Extraction judge (issue #376). Opt-in LLM-as-judge fact-worthiness gate.
     extractionJudgeEnabled: cfg.extractionJudgeEnabled === true,
     extractionJudgeModel:
@@ -2778,10 +2774,7 @@ export function parseConfig(
         ? Math.floor(cfg.extractionJudgeMaxDeferrals)
         : 2,
     // Judge telemetry (issue #562 PR 3): opt-in structured emit to the
-    // observation ledger for defer-rate / latency metrics.
-    // Uses `coerceBool` so CLI-style string inputs (`"true"`, `"false"`,
-    // `"1"`, `"0"`) are accepted consistently with the rest of the
-    // codebase (CLAUDE.md gotcha 36).
+    // observation ledger; `coerceBool` accepts CLI-style strings (gotcha 36).
     extractionJudgeTelemetryEnabled:
       coerceBool(cfg.extractionJudgeTelemetryEnabled) === true,
     // Judge training-pair collection (issue #562 PR 4): opt-in shim for a

package/src/cross-lingual-recall.test.ts

@@ -0,0 +1,47 @@
+import assert from "node:assert/strict";
+import test from "node:test";
+
+import {
+  corpusDominantLanguage,
+  detectLanguageHint,
+  planCrossScript,
+} from "./cross-lingual-recall.js";
+
+test("detectLanguageHint distinguishes Latin and Japanese", () => {
+  assert.equal(detectLanguageHint("what did we decide about the deployment?"), "latn");
+  assert.equal(detectLanguageHint("これはテストです"), "jpan");
+  assert.equal(detectLanguageHint("デプロイは金曜に延期と決定"), "jpan");
+});
+
+test("legacy memories without a language hint do not vote", () => {
+  assert.equal(corpusDominantLanguage([undefined, undefined, "jpan", "jpan", "latn"]), "jpan");
+  assert.equal(corpusDominantLanguage([undefined, undefined]), undefined);
+});
+
+test("cross-script plan leans on vector and signals when embeddings are missing", () => {
+  const withVector = planCrossScript({
+    queryLanguage: "latn",
+    corpusLanguage: "jpan",
+    vectorTierAvailable: true,
+  });
+  assert.equal(withVector.crossScript, true);
+  assert.equal(withVector.degradation, undefined);
+
+  const withoutVector = planCrossScript({
+    queryLanguage: "latn",
+    corpusLanguage: "jpan",
+    vectorTierAvailable: false,
+  });
+  assert.equal(withoutVector.crossScript, true);
+  assert.equal(withoutVector.degradation?.code, "vector_tier_unavailable");
+});
+
+test("same-script query does not degrade", () => {
+  const plan = planCrossScript({
+    queryLanguage: "latn",
+    corpusLanguage: "latn",
+    vectorTierAvailable: false,
+  });
+  assert.equal(plan.crossScript, false);
+  assert.equal(plan.degradation, undefined);
+});