@remnic/core 1.0.2 → 1.1.0

package/dist/chunk-OIT5QGG4.js

@@ -0,0 +1,80 @@
+// src/taxonomy/resolver.ts
+var DEFAULT_CATEGORY_ID = "facts";
+function resolveCategory(content, memoryCategory, taxonomy) {
+  const contentLower = content.toLowerCase();
+  const matches = taxonomy.categories.filter(
+    (cat) => cat.memoryCategories.includes(memoryCategory)
+  );
+  if (matches.length === 0) {
+    const fallback = taxonomy.categories.find((c) => c.id === DEFAULT_CATEGORY_ID) ?? taxonomy.categories[0];
+    if (!fallback) {
+      return {
+        categoryId: DEFAULT_CATEGORY_ID,
+        confidence: 0,
+        reason: "Taxonomy is empty; using default category",
+        alternatives: []
+      };
+    }
+    const alternatives2 = taxonomy.categories.filter((c) => c.id !== fallback.id).map((c) => ({
+      categoryId: c.id,
+      reason: c.description
+    }));
+    return {
+      categoryId: fallback.id,
+      confidence: 0.3,
+      reason: `No taxonomy category maps to MemoryCategory "${memoryCategory}"; falling back to "${fallback.name}"`,
+      alternatives: alternatives2
+    };
+  }
+  if (matches.length === 1) {
+    const match = matches[0];
+    const alternatives2 = taxonomy.categories.filter((c) => c.id !== match.id).map((c) => ({
+      categoryId: c.id,
+      reason: c.description
+    }));
+    return {
+      categoryId: match.id,
+      confidence: 1,
+      reason: `Unique match: MemoryCategory "${memoryCategory}" maps to "${match.name}"`,
+      alternatives: alternatives2
+    };
+  }
+  const scored = matches.map((cat) => ({
+    cat,
+    keywordScore: computeKeywordScore(contentLower, cat)
+  }));
+  scored.sort((a, b) => {
+    if (b.keywordScore !== a.keywordScore) return b.keywordScore - a.keywordScore;
+    return a.cat.priority - b.cat.priority;
+  });
+  const best = scored[0];
+  const runnerUp = scored[1];
+  const confidence = best.keywordScore > 0 && (!runnerUp || best.keywordScore > runnerUp.keywordScore) ? 0.9 : 0.7;
+  const alternatives = taxonomy.categories.filter((c) => c.id !== best.cat.id).map((c) => ({
+    categoryId: c.id,
+    reason: c.description
+  }));
+  const reason = best.keywordScore > 0 ? `Filing rules for "${best.cat.name}" matched content keywords (priority ${best.cat.priority})` : `Priority tie-break: "${best.cat.name}" has lowest priority number (${best.cat.priority})`;
+  return {
+    categoryId: best.cat.id,
+    confidence,
+    reason,
+    alternatives
+  };
+}
+function computeKeywordScore(contentLower, cat) {
+  let score = 0;
+  const ruleText = [...cat.filingRules, cat.description].join(" ").toLowerCase();
+  const keywords = ruleText.split(/[^a-z0-9]+/).filter((w) => w.length >= 3);
+  for (const kw of keywords) {
+    if (contentLower.includes(kw)) {
+      score += 1;
+    }
+  }
+  return score;
+}
+
+export {
+  resolveCategory
+};
+//# sourceMappingURL=chunk-OIT5QGG4.js.map

package/dist/chunk-OIT5QGG4.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/taxonomy/resolver.ts"],"sourcesContent":["/**\n * Resolver decision tree for the MECE taxonomy.\n *\n * Given extracted content and its MemoryCategory, determines which\n * taxonomy category the knowledge should be filed under.\n */\n\nimport type { MemoryCategory } from \"../types.js\";\nimport type { ResolverDecision, Taxonomy, TaxonomyCategory } from \"./types.js\";\n\nconst DEFAULT_CATEGORY_ID = \"facts\";\n\n/**\n * Resolve a piece of content to a taxonomy category.\n *\n * Algorithm:\n * 1. Find all taxonomy categories whose `memoryCategories` include\n *    the given `memoryCategory`.\n * 2. If exactly one match, return it with confidence 1.0.\n * 3. If multiple matches, pick the one with the lowest priority\n *    number (highest precedence). Apply keyword heuristics from\n *    filing rules as a secondary signal.\n * 4. If no match, fall back to the \"facts\" category (or first\n *    category if \"facts\" is absent) with low confidence.\n * 5. Always populate `alternatives` with other plausible categories.\n */\nexport function resolveCategory(\n  content: string,\n  memoryCategory: MemoryCategory,\n  taxonomy: Taxonomy,\n): ResolverDecision {\n  const contentLower = content.toLowerCase();\n\n  // Step 1: find matching categories\n  const matches = taxonomy.categories.filter((cat) =>\n    cat.memoryCategories.includes(memoryCategory),\n  );\n\n  if (matches.length === 0) {\n    // No taxonomy category accepts this MemoryCategory — fall back\n    const fallback =\n      taxonomy.categories.find((c) => c.id === DEFAULT_CATEGORY_ID) ??\n      taxonomy.categories[0];\n    if (!fallback) {\n      return {\n        categoryId: DEFAULT_CATEGORY_ID,\n        confidence: 0,\n        reason: \"Taxonomy is empty; using default category\",\n        alternatives: [],\n      };\n    }\n    const alternatives = taxonomy.categories\n      .filter((c) => c.id !== fallback.id)\n      .map((c) => ({\n        categoryId: c.id,\n        reason: c.description,\n      }));\n    return {\n      categoryId: fallback.id,\n      confidence: 0.3,\n      reason: `No taxonomy category maps to MemoryCategory \"${memoryCategory}\"; falling back to \"${fallback.name}\"`,\n      alternatives,\n    };\n  }\n\n  if (matches.length === 1) {\n    const match = matches[0]!;\n    const alternatives = taxonomy.categories\n      .filter((c) => c.id !== match.id)\n      .map((c) => ({\n        categoryId: c.id,\n        reason: c.description,\n      }));\n    return {\n      categoryId: match.id,\n      confidence: 1.0,\n      reason: `Unique match: MemoryCategory \"${memoryCategory}\" maps to \"${match.name}\"`,\n      alternatives,\n    };\n  }\n\n  // Multiple matches — use filing rule keyword heuristics + priority\n  const scored = matches.map((cat) => ({\n    cat,\n    keywordScore: computeKeywordScore(contentLower, cat),\n  }));\n\n  // Sort by keyword score descending, then priority ascending (lower wins)\n  scored.sort((a, b) => {\n    if (b.keywordScore !== a.keywordScore) return b.keywordScore - a.keywordScore;\n    return a.cat.priority - b.cat.priority;\n  });\n\n  const best = scored[0]!;\n  const runnerUp = scored[1];\n\n  // Confidence is higher when keyword match clearly differentiates\n  const confidence =\n    best.keywordScore > 0 && (!runnerUp || best.keywordScore > runnerUp.keywordScore)\n      ? 0.9\n      : 0.7;\n\n  const alternatives = taxonomy.categories\n    .filter((c) => c.id !== best.cat.id)\n    .map((c) => ({\n      categoryId: c.id,\n      reason: c.description,\n    }));\n\n  const reason =\n    best.keywordScore > 0\n      ? `Filing rules for \"${best.cat.name}\" matched content keywords (priority ${best.cat.priority})`\n      : `Priority tie-break: \"${best.cat.name}\" has lowest priority number (${best.cat.priority})`;\n\n  return {\n    categoryId: best.cat.id,\n    confidence,\n    reason,\n    alternatives,\n  };\n}\n\n/**\n * Compute a simple keyword overlap score between content and\n * a category's filing rules + description.\n */\nfunction computeKeywordScore(contentLower: string, cat: TaxonomyCategory): number {\n  let score = 0;\n  const ruleText = [...cat.filingRules, cat.description]\n    .join(\" \")\n    .toLowerCase();\n\n  // Extract meaningful words (3+ chars) from the rule text\n  const keywords = ruleText\n    .split(/[^a-z0-9]+/)\n    .filter((w) => w.length >= 3);\n\n  for (const kw of keywords) {\n    if (contentLower.includes(kw)) {\n      score += 1;\n    }\n  }\n  return score;\n}\n"],"mappings":";AAUA,IAAM,sBAAsB;AAgBrB,SAAS,gBACd,SACA,gBACA,UACkB;AAClB,QAAM,eAAe,QAAQ,YAAY;AAGzC,QAAM,UAAU,SAAS,WAAW;AAAA,IAAO,CAAC,QAC1C,IAAI,iBAAiB,SAAS,cAAc;AAAA,EAC9C;AAEA,MAAI,QAAQ,WAAW,GAAG;AAExB,UAAM,WACJ,SAAS,WAAW,KAAK,CAAC,MAAM,EAAE,OAAO,mBAAmB,KAC5D,SAAS,WAAW,CAAC;AACvB,QAAI,CAAC,UAAU;AACb,aAAO;AAAA,QACL,YAAY;AAAA,QACZ,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,cAAc,CAAC;AAAA,MACjB;AAAA,IACF;AACA,UAAMA,gBAAe,SAAS,WAC3B,OAAO,CAAC,MAAM,EAAE,OAAO,SAAS,EAAE,EAClC,IAAI,CAAC,OAAO;AAAA,MACX,YAAY,EAAE;AAAA,MACd,QAAQ,EAAE;AAAA,IACZ,EAAE;AACJ,WAAO;AAAA,MACL,YAAY,SAAS;AAAA,MACrB,YAAY;AAAA,MACZ,QAAQ,gDAAgD,cAAc,uBAAuB,SAAS,IAAI;AAAA,MAC1G,cAAAA;AAAA,IACF;AAAA,EACF;AAEA,MAAI,QAAQ,WAAW,GAAG;AACxB,UAAM,QAAQ,QAAQ,CAAC;AACvB,UAAMA,gBAAe,SAAS,WAC3B,OAAO,CAAC,MAAM,EAAE,OAAO,MAAM,EAAE,EAC/B,IAAI,CAAC,OAAO;AAAA,MACX,YAAY,EAAE;AAAA,MACd,QAAQ,EAAE;AAAA,IACZ,EAAE;AACJ,WAAO;AAAA,MACL,YAAY,MAAM;AAAA,MAClB,YAAY;AAAA,MACZ,QAAQ,iCAAiC,cAAc,cAAc,MAAM,IAAI;AAAA,MAC/E,cAAAA;AAAA,IACF;AAAA,EACF;AAGA,QAAM,SAAS,QAAQ,IAAI,CAAC,SAAS;AAAA,IACnC;AAAA,IACA,cAAc,oBAAoB,cAAc,GAAG;AAAA,EACrD,EAAE;AAGF,SAAO,KAAK,CAAC,GAAG,MAAM;AACpB,QAAI,EAAE,iBAAiB,EAAE,aAAc,QAAO,EAAE,eAAe,EAAE;AACjE,WAAO,EAAE,IAAI,WAAW,EAAE,IAAI;AAAA,EAChC,CAAC;AAED,QAAM,OAAO,OAAO,CAAC;AACrB,QAAM,WAAW,OAAO,CAAC;AAGzB,QAAM,aACJ,KAAK,eAAe,MAAM,CAAC,YAAY,KAAK,eAAe,SAAS,gBAChE,MACA;AAEN,QAAM,eAAe,SAAS,WAC3B,OAAO,CAAC,MAAM,EAAE,OAAO,KAAK,IAAI,EAAE,EAClC,IAAI,CAAC,OAAO;AAAA,IACX,YAAY,EAAE;AAAA,IACd,QAAQ,EAAE;AAAA,EACZ,EAAE;AAEJ,QAAM,SACJ,KAAK,eAAe,IAChB,qBAAqB,KAAK,IAAI,IAAI,wCAAwC,KAAK,IAAI,QAAQ,MAC3F,wBAAwB,KAAK,IAAI,IAAI,iCAAiC,KAAK,IAAI,QAAQ;AAE7F,SAAO;AAAA,IACL,YAAY,KAAK,IAAI;AAAA,IACrB;AAAA,IACA;AAAA,IACA;AAAA,EACF;AACF;AAMA,SAAS,oBAAoB,cAAsB,KAA+B;AAChF,MAAI,QAAQ;AACZ,QAAM,WAAW,CAAC,GAAG,IAAI,aAAa,IAAI,WAAW,EAClD,KAAK,GAAG,EACR,YAAY;AAGf,QAAM,WAAW,SACd,MAAM,YAAY,EAClB,OAAO,CAAC,MAAM,EAAE,UAAU,CAAC;AAE9B,aAAW,MAAM,UAAU;AACzB,QAAI,aAAa,SAAS,EAAE,GAAG;AAC7B,eAAS;AAAA,IACX;AAAA,EACF;AACA,SAAO;AACT;","names":["alternatives"]}

package/dist/{chunk-HLBYLYRD.js → chunk-PAORGQRI.js}

@@ -1,18 +1,79 @@
 import {
   validateRouteTarget
-} from "./chunk-HLXVTBF3.js";
+} from "./chunk-QNJMBKFK.js";
 import {
   log
-} from "./chunk-KWBU5S5U.js";
+} from "./chunk-2ODBA7MQ.js";
+
+// src/utils/iso-timestamp.ts
+var ISO_UTC_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
+var ISO_OFFSET_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/;
+function validateDateComponents(isoString) {
+  const match = isoString.match(
+    /^(\d{4})-(\d{2})-(\d{2})T(\d{2}):(\d{2}):(\d{2})/
+  );
+  if (!match) return false;
+  const [, yStr, mStr, dStr, hStr, minStr, sStr] = match;
+  const y = Number(yStr);
+  const m = Number(mStr);
+  const d = Number(dStr);
+  const h = Number(hStr);
+  const min = Number(minStr);
+  const s = Number(sStr);
+  if (m < 1 || m > 12) return false;
+  if (d < 1 || d > 31) return false;
+  if (h > 23 || min > 59 || s > 59) return false;
+  const daysInMonth = new Date(y, m, 0).getDate();
+  if (d > daysInMonth) return false;
+  return true;
+}
+function validateOffset(isoString) {
+  const offsetMatch = isoString.match(/([+-])(\d{2}):(\d{2})$/);
+  if (!offsetMatch) return true;
+  const oh = Number(offsetMatch[2]);
+  const om = Number(offsetMatch[3]);
+  if (oh > 14 || om > 59) return false;
+  if (oh === 14 && om > 0) return false;
+  return true;
+}
+function normalizeUtcForComparison(value) {
+  const fracMatch = value.match(/\.(\d+)Z$/);
+  if (fracMatch) {
+    const ms = (fracMatch[1] + "000").slice(0, 3);
+    return value.replace(/\.\d+Z$/, `.${ms}Z`);
+  }
+  return value.replace(/Z$/, ".000Z");
+}
+function parseIsoUtcTimestamp(value) {
+  if (typeof value !== "string" || !ISO_UTC_TIMESTAMP_RE.test(value)) {
+    return null;
+  }
+  const ts = Date.parse(value);
+  if (!Number.isFinite(ts)) return null;
+  if (!validateDateComponents(value)) return null;
+  const roundTrip = new Date(ts).toISOString();
+  if (roundTrip !== normalizeUtcForComparison(value)) return null;
+  return ts;
+}
+function parseIsoOffsetTimestamp(value) {
+  if (typeof value !== "string" || !ISO_OFFSET_TIMESTAMP_RE.test(value)) {
+    return null;
+  }
+  const ts = Date.parse(value);
+  if (!Number.isFinite(ts)) return null;
+  if (!validateDateComponents(value)) return null;
+  if (!validateOffset(value)) return null;
+  if (value.endsWith("Z")) {
+    const roundTrip = new Date(ts).toISOString();
+    if (roundTrip !== normalizeUtcForComparison(value)) return null;
+  }
+  return ts;
+}
 
 // src/replay/types.ts
 var VALID_SOURCES = /* @__PURE__ */ new Set(["openclaw", "claude", "chatgpt"]);
 var VALID_ROLES = /* @__PURE__ */ new Set(["user", "assistant"]);
-var ISO_UTC_TIMESTAMP_RE = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{3})?Z$/;
 var REPLAY_UNKNOWN_SESSION_KEY = "replay:unknown";
-function normalizeIsoForComparison(value) {
-  return value.includes(".") ? value : value.replace("Z", ".000Z");
-}
 function isReplaySource(value) {
   return typeof value === "string" && VALID_SOURCES.has(value);
 }
@@ -25,12 +86,7 @@ function normalizeReplaySessionKey(value) {
   return trimmed.length > 0 ? trimmed : REPLAY_UNKNOWN_SESSION_KEY;
 }
 function parseIsoTimestamp(value) {
-  if (typeof value !== "string" || !ISO_UTC_TIMESTAMP_RE.test(value)) return null;
-  const ts = Date.parse(value);
-  if (!Number.isFinite(ts)) return null;
-  const roundTrip = new Date(ts).toISOString();
-  if (roundTrip !== normalizeIsoForComparison(value)) return null;
-  return ts;
+  return parseIsoUtcTimestamp(value);
 }
 function validateReplayTurn(turn, index) {
   const issues = [];
@@ -336,6 +392,7 @@ var RoutingRulesStore = class {
 };
 
 export {
+  parseIsoOffsetTimestamp,
   isReplaySource,
   isReplayRole,
   normalizeReplaySessionKey,
@@ -343,4 +400,4 @@ export {
   validateReplayTurn,
   RoutingRulesStore
 };
-//# sourceMappingURL=chunk-HLBYLYRD.js.map
+//# sourceMappingURL=chunk-PAORGQRI.js.map

package/dist/chunk-PAORGQRI.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/utils/iso-timestamp.ts","../src/replay/types.ts","../src/routing/store.ts"],"sourcesContent":["// ---------------------------------------------------------------------------\n// Shared ISO-8601 / RFC 3339 timestamp validation helpers.\n//\n// Two public entry points — a strict UTC-only parser used by the replay\n// pipeline, and a more permissive parser used by bulk-import adapters that\n// need to preserve source timezone offsets. Both share date-component,\n// offset-range, and round-trip validation so they cannot silently diverge.\n// ---------------------------------------------------------------------------\n\n// UTC-only: `...Z`, 0 or 3 fractional digits (replay canonical form).\nconst ISO_UTC_TIMESTAMP_RE =\n  /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{3})?Z$/;\n\n// Lenient: variable-precision fractional seconds and `Z` or `[+-]HH:MM` offset.\nconst ISO_OFFSET_TIMESTAMP_RE =\n  /^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d+)?(?:Z|[+-]\\d{2}:\\d{2})$/;\n\n/**\n * Validate the date/time components of an ISO timestamp string.\n * Catches overflowed dates like Feb 31 that `Date.parse` silently normalizes.\n */\nfunction validateDateComponents(isoString: string): boolean {\n  const match = isoString.match(\n    /^(\\d{4})-(\\d{2})-(\\d{2})T(\\d{2}):(\\d{2}):(\\d{2})/,\n  );\n  if (!match) return false;\n  const [, yStr, mStr, dStr, hStr, minStr, sStr] = match;\n  const y = Number(yStr);\n  const m = Number(mStr);\n  const d = Number(dStr);\n  const h = Number(hStr);\n  const min = Number(minStr);\n  const s = Number(sStr);\n  if (m < 1 || m > 12) return false;\n  if (d < 1 || d > 31) return false;\n  if (h > 23 || min > 59 || s > 59) return false;\n  // Validate day for the specific month (using Date(y, m, 0) to get days).\n  const daysInMonth = new Date(y, m, 0).getDate();\n  if (d > daysInMonth) return false;\n  return true;\n}\n\n/**\n * Validate the timezone offset range if present.\n * Max offset is +/-14:00 per ISO 8601; minute part must be 0-59.\n */\nfunction validateOffset(isoString: string): boolean {\n  const offsetMatch = isoString.match(/([+-])(\\d{2}):(\\d{2})$/);\n  if (!offsetMatch) return true; // `Z` form, no offset to validate.\n  const oh = Number(offsetMatch[2]);\n  const om = Number(offsetMatch[3]);\n  if (oh > 14 || om > 59) return false;\n  // +14:00 is max; offsets like +14:30 are invalid.\n  if (oh === 14 && om > 0) return false;\n  return true;\n}\n\n/**\n * Normalize a `Z`-suffixed ISO timestamp to exactly three fractional digits so\n * the round-trip comparison against `Date.prototype.toISOString()` succeeds\n * regardless of input precision (or absence of a fractional part).\n */\nfunction normalizeUtcForComparison(value: string): string {\n  const fracMatch = value.match(/\\.(\\d+)Z$/);\n  if (fracMatch) {\n    const ms = (fracMatch[1] + \"000\").slice(0, 3);\n    return value.replace(/\\.\\d+Z$/, `.${ms}Z`);\n  }\n  return value.replace(/Z$/, \".000Z\");\n}\n\n/**\n * Strict UTC-only parser — accepts `YYYY-MM-DDTHH:MM:SS[.sss]Z`.\n * Returns milliseconds since epoch, or `null` if invalid.\n */\nexport function parseIsoUtcTimestamp(value: string): number | null {\n  if (typeof value !== \"string\" || !ISO_UTC_TIMESTAMP_RE.test(value)) {\n    return null;\n  }\n  const ts = Date.parse(value);\n  if (!Number.isFinite(ts)) return null;\n  if (!validateDateComponents(value)) return null;\n  const roundTrip = new Date(ts).toISOString();\n  if (roundTrip !== normalizeUtcForComparison(value)) return null;\n  return ts;\n}\n\n/**\n * Lenient parser — accepts variable-precision fractional seconds and either\n * a `Z` suffix or a `[+-]HH:MM` offset. Returns milliseconds since epoch, or\n * `null` if the string is not a well-formed RFC 3339 timestamp.\n */\nexport function parseIsoOffsetTimestamp(value: string): number | null {\n  if (typeof value !== \"string\" || !ISO_OFFSET_TIMESTAMP_RE.test(value)) {\n    return null;\n  }\n  const ts = Date.parse(value);\n  if (!Number.isFinite(ts)) return null;\n  if (!validateDateComponents(value)) return null;\n  if (!validateOffset(value)) return null;\n  // For UTC timestamps (ending in `Z`), verify with a round-trip so that\n  // overflowed UTC calendar dates cannot slip through.\n  if (value.endsWith(\"Z\")) {\n    const roundTrip = new Date(ts).toISOString();\n    if (roundTrip !== normalizeUtcForComparison(value)) return null;\n  }\n  return ts;\n}\n","import { parseIsoUtcTimestamp } from \"../utils/iso-timestamp.js\";\n\nexport type ReplaySource = \"openclaw\" | \"claude\" | \"chatgpt\";\nexport type ReplayRole = \"user\" | \"assistant\";\n\nexport interface ReplayTurn {\n  source: ReplaySource;\n  sessionKey: string;\n  role: ReplayRole;\n  content: string;\n  timestamp: string;\n  externalId?: string;\n  metadata?: Record<string, unknown>;\n}\n\nexport interface ReplayWarning {\n  code: string;\n  message: string;\n  index?: number;\n}\n\nexport interface ReplayValidationIssue {\n  code: string;\n  message: string;\n  index?: number;\n}\n\nexport interface ReplayParseOptions {\n  from?: string;\n  to?: string;\n  defaultSessionKey?: string;\n  strict?: boolean;\n}\n\nexport interface ReplayParseResult {\n  turns: ReplayTurn[];\n  warnings: ReplayWarning[];\n}\n\nexport interface ReplayNormalizer {\n  source: ReplaySource;\n  parse(input: unknown, options?: ReplayParseOptions): Promise<ReplayParseResult> | ReplayParseResult;\n}\n\nconst VALID_SOURCES: ReadonlySet<string> = new Set([\"openclaw\", \"claude\", \"chatgpt\"]);\nconst VALID_ROLES: ReadonlySet<string> = new Set([\"user\", \"assistant\"]);\nexport const REPLAY_UNKNOWN_SESSION_KEY = \"replay:unknown\";\n\nexport function isReplaySource(value: unknown): value is ReplaySource {\n  return typeof value === \"string\" && VALID_SOURCES.has(value);\n}\n\nexport function isReplayRole(value: unknown): value is ReplayRole {\n  return typeof value === \"string\" && VALID_ROLES.has(value);\n}\n\nexport function normalizeReplaySessionKey(value: unknown): string {\n  if (typeof value !== \"string\") return REPLAY_UNKNOWN_SESSION_KEY;\n  const trimmed = value.trim();\n  return trimmed.length > 0 ? trimmed : REPLAY_UNKNOWN_SESSION_KEY;\n}\n\n/**\n * Strict UTC-only ISO-8601 parser used by the replay pipeline.\n *\n * Delegates to the shared parser in `utils/iso-timestamp.ts` — do not\n * reimplement locally; extend that helper instead. Replay intentionally\n * rejects timezone-offset timestamps to keep canonical form consistent\n * across recorded transcripts.\n */\nexport function parseIsoTimestamp(value: string): number | null {\n  return parseIsoUtcTimestamp(value);\n}\n\nexport function validateReplayTurn(turn: ReplayTurn, index?: number): ReplayValidationIssue[] {\n  const issues: ReplayValidationIssue[] = [];\n  if (!turn || typeof turn !== \"object\") {\n    issues.push({\n      code: \"turn.invalid\",\n      message: \"Replay turn must be an object.\",\n      index,\n    });\n    return issues;\n  }\n\n  if (!isReplayRole(turn.role)) {\n    issues.push({\n      code: \"turn.role.invalid\",\n      message: `Replay role must be 'user' or 'assistant', received '${String(turn.role)}'.`,\n      index,\n    });\n  }\n\n  if (!isReplaySource(turn.source)) {\n    issues.push({\n      code: \"turn.source.invalid\",\n      message: `Replay source must be 'openclaw', 'claude', or 'chatgpt', received '${String(turn.source)}'.`,\n      index,\n    });\n  }\n\n  if (!turn.sessionKey || typeof turn.sessionKey !== \"string\" || turn.sessionKey.trim().length === 0) {\n    issues.push({\n      code: \"turn.sessionKey.invalid\",\n      message: \"Replay sessionKey is required.\",\n      index,\n    });\n  }\n\n  if (!turn.content || typeof turn.content !== \"string\" || turn.content.trim().length === 0) {\n    issues.push({\n      code: \"turn.content.invalid\",\n      message: \"Replay content must be a non-empty string.\",\n      index,\n    });\n  }\n\n  if (!turn.timestamp || typeof turn.timestamp !== \"string\" || parseIsoTimestamp(turn.timestamp) === null) {\n    issues.push({\n      code: \"turn.timestamp.invalid\",\n      message: `Replay timestamp must be a valid ISO timestamp, received '${String(turn.timestamp)}'.`,\n      index,\n    });\n  }\n\n  return issues;\n}\n","import { lstat, mkdir, readFile, realpath, rename, rm, stat, writeFile } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { createHash } from \"node:crypto\";\nimport { log } from \"../logger.js\";\nimport { validateRouteTarget, type RouteRule, type RoutingEngineOptions } from \"./engine.js\";\n\ntype RoutingRulesState = {\n  version: 1;\n  updatedAt: string;\n  rules: RouteRule[];\n};\n\nfunction defaultState(): RoutingRulesState {\n  return {\n    version: 1,\n    updatedAt: new Date(0).toISOString(),\n    rules: [],\n  };\n}\n\nfunction stableRuleId(rule: Pick<RouteRule, \"patternType\" | \"pattern\" | \"priority\" | \"target\">): string {\n  const seed = JSON.stringify({\n    patternType: rule.patternType,\n    pattern: rule.pattern.trim(),\n    priority: rule.priority,\n    target: rule.target,\n  });\n  return `route-${createHash(\"sha256\").update(seed).digest(\"hex\").slice(0, 12)}`;\n}\n\nfunction resolveStatePath(memoryDir: string, stateFile: string): string {\n  const root = path.resolve(memoryDir);\n  const defaultPath = path.join(root, \"state\", \"routing-rules.json\");\n  if (path.isAbsolute(stateFile)) {\n    const absolute = path.resolve(stateFile);\n    return absolute.startsWith(root + path.sep) ? absolute : defaultPath;\n  }\n  const resolved = path.resolve(root, stateFile);\n  return resolved.startsWith(root + path.sep) ? resolved : defaultPath;\n}\n\nfunction normalizeRule(rule: RouteRule, options?: RoutingEngineOptions): RouteRule | null {\n  if (!rule || typeof rule !== \"object\") return null;\n  if (rule.enabled === false) return null;\n  if (rule.patternType !== \"keyword\" && rule.patternType !== \"regex\") return null;\n  if (typeof rule.pattern !== \"string\" || rule.pattern.trim().length === 0) return null;\n  if (typeof rule.priority !== \"number\" || !Number.isFinite(rule.priority)) return null;\n\n  const targetValidation = validateRouteTarget(rule.target, options);\n  if (!targetValidation.ok || !targetValidation.target) return null;\n\n  const normalizedPriority = Math.trunc(rule.priority);\n  const normalizedTarget = targetValidation.target;\n  const id = typeof rule.id === \"string\" && rule.id.trim().length > 0\n    ? rule.id.trim()\n    : stableRuleId({\n      patternType: rule.patternType,\n      pattern: rule.pattern.trim(),\n      priority: normalizedPriority,\n      target: normalizedTarget,\n    });\n  return {\n    id,\n    patternType: rule.patternType,\n    pattern: rule.pattern.trim(),\n    priority: normalizedPriority,\n    target: normalizedTarget,\n    enabled: true,\n  };\n}\n\nexport class RoutingRulesStore {\n  private readonly memoryRoot: string;\n  private readonly statePath: string;\n  private readonly lockPath: string;\n  private writeQueue: Promise<void> = Promise.resolve();\n\n  constructor(memoryDir: string, stateFile = \"state/routing-rules.json\") {\n    this.memoryRoot = path.resolve(memoryDir);\n    this.statePath = resolveStatePath(memoryDir, stateFile);\n    this.lockPath = `${this.statePath}.lock`;\n  }\n\n  async read(options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    try {\n      const persisted = await this.readPersistedRules();\n      return persisted\n        .map((rule) => normalizeRule(rule, options))\n        .filter((rule): rule is RouteRule => rule !== null);\n    } catch {\n      return [];\n    }\n  }\n\n  async write(rules: RouteRule[], options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => this.writeNormalized(rules, options));\n  }\n\n  async upsert(rule: RouteRule, options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => {\n      const existing = await this.readPersistedRules();\n      const normalized = normalizeRule(rule, options);\n      if (!normalized) return existing;\n\n      const next = existing.filter((entry) => entry.id !== normalized.id);\n      next.push(normalized);\n      return this.writeNormalized(next);\n    });\n  }\n\n  async removeByPattern(pattern: string): Promise<RouteRule[]> {\n    return this.withWriteLock(async () => {\n      const trimmed = pattern.trim();\n      const existing = await this.readPersistedRules();\n      const next = existing.filter((entry) => entry.pattern !== trimmed);\n      if (next.length === existing.length) return existing;\n      return this.writeNormalized(next);\n    });\n  }\n\n  async reset(): Promise<void> {\n    await this.withWriteLock(async () => {\n      const payload = defaultState();\n      await this.assertStatePathScoped();\n      await writeFile(this.statePath, JSON.stringify(payload, null, 2), \"utf-8\");\n    });\n  }\n\n  private dedupeById(rules: RouteRule[]): RouteRule[] {\n    const byId = new Map<string, RouteRule>();\n    for (const rule of rules) {\n      byId.set(rule.id, rule);\n    }\n    return Array.from(byId.values());\n  }\n\n  private async readPersistedRules(): Promise<RouteRule[]> {\n    try {\n      await this.assertStatePathScoped();\n      const raw = await readFile(this.statePath, \"utf-8\");\n      const parsed = JSON.parse(raw) as Partial<RoutingRulesState>;\n      if (!parsed || typeof parsed !== \"object\" || !Array.isArray(parsed.rules)) return [];\n      const normalized = parsed.rules\n        .map((rule) => normalizeRule(rule))\n        .filter((rule): rule is RouteRule => rule !== null);\n      return this.dedupeById(normalized);\n    } catch {\n      return [];\n    }\n  }\n\n  private async writeNormalized(rules: RouteRule[], options?: RoutingEngineOptions): Promise<RouteRule[]> {\n    const normalized = this.dedupeById(\n      rules\n        .map((rule) => normalizeRule(rule, options))\n        .filter((rule): rule is RouteRule => rule !== null),\n    );\n\n    const payload: RoutingRulesState = {\n      version: 1,\n      updatedAt: new Date().toISOString(),\n      rules: normalized,\n    };\n\n    const tmpPath = `${this.statePath}.tmp-${process.pid}-${Date.now()}`;\n    try {\n      await this.assertStatePathScoped();\n      await writeFile(tmpPath, JSON.stringify(payload, null, 2), \"utf-8\");\n      await rename(tmpPath, this.statePath);\n    } catch (err) {\n      log.debug(`routing rules write failed: ${err}`);\n      throw err;\n    } finally {\n      await rm(tmpPath, { force: true }).catch(() => {});\n    }\n\n    return normalized;\n  }\n\n  private async withWriteLock<T>(op: () => Promise<T>): Promise<T> {\n    const previous = this.writeQueue;\n    let release: () => void = () => {};\n    this.writeQueue = new Promise<void>((resolve) => {\n      release = resolve;\n    });\n    await previous;\n    let unlock: (() => Promise<void>) | null = null;\n    try {\n      unlock = await this.acquireFileLock();\n      return await op();\n    } finally {\n      if (unlock) await unlock();\n      release();\n    }\n  }\n\n  private async acquireFileLock(): Promise<() => Promise<void>> {\n    const start = Date.now();\n    const staleMs = 30_000;\n    const timeoutMs = 5_000;\n    let unexpectedLockError: unknown = null;\n    await this.assertStatePathScoped();\n    await mkdir(path.dirname(this.lockPath), { recursive: true });\n\n    while (Date.now() - start < timeoutMs) {\n      try {\n        await mkdir(this.lockPath);\n        return async () => {\n          try {\n            await rm(this.lockPath, { recursive: true, force: true });\n          } catch {\n            // Fail-open: lock cleanup should not fail writes.\n          }\n        };\n      } catch (err) {\n        const code = (err as NodeJS.ErrnoException).code;\n        if (code !== \"EEXIST\") {\n          unexpectedLockError = err;\n          break;\n        }\n        try {\n          const lockStat = await stat(this.lockPath);\n          if (Date.now() - lockStat.mtimeMs > staleMs) {\n            await rm(this.lockPath, { recursive: true, force: true });\n            continue;\n          }\n        } catch {\n          // Lock may have been released between stat/rm attempts.\n        }\n        await new Promise((resolve) => setTimeout(resolve, 25));\n      }\n    }\n\n    if (unexpectedLockError) {\n      throw unexpectedLockError;\n    }\n    throw new Error(`routing rules lock acquisition timed out after ${timeoutMs}ms`);\n  }\n\n  private async assertStatePathScoped(): Promise<void> {\n    await mkdir(this.memoryRoot, { recursive: true });\n    const canonicalRoot = await realpath(this.memoryRoot);\n    const canonicalParent = await this.canonicalizePathWithoutCreating(path.dirname(this.statePath));\n    const canonicalStatePath = path.join(canonicalParent, path.basename(this.statePath));\n    if (!this.isPathInside(canonicalRoot, canonicalStatePath)) {\n      throw new Error(`routing rules state path escaped memoryDir: ${canonicalStatePath}`);\n    }\n    await mkdir(path.dirname(this.statePath), { recursive: true });\n    try {\n      const stateStats = await lstat(this.statePath);\n      if (stateStats.isSymbolicLink()) {\n        const canonicalFile = await realpath(this.statePath);\n        if (!this.isPathInside(canonicalRoot, canonicalFile)) {\n          throw new Error(`routing rules state symlink escaped memoryDir: ${canonicalFile}`);\n        }\n      }\n    } catch (err) {\n      const code = (err as NodeJS.ErrnoException).code;\n      if (code !== \"ENOENT\") {\n        throw err;\n      }\n    }\n  }\n\n  private isPathInside(root: string, candidate: string): boolean {\n    const normalizedRoot = path.resolve(root);\n    const normalizedCandidate = path.resolve(candidate);\n    if (normalizedCandidate === normalizedRoot) return true;\n    if (normalizedRoot === path.parse(normalizedRoot).root) {\n      return normalizedCandidate.startsWith(normalizedRoot);\n    }\n    return normalizedCandidate.startsWith(`${normalizedRoot}${path.sep}`);\n  }\n\n  private async canonicalizePathWithoutCreating(targetPath: string): Promise<string> {\n    const absoluteTarget = path.resolve(targetPath);\n    let probe = absoluteTarget;\n    while (true) {\n      try {\n        const canonicalProbe = await realpath(probe);\n        const remainder = path.relative(probe, absoluteTarget);\n        return path.resolve(canonicalProbe, remainder);\n      } catch (err) {\n        const code = (err as NodeJS.ErrnoException).code;\n        if (code !== \"ENOENT\") {\n          throw err;\n        }\n        const parent = path.dirname(probe);\n        if (parent === probe) {\n          return absoluteTarget;\n        }\n        probe = parent;\n      }\n    }\n  }\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-PVGDJXVK.js

@@ -0,0 +1,21 @@
+// src/abort-error.ts
+function abortError(message) {
+  const err = new Error(message);
+  Object.defineProperty(err, "name", { value: "AbortError" });
+  return err;
+}
+function isAbortError(err) {
+  return err instanceof Error && err.name === "AbortError";
+}
+function throwIfAborted(signal, message = "operation aborted") {
+  if (signal?.aborted) {
+    throw abortError(message);
+  }
+}
+
+export {
+  abortError,
+  isAbortError,
+  throwIfAborted
+};
+//# sourceMappingURL=chunk-PVGDJXVK.js.map

package/dist/chunk-PVGDJXVK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/abort-error.ts"],"sourcesContent":["/**\n * Shared abort-error helpers.\n *\n * Consolidates the `throwIfAborted` / `abortError` / `isAbortError`\n * patterns that were independently implemented across\n * `direct-answer-wiring.ts`, `harmonic-retrieval.ts`, and `qmd.ts`\n * (plus a private pair in `orchestrator.ts`).  A single helper\n * means future changes to the abort-error convention are applied\n * consistently across the codebase.\n *\n * The convention (matching Web / Node): throw a standard `Error`\n * with `name === \"AbortError\"`.  Callers dispatch on name rather\n * than a specific class so error propagation across async\n * boundaries continues to classify correctly.\n */\n\n/**\n * Build an Error whose `name` is `\"AbortError\"`.  Uses\n * `Object.defineProperty` so the name is non-enumerable and\n * mirrors the shape of `DOMException(\"AbortError\")` where that\n * is available.\n */\nexport function abortError(message: string): Error {\n  const err = new Error(message);\n  Object.defineProperty(err, \"name\", { value: \"AbortError\" });\n  return err;\n}\n\n/** Return true iff `err` is an Error whose `name` is `\"AbortError\"`. */\nexport function isAbortError(err: unknown): boolean {\n  return err instanceof Error && err.name === \"AbortError\";\n}\n\n/**\n * Throw an AbortError when the given signal has fired.  No-op\n * when the signal is absent or not yet aborted.  The default\n * message matches the prior in-module implementations.\n */\nexport function throwIfAborted(\n  signal?: AbortSignal,\n  message = \"operation aborted\",\n): void {\n  if (signal?.aborted) {\n    throw abortError(message);\n  }\n}\n"],"mappings":";AAsBO,SAAS,WAAW,SAAwB;AACjD,QAAM,MAAM,IAAI,MAAM,OAAO;AAC7B,SAAO,eAAe,KAAK,QAAQ,EAAE,OAAO,aAAa,CAAC;AAC1D,SAAO;AACT;AAGO,SAAS,aAAa,KAAuB;AAClD,SAAO,eAAe,SAAS,IAAI,SAAS;AAC9C;AAOO,SAAS,eACd,QACA,UAAU,qBACJ;AACN,MAAI,QAAQ,SAAS;AACnB,UAAM,WAAW,OAAO;AAAA,EAC1B;AACF;","names":[]}

package/dist/{chunk-OTAVQCSF.js → chunk-PYXS46O7.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-3QKK7QOS.js";
 import {
   clamp01
-} from "./chunk-QCCCQT3O.js";
+} from "./chunk-TBBDFYXW.js";
 
 // src/utility-learner.ts
 import path from "path";
@@ -265,4 +265,4 @@ export {
   learnUtilityPromotionWeights,
   getUtilityLearningStatus
 };
-//# sourceMappingURL=chunk-OTAVQCSF.js.map
+//# sourceMappingURL=chunk-PYXS46O7.js.map

package/dist/chunk-QDW3E4RD.js

@@ -0,0 +1,108 @@
+// src/procedural/procedure-types.ts
+function normalizeProcedureSteps(raw) {
+  if (!Array.isArray(raw)) return [];
+  const out = [];
+  for (let i = 0; i < raw.length; i++) {
+    const s = raw[i];
+    if (!s || typeof s !== "object") continue;
+    const o = s;
+    const intent = typeof o.intent === "string" ? o.intent.trim() : "";
+    if (!intent) continue;
+    const orderRaw = o.order;
+    const order = typeof orderRaw === "number" && Number.isFinite(orderRaw) ? Math.max(1, Math.floor(orderRaw)) : i + 1;
+    let toolCall;
+    const tc = o.toolCall;
+    if (tc && typeof tc === "object" && !Array.isArray(tc)) {
+      const t = tc;
+      const kind = typeof t.kind === "string" ? t.kind.trim() : "";
+      const signature = typeof t.signature === "string" ? t.signature.trim() : "";
+      if (kind && signature) {
+        toolCall = { kind, signature };
+      }
+    }
+    const expectedOutcome = typeof o.expectedOutcome === "string" && o.expectedOutcome.trim() ? o.expectedOutcome.trim() : void 0;
+    const optional = o.optional === true ? true : void 0;
+    out.push({ order, intent, toolCall, expectedOutcome, optional });
+  }
+  return out;
+}
+function buildProcedurePersistBody(title, procedureSteps) {
+  const head = typeof title === "string" ? title.trim() : "";
+  const steps = normalizeProcedureSteps(procedureSteps);
+  if (steps.length === 0) return head;
+  return `${head}
+
+${buildProcedureMarkdownBody(steps)}`.trimEnd() + "\n";
+}
+function buildProcedureMarkdownBody(steps) {
+  const sorted = [...steps].sort((a, b) => a.order - b.order);
+  const lines = [];
+  for (const step of sorted) {
+    const n = Number.isFinite(step.order) ? Math.max(1, Math.floor(step.order)) : 1;
+    lines.push(`## Step ${n}`);
+    lines.push("");
+    lines.push(step.intent.trim());
+    if (step.toolCall?.kind && step.toolCall.signature) {
+      lines.push("");
+      lines.push(`- Tool: \`${step.toolCall.kind}\` \u2014 ${step.toolCall.signature}`);
+    }
+    if (step.expectedOutcome?.trim()) {
+      lines.push("");
+      lines.push(`- Expected: ${step.expectedOutcome.trim()}`);
+    }
+    if (step.optional === true) {
+      lines.push("");
+      lines.push("- Optional: true");
+    }
+    lines.push("");
+  }
+  return lines.join("\n").trimEnd() + "\n";
+}
+var STEP_HEADER_RE = /^##\s+Step\s+(\d+)\s*$/im;
+function parseProcedureStepsFromBody(content) {
+  const text = content.replace(/\r\n/g, "\n").trim();
+  if (!text) return null;
+  const matches = [...text.matchAll(new RegExp(STEP_HEADER_RE.source, "gim"))];
+  if (matches.length === 0) return null;
+  const steps = [];
+  for (let i = 0; i < matches.length; i++) {
+    const m = matches[i];
+    const order = Number.parseInt(m[1] ?? "1", 10);
+    const start = (m.index ?? 0) + m[0].length;
+    const end = i + 1 < matches.length ? matches[i + 1].index ?? text.length : text.length;
+    const block = text.slice(start, end).trim();
+    const lines = block.split("\n").map((l) => l.trim());
+    const intentLines = lines.filter(
+      (l) => l.length > 0 && !l.startsWith("- Tool:") && !l.startsWith("- Expected:") && !l.startsWith("- Optional:")
+    );
+    const intent = intentLines.join(" ").trim() || "(unspecified)";
+    let toolCall;
+    const toolLine = lines.find((l) => l.startsWith("- Tool:"));
+    if (toolLine) {
+      const inner = toolLine.replace(/^- Tool:\s*/i, "").trim();
+      const tick = inner.match(/^`([^`]+)`\s*[—-]\s*(.+)$/);
+      if (tick) {
+        toolCall = { kind: tick[1].trim(), signature: tick[2].trim() };
+      }
+    }
+    const expectedLine = lines.find((l) => l.startsWith("- Expected:"));
+    const expectedOutcome = expectedLine?.replace(/^- Expected:\s*/i, "").trim();
+    const optional = /^- Optional:\s*true$/i.test(lines.find((l) => l.startsWith("- Optional:")) ?? "");
+    steps.push({
+      order: Number.isFinite(order) ? order : i + 1,
+      intent,
+      toolCall,
+      expectedOutcome: expectedOutcome?.length ? expectedOutcome : void 0,
+      optional: optional || void 0
+    });
+  }
+  return steps.length > 0 ? steps : null;
+}
+
+export {
+  normalizeProcedureSteps,
+  buildProcedurePersistBody,
+  buildProcedureMarkdownBody,
+  parseProcedureStepsFromBody
+};
+//# sourceMappingURL=chunk-QDW3E4RD.js.map

package/dist/chunk-QDW3E4RD.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/procedural/procedure-types.ts"],"sourcesContent":["/**\n * Procedural memory types (issue #519).\n * Bodies use ordered \"## Step N\" sections; machine fields live in frontmatter / structuredAttributes.\n */\n\nexport interface ProcedureStep {\n  order: number;\n  intent: string;\n  toolCall?: {\n    kind: string;\n    signature: string;\n  };\n  expectedOutcome?: string;\n  optional?: boolean;\n}\n\n/** Normalize loose extraction JSON into ProcedureStep records. */\nexport function normalizeProcedureSteps(raw: unknown): ProcedureStep[] {\n  if (!Array.isArray(raw)) return [];\n  const out: ProcedureStep[] = [];\n  for (let i = 0; i < raw.length; i++) {\n    const s = raw[i];\n    if (!s || typeof s !== \"object\") continue;\n    const o = s as Record<string, unknown>;\n    const intent = typeof o.intent === \"string\" ? o.intent.trim() : \"\";\n    if (!intent) continue;\n    const orderRaw = o.order;\n    const order =\n      typeof orderRaw === \"number\" && Number.isFinite(orderRaw)\n        ? Math.max(1, Math.floor(orderRaw))\n        : i + 1;\n    let toolCall: ProcedureStep[\"toolCall\"];\n    const tc = o.toolCall;\n    if (tc && typeof tc === \"object\" && !Array.isArray(tc)) {\n      const t = tc as Record<string, unknown>;\n      const kind = typeof t.kind === \"string\" ? t.kind.trim() : \"\";\n      const signature = typeof t.signature === \"string\" ? t.signature.trim() : \"\";\n      if (kind && signature) {\n        toolCall = { kind, signature };\n      }\n    }\n    const expectedOutcome =\n      typeof o.expectedOutcome === \"string\" && o.expectedOutcome.trim()\n        ? o.expectedOutcome.trim()\n        : undefined;\n    const optional = o.optional === true ? true : undefined;\n    out.push({ order, intent, toolCall, expectedOutcome, optional });\n  }\n  return out;\n}\n\n/** Title line plus serialized steps for storage.writeMemory body. */\nexport function buildProcedurePersistBody(title: string, procedureSteps: unknown): string {\n  const head = typeof title === \"string\" ? title.trim() : \"\";\n  const steps = normalizeProcedureSteps(procedureSteps);\n  if (steps.length === 0) return head;\n  return `${head}\\n\\n${buildProcedureMarkdownBody(steps)}`.trimEnd() + \"\\n\";\n}\n\n/** Serialize steps into markdown body (human-editable). */\nexport function buildProcedureMarkdownBody(steps: ProcedureStep[]): string {\n  const sorted = [...steps].sort((a, b) => a.order - b.order);\n  const lines: string[] = [];\n  for (const step of sorted) {\n    const n = Number.isFinite(step.order) ? Math.max(1, Math.floor(step.order)) : 1;\n    lines.push(`## Step ${n}`);\n    lines.push(\"\");\n    lines.push(step.intent.trim());\n    if (step.toolCall?.kind && step.toolCall.signature) {\n      lines.push(\"\");\n      lines.push(`- Tool: \\`${step.toolCall.kind}\\` — ${step.toolCall.signature}`);\n    }\n    if (step.expectedOutcome?.trim()) {\n      lines.push(\"\");\n      lines.push(`- Expected: ${step.expectedOutcome.trim()}`);\n    }\n    if (step.optional === true) {\n      lines.push(\"\");\n      lines.push(\"- Optional: true\");\n    }\n    lines.push(\"\");\n  }\n  return lines.join(\"\\n\").trimEnd() + \"\\n\";\n}\n\nconst STEP_HEADER_RE = /^##\\s+Step\\s+(\\d+)\\s*$/im;\n\n/**\n * Best-effort parse of \"## Step N\" blocks into ProcedureStep records.\n * Returns null when no step headers are found.\n */\nexport function parseProcedureStepsFromBody(content: string): ProcedureStep[] | null {\n  const text = content.replace(/\\r\\n/g, \"\\n\").trim();\n  if (!text) return null;\n  const matches = [...text.matchAll(new RegExp(STEP_HEADER_RE.source, \"gim\"))];\n  if (matches.length === 0) return null;\n\n  const steps: ProcedureStep[] = [];\n  for (let i = 0; i < matches.length; i++) {\n    const m = matches[i];\n    const order = Number.parseInt(m[1] ?? \"1\", 10);\n    const start = (m.index ?? 0) + m[0].length;\n    const end = i + 1 < matches.length ? (matches[i + 1].index ?? text.length) : text.length;\n    const block = text.slice(start, end).trim();\n    const lines = block.split(\"\\n\").map((l) => l.trim());\n    const intentLines = lines.filter(\n      (l) => l.length > 0 && !l.startsWith(\"- Tool:\") && !l.startsWith(\"- Expected:\") && !l.startsWith(\"- Optional:\"),\n    );\n    const intent = intentLines.join(\" \").trim() || \"(unspecified)\";\n    let toolCall: ProcedureStep[\"toolCall\"];\n    const toolLine = lines.find((l) => l.startsWith(\"- Tool:\"));\n    if (toolLine) {\n      const inner = toolLine.replace(/^- Tool:\\s*/i, \"\").trim();\n      const tick = inner.match(/^`([^`]+)`\\s*[—-]\\s*(.+)$/);\n      if (tick) {\n        toolCall = { kind: tick[1].trim(), signature: tick[2].trim() };\n      }\n    }\n    const expectedLine = lines.find((l) => l.startsWith(\"- Expected:\"));\n    const expectedOutcome = expectedLine?.replace(/^- Expected:\\s*/i, \"\").trim();\n    const optional = /^- Optional:\\s*true$/i.test(lines.find((l) => l.startsWith(\"- Optional:\")) ?? \"\");\n\n    steps.push({\n      order: Number.isFinite(order) ? order : i + 1,\n      intent,\n      toolCall,\n      expectedOutcome: expectedOutcome?.length ? expectedOutcome : undefined,\n      optional: optional || undefined,\n    });\n  }\n  return steps.length > 0 ? steps : null;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-YNCQ7E4M.js → chunk-QDYXG4CS.js}

@@ -1,6 +1,6 @@
 import {
   isSafeRouteNamespace
-} from "./chunk-HLXVTBF3.js";
+} from "./chunk-QNJMBKFK.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-M62O4P4T.js";
@@ -20,7 +20,8 @@ var INLINE_ALLOWED_CATEGORIES = /* @__PURE__ */ new Set([
   "commitment",
   "moment",
   "skill",
-  "rule"
+  "rule",
+  "procedure"
 ]);
 var SECRET_PATTERNS = [
   /\bsk-[A-Za-z0-9]{16,}\b/,
@@ -385,4 +386,4 @@ export {
   shouldSkipImplicitExtraction,
   shouldProcessInlineExplicitCapture
 };
-//# sourceMappingURL=chunk-YNCQ7E4M.js.map
+//# sourceMappingURL=chunk-QDYXG4CS.js.map

package/dist/chunk-QDYXG4CS.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/explicit-capture.ts"],"sourcesContent":["import { randomUUID } from \"node:crypto\";\nimport type { Orchestrator } from \"./orchestrator.js\";\nimport { isSafeRouteNamespace } from \"./routing/engine.js\";\nimport { sanitizeMemoryContent } from \"./sanitize.js\";\nimport { ContentHashIndex } from \"./storage.js\";\nimport type { CaptureMode, MemoryCategory, MemoryLifecycleEvent, PluginConfig } from \"./types.js\";\n\nexport type ExplicitCaptureInput = {\n  content: string;\n  category?: string;\n  confidence?: number;\n  namespace?: string;\n  tags?: string[];\n  entityRef?: string;\n  ttl?: string;\n  sourceReason?: string;\n};\n\nexport type ValidExplicitCapture = {\n  content: string;\n  category: MemoryCategory;\n  confidence: number;\n  namespace?: string;\n  tags: string[];\n  entityRef?: string;\n  expiresAt?: string;\n  sourceReason?: string;\n};\n\nexport type ExplicitCaptureSource = \"memory_store\" | \"memory_capture\" | \"suggestion_submit\" | \"inline\";\ntype ExplicitCaptureValidationMode = \"legacy_tool\" | \"strict_explicit\";\n\nconst INLINE_NOTE_RE = /<memory_note>\\s*([\\s\\S]*?)\\s*<\\/memory_note>/gi;\nconst INLINE_NOTE_MARKUP_RE = /<memory_note>\\s*[\\s\\S]*?\\s*<\\/memory_note>/i;\nconst INLINE_ALLOWED_CATEGORIES = new Set<MemoryCategory>([\n  \"fact\",\n  \"preference\",\n  \"correction\",\n  \"entity\",\n  \"decision\",\n  \"relationship\",\n  \"principle\",\n  \"commitment\",\n  \"moment\",\n  \"skill\",\n  \"rule\",\n  \"procedure\",\n]);\n\nconst SECRET_PATTERNS: RegExp[] = [\n  /\\bsk-[A-Za-z0-9]{16,}\\b/,\n  /\\bAKIA[0-9A-Z]{16}\\b/,\n  /\\bBearer\\s+[A-Za-z0-9._-]{16,}\\b/i,\n  /\\b(?:api[_-]?key|secret|token|password|passwd)\\s*[:=]\\s*[^\\s]{8,}\\b/i,\n  /\\b(?:authorization)\\s*:\\s*[^\\s]{8,}\\b/i,\n];\nconst SECRET_REDACTION_PATTERNS: Array<{ pattern: RegExp; replacement: string }> = [\n  { pattern: /\\bsk-[A-Za-z0-9]{16,}\\b/g, replacement: \"[redacted openai key]\" },\n  { pattern: /\\bAKIA[0-9A-Z]{16}\\b/g, replacement: \"[redacted aws key]\" },\n  { pattern: /\\bBearer\\s+[A-Za-z0-9._-]{16,}\\b/gi, replacement: \"Bearer [redacted token]\" },\n  {\n    pattern: /\\b(?:api[_-]?key|secret|token|password|passwd)\\s*[:=]\\s*[^\\s]{8,}\\b/gi,\n    replacement: \"[redacted credential]\",\n  },\n  {\n    pattern: /\\b(?:authorization)\\s*:\\s*[^\\s]{8,}\\b/gi,\n    replacement: \"authorization: [redacted credential]\",\n  },\n];\nconst EXPLICIT_CAPTURE_REVIEW_TAGS = [\"explicit-capture\", \"queued-review\"];\n\nfunction explicitCaptureActor(source: ExplicitCaptureSource): string {\n  switch (source) {\n    case \"inline\":\n      return \"inline.memory_note\";\n    case \"memory_store\":\n      return \"tool.memory_store\";\n    case \"suggestion_submit\":\n      return \"tool.suggestion_submit\";\n    default:\n      return \"tool.memory_capture\";\n  }\n}\n\nfunction asTrimmed(value: string | undefined): string | undefined {\n  const trimmed = value?.trim();\n  return trimmed && trimmed.length > 0 ? trimmed : undefined;\n}\n\nfunction normalizeCaptureContent(value: string): string {\n  return value\n    .toLowerCase()\n    .replace(/\\s+/g, \" \")\n    .trim();\n}\n\nfunction redactSecrets(value: string): string {\n  let redacted = value;\n  for (const { pattern, replacement } of SECRET_REDACTION_PATTERNS) {\n    redacted = redacted.replace(pattern, replacement);\n  }\n  return redacted;\n}\n\nfunction normalizeExplicitCaptureError(error: unknown): string {\n  if (error instanceof Error && error.message.trim().length > 0) return error.message.trim();\n  const rendered = String(error).trim();\n  return rendered.length > 0 ? rendered : \"explicit capture failed\";\n}\n\nfunction resolveExplicitCaptureReviewNamespace(\n  orchestrator: Orchestrator,\n  namespace: string | undefined,\n): string | undefined {\n  const normalized = asTrimmed(namespace);\n  if (!normalized) return undefined;\n  return resolveExplicitCaptureNamespace(orchestrator, normalized);\n}\n\nfunction resolveExplicitCaptureNamespace(\n  orchestrator: Orchestrator,\n  namespace: string | undefined,\n): string | undefined {\n  const normalized = asTrimmed(namespace);\n  if (!normalized) return undefined;\n  if (!orchestrator.config.namespacesEnabled) {\n    if (normalized !== orchestrator.config.defaultNamespace) {\n      throw new Error(`unsupported namespace: ${normalized}`);\n    }\n    return normalized;\n  }\n  const allowed = new Set([\n    orchestrator.config.defaultNamespace,\n    orchestrator.config.sharedNamespace,\n    ...orchestrator.config.namespacePolicies.map((policy) => policy.name),\n  ].map((value) => value.trim()).filter(Boolean));\n  if (!allowed.has(normalized)) {\n    throw new Error(`unsupported namespace: ${normalized}`);\n  }\n  return normalized;\n}\n\nfunction parseExplicitCaptureTtl(ttl: string | undefined): string | undefined {\n  const raw = asTrimmed(ttl);\n  if (!raw) return undefined;\n\n  const absoluteMs = Date.parse(raw);\n  if (Number.isFinite(absoluteMs)) {\n    return new Date(absoluteMs).toISOString();\n  }\n\n  const relative = raw.match(/^(\\d+)\\s*([mhdw])$/i);\n  if (!relative) {\n    throw new Error(\"ttl must be an ISO-8601 timestamp or relative duration like 30m, 12h, 7d, or 2w\");\n  }\n\n  const amount = Number.parseInt(relative[1] ?? \"\", 10);\n  const unit = (relative[2] ?? \"\").toLowerCase();\n  if (!Number.isFinite(amount) || amount <= 0) {\n    throw new Error(\"ttl duration must be a positive integer\");\n  }\n\n  const multiplier =\n    unit === \"m\" ? 60_000\n      : unit === \"h\" ? 60 * 60_000\n        : unit === \"d\" ? 24 * 60 * 60_000\n          : 7 * 24 * 60 * 60_000;\n  return new Date(Date.now() + amount * multiplier).toISOString();\n}\n\nfunction parseInlineNote(block: string): ExplicitCaptureInput | null {\n  const lines = block.replace(/\\r/g, \"\").split(\"\\n\");\n  const note: Partial<ExplicitCaptureInput> = {};\n  let idx = 0;\n\n  while (idx < lines.length) {\n    const rawLine = lines[idx] ?? \"\";\n    const line = rawLine.trim();\n    idx += 1;\n    if (line.length === 0) continue;\n    const colonIdx = line.indexOf(\":\");\n    if (colonIdx < 0) continue;\n    const key = line.slice(0, colonIdx).trim();\n    const value = line.slice(colonIdx + 1).trim();\n\n    if (key === \"content\" && value === \"|\") {\n      const contentLines: string[] = [];\n      while (idx < lines.length) {\n        const next = lines[idx] ?? \"\";\n        if (next.startsWith(\"  \") || next.startsWith(\"\\t\")) {\n          contentLines.push(next.replace(/^(  |\\t)/, \"\"));\n          idx += 1;\n          continue;\n        }\n        if (next.trim().length === 0) {\n          contentLines.push(\"\");\n          idx += 1;\n          continue;\n        }\n        break;\n      }\n      note.content = contentLines.join(\"\\n\").trim();\n      continue;\n    }\n\n    switch (key) {\n      case \"content\":\n        note.content = value;\n        break;\n      case \"category\":\n        note.category = value;\n        break;\n      case \"confidence\":\n        note.confidence = Number.parseFloat(value);\n        break;\n      case \"namespace\":\n        note.namespace = value;\n        break;\n      case \"tags\":\n        note.tags = value\n          .split(\",\")\n          .map((entry) => entry.trim())\n          .filter(Boolean);\n        break;\n      case \"entityRef\":\n        note.entityRef = value;\n        break;\n      case \"ttl\":\n        note.ttl = value;\n        break;\n      case \"sourceReason\":\n        note.sourceReason = value;\n        break;\n      default:\n        break;\n    }\n  }\n\n  return asTrimmed(note.content) ? (note as ExplicitCaptureInput) : null;\n}\n\nexport function parseInlineExplicitCaptureNotes(text: string): ExplicitCaptureInput[] {\n  const notes: ExplicitCaptureInput[] = [];\n  for (const match of text.matchAll(INLINE_NOTE_RE)) {\n    const parsed = parseInlineNote(match[1] ?? \"\");\n    if (parsed) notes.push(parsed);\n  }\n  return notes;\n}\n\nexport function hasInlineExplicitCaptureMarkup(text: string): boolean {\n  return INLINE_NOTE_MARKUP_RE.test(text);\n}\n\nexport function stripInlineExplicitCaptureNotes(text: string): string {\n  return text.replace(INLINE_NOTE_RE, \"\").trim();\n}\n\nexport function validateExplicitCaptureInput(\n  input: ExplicitCaptureInput,\n  mode: ExplicitCaptureValidationMode = \"strict_explicit\",\n): ValidExplicitCapture {\n  const content = asTrimmed(input.content);\n  if (!content) throw new Error(\"content is required\");\n  if (mode === \"strict_explicit\") {\n    if (content.length < 10) throw new Error(\"content must be at least 10 characters\");\n    if (content.length > 4000) throw new Error(\"content must be 4000 characters or fewer\");\n  }\n  if (/<memory_note>/i.test(content) || /<\\/memory_note>/i.test(content)) {\n    throw new Error(\"nested memory_note blocks are not allowed\");\n  }\n\n  const category = (asTrimmed(input.category) ?? \"fact\") as MemoryCategory;\n  if (!INLINE_ALLOWED_CATEGORIES.has(category)) {\n    throw new Error(`unsupported category: ${input.category ?? category}`);\n  }\n\n  const sanitized = sanitizeMemoryContent(content);\n  if (!sanitized.clean) {\n    throw new Error(\"content failed memory sanitization\");\n  }\n  for (const pattern of SECRET_PATTERNS) {\n    if (pattern.test(content)) {\n      throw new Error(\"content appears to contain a secret or credential\");\n    }\n  }\n\n  const confidence = Number.isFinite(input.confidence) ? Number(input.confidence) : 0.95;\n  if (confidence < 0 || confidence > 1) {\n    throw new Error(\"confidence must be between 0 and 1\");\n  }\n  const requestedNamespace = asTrimmed(input.namespace);\n  if (requestedNamespace && !isSafeRouteNamespace(requestedNamespace)) {\n    throw new Error(`unsafe namespace: ${requestedNamespace}`);\n  }\n  const expiresAt = parseExplicitCaptureTtl(input.ttl);\n\n  return {\n    content,\n    category,\n    confidence,\n    namespace: asTrimmed(input.namespace),\n    tags: Array.from(new Set((input.tags ?? []).map((tag) => tag.trim()).filter(Boolean))),\n    entityRef: asTrimmed(input.entityRef),\n    expiresAt,\n    sourceReason: asTrimmed(input.sourceReason),\n  };\n}\n\nasync function findDuplicateExplicitCapture(\n  orchestrator: Orchestrator,\n  resolvedNamespace: string | undefined,\n  candidate: ValidExplicitCapture,\n): Promise<string | null> {\n  const storage = await orchestrator.getStorage(resolvedNamespace);\n  if (\n    candidate.category === \"fact\"\n    && typeof (storage as { hasFactContentHash?: (content: string) => Promise<boolean> }).hasFactContentHash === \"function\"\n  ) {\n    try {\n      const hasHash = await (storage as { hasFactContentHash: (content: string) => Promise<boolean> }).hasFactContentHash(\n        candidate.content,\n      );\n      if (!hasHash) {\n        const authoritative =\n          typeof (storage as { isFactContentHashAuthoritative?: () => Promise<boolean> | boolean }).isFactContentHashAuthoritative\n            === \"function\"\n            ? await (storage as { isFactContentHashAuthoritative: () => Promise<boolean> | boolean })\n              .isFactContentHashAuthoritative()\n            : false;\n        if (authoritative) return null;\n      }\n    } catch (err) {\n      // Fail open: hash index is only an optimization, so fall back to the full corpus scan.\n      void err;\n    }\n  }\n  const existing = await storage.readAllMemories();\n  const normalizedCandidate = normalizeCaptureContent(candidate.content);\n  const match = existing.find((memory) => {\n    const status = memory.frontmatter.status ?? \"active\";\n    if (status !== \"active\") return false;\n    if (memory.frontmatter.category !== candidate.category) return false;\n    return normalizeCaptureContent(memory.content) === normalizedCandidate;\n  });\n  return match?.frontmatter.id ?? null;\n}\n\nexport async function persistExplicitCapture(\n  orchestrator: Orchestrator,\n  candidate: ValidExplicitCapture,\n  source: ExplicitCaptureSource,\n): Promise<{ id: string; duplicateOf?: string }> {\n  const resolvedNamespace = resolveExplicitCaptureNamespace(orchestrator, candidate.namespace);\n  const duplicateOf = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate);\n  if (duplicateOf) {\n    return { id: duplicateOf, duplicateOf };\n  }\n\n  const storage = await orchestrator.getStorage(resolvedNamespace);\n  const id = await storage.writeMemory(candidate.category, candidate.content, {\n    confidence: candidate.confidence,\n    tags: candidate.tags,\n    entityRef: candidate.entityRef,\n    expiresAt: candidate.expiresAt,\n    source: source === \"inline\" ? \"explicit-inline\" : \"explicit\",\n  });\n\n  const created = new Date().toISOString();\n  const event: MemoryLifecycleEvent = {\n    eventId: `mle-${randomUUID()}`,\n    memoryId: id,\n    eventType: \"explicit_capture_accepted\",\n    timestamp: created,\n    actor: explicitCaptureActor(source),\n    reasonCode: candidate.sourceReason,\n    ruleVersion: \"explicit-capture.v1\",\n  };\n  await storage.appendMemoryLifecycleEvents([event]);\n\n  return { id };\n}\n\nfunction buildExplicitCaptureReviewContent(input: ExplicitCaptureInput, reason: string): string {\n  const requestedContent = asTrimmed(input.content);\n  const sanitized = sanitizeMemoryContent(redactSecrets(requestedContent ?? \"[empty explicit capture]\"));\n  const safeContent = sanitized.text.trim().length > 0 ? sanitized.text.trim() : \"[empty explicit capture]\";\n  const lines = [\n    \"Explicit capture queued for review.\",\n    \"\",\n    `Reason: ${reason}`,\n    \"\",\n    \"Submitted content:\",\n    safeContent,\n  ];\n  const metadata = [\n    input.category ? `Requested category: ${input.category}` : undefined,\n    input.namespace ? `Requested namespace: ${input.namespace}` : undefined,\n    input.entityRef ? `Requested entityRef: ${input.entityRef}` : undefined,\n    input.ttl ? `Requested ttl: ${input.ttl}` : undefined,\n    input.sourceReason ? `Requested sourceReason: ${input.sourceReason}` : undefined,\n    input.tags && input.tags.length > 0 ? `Requested tags: ${input.tags.join(\", \")}` : undefined,\n  ].filter((entry): entry is string => typeof entry === \"string\" && entry.length > 0);\n  if (metadata.length > 0) {\n    lines.push(\"\", ...metadata);\n  }\n  return lines.join(\"\\n\");\n}\n\nasync function findQueuedExplicitCaptureDuplicate(\n  orchestrator: Orchestrator,\n  namespace: string | undefined,\n  content: string,\n): Promise<string | null> {\n  const storage = await orchestrator.getStorage(namespace);\n  const existing = await storage.readAllMemories();\n  const normalized = normalizeCaptureContent(content);\n  const match = existing.find((memory) => {\n    const status = memory.frontmatter.status ?? \"active\";\n    if (status !== \"pending_review\") return false;\n    if (!(memory.frontmatter.tags ?? []).includes(\"queued-review\")) return false;\n    return normalizeCaptureContent(memory.content) === normalized;\n  });\n  return match?.frontmatter.id ?? null;\n}\n\nexport async function queueExplicitCaptureForReview(\n  orchestrator: Orchestrator,\n  input: ExplicitCaptureInput,\n  source: ExplicitCaptureSource,\n  error: unknown,\n): Promise<{ id: string; duplicateOf?: string }> {\n  const reason = normalizeExplicitCaptureError(error);\n  const requestedNamespace = asTrimmed(input.namespace);\n  const queueNamespace = resolveExplicitCaptureReviewNamespace(orchestrator, requestedNamespace);\n  const content = buildExplicitCaptureReviewContent(input, reason);\n  const duplicateOf = await findQueuedExplicitCaptureDuplicate(orchestrator, queueNamespace, content);\n  if (duplicateOf) {\n    return { id: duplicateOf, duplicateOf };\n  }\n\n  const requestedCategory = asTrimmed(input.category);\n  const reviewCategory = requestedCategory && INLINE_ALLOWED_CATEGORIES.has(requestedCategory as MemoryCategory)\n    ? requestedCategory as MemoryCategory\n    : \"fact\";\n  const requestedTags = Array.isArray(input.tags)\n    ? input.tags.map((tag) => tag.trim()).filter(Boolean)\n    : [];\n  const storage = await orchestrator.getStorage(queueNamespace);\n  const id = await storage.writeMemory(reviewCategory, content, {\n    confidence: 0.2,\n    tags: Array.from(new Set([...EXPLICIT_CAPTURE_REVIEW_TAGS, ...requestedTags])),\n    entityRef: asTrimmed(input.entityRef),\n    source: source === \"inline\" ? \"explicit-inline-review\" : \"explicit-review\",\n  });\n  const created = await storage.getMemoryById(id);\n  if (created) {\n    await storage.writeMemoryFrontmatter(created, {\n      status: \"pending_review\",\n      updated: new Date().toISOString(),\n    }, {\n      actor: explicitCaptureActor(source),\n      reasonCode: reason,\n      ruleVersion: \"explicit-capture.v1\",\n    });\n  }\n  const event: MemoryLifecycleEvent = {\n    eventId: `mle-${randomUUID()}`,\n    memoryId: id,\n    eventType: \"explicit_capture_queued\",\n    timestamp: new Date().toISOString(),\n    actor: explicitCaptureActor(source),\n    reasonCode: reason,\n    ruleVersion: \"explicit-capture.v1\",\n  };\n  await storage.appendMemoryLifecycleEvents([event]);\n  return { id };\n}\n\nexport function shouldSkipImplicitExtraction(cfg: Pick<PluginConfig, \"captureMode\">): boolean {\n  return cfg.captureMode === \"explicit\";\n}\n\nexport function shouldProcessInlineExplicitCapture(cfg: Pick<PluginConfig, \"captureMode\">): boolean {\n  return cfg.captureMode !== \"implicit\";\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-HLXVTBF3.js → chunk-QNJMBKFK.js}

@@ -10,7 +10,8 @@ var DEFAULT_CATEGORIES = [
   "commitment",
   "moment",
   "skill",
-  "rule"
+  "rule",
+  "procedure"
 ];
 function normalizeNamespace(namespace) {
   return namespace.trim();
@@ -106,4 +107,4 @@ export {
   validateRouteTarget,
   selectRouteRule
 };
-//# sourceMappingURL=chunk-HLXVTBF3.js.map
+//# sourceMappingURL=chunk-QNJMBKFK.js.map

package/dist/chunk-QNJMBKFK.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/routing/engine.ts"],"sourcesContent":["import type { MemoryCategory } from \"../types.js\";\n\nexport type RoutePatternType = \"regex\" | \"keyword\";\n\nexport interface RouteTarget {\n  category?: MemoryCategory;\n  namespace?: string;\n}\n\nexport interface RouteRule {\n  id: string;\n  patternType: RoutePatternType;\n  pattern: string;\n  priority: number;\n  target: RouteTarget;\n  enabled?: boolean;\n}\n\nexport interface RoutingEngineOptions {\n  allowedNamespaces?: string[];\n  allowedCategories?: MemoryCategory[];\n}\n\nexport interface RouteSelection {\n  rule: RouteRule;\n  target: RouteTarget;\n}\n\nconst DEFAULT_CATEGORIES: readonly MemoryCategory[] = [\n  \"fact\",\n  \"preference\",\n  \"correction\",\n  \"entity\",\n  \"decision\",\n  \"relationship\",\n  \"principle\",\n  \"commitment\",\n  \"moment\",\n  \"skill\",\n  \"rule\",\n  \"procedure\",\n] as const;\n\nfunction normalizeNamespace(namespace: string): string {\n  return namespace.trim();\n}\n\nexport function isLikelyUnsafeRegex(pattern: string): boolean {\n  const value = pattern.trim();\n  if (value.length === 0) return true;\n  if (value.length > 120) return true;\n  if (/\\\\[1-9]/.test(value)) return true; // backreferences\n  if (/\\(\\?<?[=!]/.test(value)) return true; // lookaround assertions\n  if (/\\((?:[^()\\\\]|\\\\.)*[+*](?:[^()\\\\]|\\\\.)*\\)[+*{]/.test(value)) return true; // nested quantifiers\n  // Conservative fail-closed guardrail: grouped/alternation regexes are user-configurable and can be expensive.\n  if (/(^|[^\\\\])[()|]/.test(value)) return true;\n  // Multiple quantifiers in one user pattern are high risk for catastrophic backtracking on non-matches.\n  const quantifierCount =\n    (value.match(/(^|[^\\\\])[*+?]/g)?.length ?? 0) +\n    (value.match(/(^|[^\\\\])\\{/g)?.length ?? 0);\n  if (quantifierCount > 1) return true;\n  return false;\n}\n\nexport function isSafeRouteNamespace(namespace: string): boolean {\n  const value = normalizeNamespace(namespace);\n  if (value.length === 0) return false;\n  if (value === \".\") return false;\n  if (value.includes(\"/\") || value.includes(\"\\\\\")) return false;\n  if (value.includes(\"..\")) return false;\n  return /^[A-Za-z0-9._-]{1,64}$/.test(value);\n}\n\nexport function validateRouteTarget(target: RouteTarget | null | undefined, options?: RoutingEngineOptions): {\n  ok: boolean;\n  error?: string;\n  target?: RouteTarget;\n} {\n  if (!target || typeof target !== \"object\") {\n    return { ok: false, error: \"target must be an object\" };\n  }\n\n  const allowedCategories = new Set(options?.allowedCategories ?? DEFAULT_CATEGORIES);\n  const allowedNamespaces = options?.allowedNamespaces\n    ? new Set(options.allowedNamespaces.map((v) => v.trim()).filter((v) => v.length > 0))\n    : null;\n\n  const normalized: RouteTarget = {};\n\n  if (typeof target.category === \"string\") {\n    if (!allowedCategories.has(target.category)) {\n      return { ok: false, error: `invalid category: ${target.category}` };\n    }\n    normalized.category = target.category;\n  }\n\n  if (typeof target.namespace === \"string\") {\n    const namespace = normalizeNamespace(target.namespace);\n    if (!isSafeRouteNamespace(namespace)) {\n      return { ok: false, error: `invalid namespace: ${target.namespace}` };\n    }\n    if (allowedNamespaces && !allowedNamespaces.has(namespace)) {\n      return { ok: false, error: `namespace not allowed: ${namespace}` };\n    }\n    normalized.namespace = namespace;\n  }\n\n  if (!normalized.category && !normalized.namespace) {\n    return { ok: false, error: \"target must include category or namespace\" };\n  }\n\n  return { ok: true, target: normalized };\n}\n\nexport function doesRuleMatch(rule: RouteRule, text: string): boolean {\n  if (!rule || typeof rule !== \"object\") return false;\n  if (rule.enabled === false) return false;\n  if (typeof rule.pattern !== \"string\") return false;\n  const pattern = rule.pattern.trim();\n  if (pattern.length === 0) return false;\n\n  if (rule.patternType === \"keyword\") {\n    return text.toLowerCase().includes(pattern.toLowerCase());\n  }\n  if (rule.patternType !== \"regex\") {\n    return false;\n  }\n\n  if (isLikelyUnsafeRegex(pattern)) {\n    return false;\n  }\n\n  try {\n    return new RegExp(pattern, \"i\").test(text);\n  } catch {\n    return false;\n  }\n}\n\nexport function selectRouteRule(text: string, rules: RouteRule[], options?: RoutingEngineOptions): RouteSelection | null {\n  const ranked = rules\n    .map((rule, index) => ({ rule, index }))\n    .sort((a, b) => {\n      if (b.rule.priority !== a.rule.priority) return b.rule.priority - a.rule.priority;\n      return a.index - b.index;\n    });\n\n  for (const entry of ranked) {\n    if (!doesRuleMatch(entry.rule, text)) continue;\n\n    const validation = validateRouteTarget(entry.rule.target, options);\n    if (!validation.ok || !validation.target) continue;\n\n    return {\n      rule: entry.rule,\n      target: validation.target,\n    };\n  }\n\n  return null;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-4A24LIM2.js → chunk-S75M5ZRK.js}

@@ -2,7 +2,7 @@ import {
   clamp01,
   computeLifecycleValueInputs,
   daysSince
-} from "./chunk-QCCCQT3O.js";
+} from "./chunk-TBBDFYXW.js";
 
 // src/tier-routing.ts
 function computeTierValueScore(memory, now, signals) {
@@ -65,4 +65,4 @@ export {
   computeTierValueScore,
   decideTierTransition
 };
-//# sourceMappingURL=chunk-4A24LIM2.js.map
+//# sourceMappingURL=chunk-S75M5ZRK.js.map