@remnic/core 9.3.624 → 9.3.625

package/dist/{chunk-FH3PPO42.js → chunk-KVFYTRMV.js}

@@ -11,7 +11,7 @@ import {
 } from "./chunk-LMDRGRJ2.js";
 import {
   parseConfig
-} from "./chunk-5GOMXHLC.js";
+} from "./chunk-KKTXCFD7.js";
 import {
   resolveObjectiveStateStoreDir,
   validateObjectiveStateSnapshot
@@ -268,4 +268,4 @@ export {
   recordResumeBundle,
   getResumeBundleStatus
 };
-//# sourceMappingURL=chunk-FH3PPO42.js.map
+//# sourceMappingURL=chunk-KVFYTRMV.js.map

package/dist/{chunk-BNW5NJJH.js → chunk-LQYTQCXM.js}

@@ -4,7 +4,7 @@ import {
 import {
   compareEntityTimestamps,
   normalizeEntityName
-} from "./chunk-PJGB7XRR.js";
+} from "./chunk-UGHUNQ74.js";
 import {
   sanitizeMemoryContent
 } from "./chunk-FVQJYWH7.js";
@@ -677,4 +677,4 @@ export {
   entityIndexVersion,
   entityRecentTranscriptLookbackHours
 };
-//# sourceMappingURL=chunk-BNW5NJJH.js.map
+//# sourceMappingURL=chunk-LQYTQCXM.js.map

package/dist/{chunk-AYHXQR53.js → chunk-MVQN73GT.js}

@@ -4,7 +4,7 @@ import {
 import {
   ALL_CATEGORY_DIRS,
   NamespaceStorageRouter
-} from "./chunk-W3BKVM64.js";
+} from "./chunk-QDV6VAD4.js";
 import {
   namespaceIdentityFromToken,
   namespaceIdentityToken
@@ -202,4 +202,4 @@ export {
   verifyNamespaces,
   runNamespaceMigration
 };
-//# sourceMappingURL=chunk-AYHXQR53.js.map
+//# sourceMappingURL=chunk-MVQN73GT.js.map

package/dist/{chunk-ZZPIJPPD.js → chunk-N5RGXWLQ.js}

@@ -1,6 +1,6 @@
 import {
   StorageManager
-} from "./chunk-PJGB7XRR.js";
+} from "./chunk-UGHUNQ74.js";
 
 // src/semantic-rule-promotion.ts
 import { createHash, randomUUID } from "crypto";
@@ -529,4 +529,4 @@ export {
   setSemanticRulePromotionTestHooks,
   promoteSemanticRuleFromMemory
 };
-//# sourceMappingURL=chunk-ZZPIJPPD.js.map
+//# sourceMappingURL=chunk-N5RGXWLQ.js.map

package/dist/chunk-NDAH7BJ5.js

@@ -0,0 +1,213 @@
+// src/wearables/corrections.ts
+import { promises as fsPromises } from "fs";
+import * as path from "path";
+var MAX_PATTERN_LENGTH = 256;
+function escapeRegExp(value) {
+  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function compileCorrectionRule(rule, label) {
+  if (typeof rule.match !== "string" || rule.match.length === 0) {
+    throw new Error(`${label}: match must be a non-empty string`);
+  }
+  if (rule.match.length > MAX_PATTERN_LENGTH) {
+    throw new Error(
+      `${label}: match exceeds ${MAX_PATTERN_LENGTH} characters \u2014 correction patterns must stay short`
+    );
+  }
+  if (typeof rule.replace !== "string") {
+    throw new Error(`${label}: replace must be a string`);
+  }
+  const flags = rule.caseInsensitive === false ? "g" : "gi";
+  let pattern;
+  if (rule.regex === true) {
+    try {
+      pattern = new RegExp(rule.match, flags);
+    } catch (err) {
+      throw new Error(
+        `${label}: match is not a valid regular expression: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  } else {
+    const escaped = escapeRegExp(rule.match);
+    const leading = /^[\p{L}\p{N}_]/u.test(rule.match) ? "\\b" : "";
+    const trailing = /[\p{L}\p{N}_]$/u.test(rule.match) ? "\\b" : "";
+    pattern = new RegExp(`${leading}${escaped}${trailing}`, flags);
+  }
+  if (pattern.test("")) {
+    throw new Error(
+      `${label}: pattern matches the empty string and would corrupt every transcript`
+    );
+  }
+  pattern.lastIndex = 0;
+  return { rule, pattern };
+}
+function compileCorrectionRules(rules, labelPrefix) {
+  return rules.map(
+    (rule, index) => compileCorrectionRule(rule, `${labelPrefix}[${index}]`)
+  );
+}
+function applyCorrections(text, rules, sourceId) {
+  let applied = 0;
+  let result = text;
+  for (const { rule, pattern } of rules) {
+    if (Array.isArray(rule.sources) && rule.sources.length > 0 && !rule.sources.includes(sourceId)) {
+      continue;
+    }
+    pattern.lastIndex = 0;
+    result = result.replace(pattern, () => {
+      applied += 1;
+      return rule.replace;
+    });
+  }
+  return { text: result, applied };
+}
+function correctionsFilePath(memoryDir) {
+  return path.join(memoryDir, "state", "wearables", "corrections.json");
+}
+async function loadCorrectionsFile(memoryDir) {
+  const filePath = correctionsFilePath(memoryDir);
+  let raw;
+  try {
+    raw = await fsPromises.readFile(filePath, "utf-8");
+  } catch (err) {
+    if (err.code === "ENOENT") return [];
+    throw err;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch (err) {
+    throw new Error(
+      `wearables corrections file is not valid JSON (state/wearables/corrections.json): ${err instanceof Error ? err.message : String(err)}`
+    );
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed) || !Array.isArray(parsed.rules)) {
+    throw new Error(
+      'wearables corrections file has an unexpected shape (state/wearables/corrections.json); expected {"version":1,"rules":[...]}'
+    );
+  }
+  const rules = parsed.rules;
+  compileCorrectionRules(rules, "state corrections");
+  return rules;
+}
+async function saveCorrectionsFile(memoryDir, rules) {
+  compileCorrectionRules(rules, "state corrections");
+  const filePath = correctionsFilePath(memoryDir);
+  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });
+  const payload = { version: 1, rules };
+  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;
+  await fsPromises.writeFile(
+    tmpPath,
+    `${JSON.stringify(payload, null, 2)}
+`,
+    "utf-8"
+  );
+  try {
+    await fsPromises.rename(tmpPath, filePath);
+  } catch (err) {
+    await fsPromises.unlink(tmpPath).catch(() => void 0);
+    throw err;
+  }
+}
+
+// src/wearables/redaction.ts
+var REDACTION_PLACEHOLDER = "[redacted]";
+var BUILT_IN_PATTERNS = [
+  /\b\d{3}-\d{2}-\d{4}\b/g,
+  // Starts and ENDS on a digit so a trailing separator is never
+  // consumed (replacing it would glue the placeholder to the next word).
+  /\b\d(?:[ -]?\d){12,18}\b/g
+];
+var CARD_MIN_DIGITS = 13;
+function redactText(text, userPatterns) {
+  let redactions = 0;
+  let result = text;
+  result = result.replace(BUILT_IN_PATTERNS[0], () => {
+    redactions += 1;
+    return REDACTION_PLACEHOLDER;
+  });
+  result = result.replace(BUILT_IN_PATTERNS[1], (match) => {
+    const digits = match.replace(/\D/g, "");
+    if (digits.length < CARD_MIN_DIGITS || digits.length > 19) {
+      return match;
+    }
+    redactions += 1;
+    return REDACTION_PLACEHOLDER;
+  });
+  for (const pattern of userPatterns) {
+    result = result.replace(pattern, () => {
+      redactions += 1;
+      return REDACTION_PLACEHOLDER;
+    });
+  }
+  return { text: result, redactions };
+}
+function compileRedactionPatterns(patterns) {
+  return patterns.map((pattern, index) => {
+    if (typeof pattern !== "string" || pattern.trim().length === 0) {
+      throw new Error(
+        `wearables.redactionPatterns[${index}] must be a non-empty string`
+      );
+    }
+    if (pattern.length > 256) {
+      throw new Error(
+        `wearables.redactionPatterns[${index}] exceeds 256 characters \u2014 redaction patterns must stay short`
+      );
+    }
+    try {
+      return new RegExp(pattern, "gi");
+    } catch (err) {
+      throw new Error(
+        `wearables.redactionPatterns[${index}] is not a valid regular expression: ${err instanceof Error ? err.message : String(err)}`
+      );
+    }
+  });
+}
+var OFF_THE_RECORD = /\boff\s+the\s+record\b/i;
+var BACK_ON_THE_RECORD = /\b(?:back\s+)?on\s+the\s+record\b/i;
+function applyOffTheRecord(conversation) {
+  let offRecord = false;
+  let droppedSegments = 0;
+  const segments = [];
+  for (const segment of conversation.segments) {
+    if (!offRecord && OFF_THE_RECORD.test(segment.text)) {
+      offRecord = true;
+      segments.push({
+        ...segment,
+        text: "[off the record \u2014 segment elided]"
+      });
+      continue;
+    }
+    if (offRecord) {
+      if (BACK_ON_THE_RECORD.test(segment.text)) {
+        offRecord = false;
+        segments.push({
+          ...segment,
+          text: "[back on the record]"
+        });
+      } else {
+        droppedSegments += 1;
+      }
+      continue;
+    }
+    segments.push(segment);
+  }
+  return {
+    conversation: { ...conversation, segments },
+    droppedSegments
+  };
+}
+
+export {
+  compileCorrectionRule,
+  compileCorrectionRules,
+  applyCorrections,
+  correctionsFilePath,
+  loadCorrectionsFile,
+  saveCorrectionsFile,
+  REDACTION_PLACEHOLDER,
+  redactText,
+  compileRedactionPatterns,
+  applyOffTheRecord
+};
+//# sourceMappingURL=chunk-NDAH7BJ5.js.map

package/dist/chunk-NDAH7BJ5.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/wearables/corrections.ts","../src/wearables/redaction.ts"],"sourcesContent":["/**\n * Wearable transcript corrections — user-specific replacement rules.\n *\n * ASR engines consistently mishear the same proper nouns for the same\n * person (\"remnick\" for \"Remnic\", a colleague's name, product jargon).\n * Rules come from two places, merged at sync time:\n *\n *  1. `wearables.corrections` in plugin config (declarative, versioned\n *     with the operator's config).\n *  2. A CLI-managed rules file at `state/wearables/corrections.json`\n *     (added interactively via `remnic wearables corrections add`).\n *\n * Literal rules are regex-escaped before compilation and replacements\n * are applied via a function (never a replacement string) so `$` in\n * either side can't corrupt output.\n */\n\nimport { promises as fsPromises } from \"node:fs\";\nimport * as path from \"node:path\";\n\nimport type { WearableCorrectionRule } from \"./types.js\";\n\nexport interface CompiledCorrectionRule {\n  rule: WearableCorrectionRule;\n  pattern: RegExp;\n}\n\nexport interface CorrectionApplication {\n  text: string;\n  applied: number;\n}\n\n/** Hard cap on rule pattern length (bounds hostile/pathological regexes). */\nconst MAX_PATTERN_LENGTH = 256;\n\nfunction escapeRegExp(value: string): string {\n  return value.replace(/[.*+?^${}()|[\\]\\\\]/g, \"\\\\$&\");\n}\n\n/**\n * Validate and compile a correction rule. Throws a descriptive error on\n * invalid input (empty match, regex that doesn't compile, regex that\n * matches the empty string) — callers surface this at config parse or\n * CLI time rather than skipping the rule silently.\n */\nexport function compileCorrectionRule(\n  rule: WearableCorrectionRule,\n  label: string,\n): CompiledCorrectionRule {\n  if (typeof rule.match !== \"string\" || rule.match.length === 0) {\n    throw new Error(`${label}: match must be a non-empty string`);\n  }\n  if (rule.match.length > MAX_PATTERN_LENGTH) {\n    throw new Error(\n      `${label}: match exceeds ${MAX_PATTERN_LENGTH} characters — correction patterns must stay short`,\n    );\n  }\n  if (typeof rule.replace !== \"string\") {\n    throw new Error(`${label}: replace must be a string`);\n  }\n  const flags = rule.caseInsensitive === false ? \"g\" : \"gi\";\n  let pattern: RegExp;\n  if (rule.regex === true) {\n    try {\n      // Operator-supplied regexes are the documented feature here\n      // (rules live in the operator's own config / state file, never in\n      // request input); the length cap above bounds pathological\n      // patterns. CodeQL js/regex-injection is dismissed by design for\n      // this site.\n      pattern = new RegExp(rule.match, flags);\n    } catch (err) {\n      throw new Error(\n        `${label}: match is not a valid regular expression: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n  } else {\n    // Literal rules match on word boundaries when both edges of the\n    // match are word characters, so \"remnick\" doesn't fire inside\n    // \"remnickson\" unless the user opts into regex mode.\n    const escaped = escapeRegExp(rule.match);\n    const leading = /^[\\p{L}\\p{N}_]/u.test(rule.match) ? \"\\\\b\" : \"\";\n    const trailing = /[\\p{L}\\p{N}_]$/u.test(rule.match) ? \"\\\\b\" : \"\";\n    pattern = new RegExp(`${leading}${escaped}${trailing}`, flags);\n  }\n  if (pattern.test(\"\")) {\n    throw new Error(\n      `${label}: pattern matches the empty string and would corrupt every transcript`,\n    );\n  }\n  pattern.lastIndex = 0;\n  return { rule, pattern };\n}\n\n/** Compile a rule list, labeling errors with their index. */\nexport function compileCorrectionRules(\n  rules: WearableCorrectionRule[],\n  labelPrefix: string,\n): CompiledCorrectionRule[] {\n  return rules.map((rule, index) =>\n    compileCorrectionRule(rule, `${labelPrefix}[${index}]`),\n  );\n}\n\n/** Apply every applicable rule to a piece of transcript text. */\nexport function applyCorrections(\n  text: string,\n  rules: CompiledCorrectionRule[],\n  sourceId: string,\n): CorrectionApplication {\n  let applied = 0;\n  let result = text;\n  for (const { rule, pattern } of rules) {\n    if (\n      Array.isArray(rule.sources) &&\n      rule.sources.length > 0 &&\n      !rule.sources.includes(sourceId)\n    ) {\n      continue;\n    }\n    pattern.lastIndex = 0;\n    result = result.replace(pattern, () => {\n      applied += 1;\n      // Replacement via function: `$` in rule.replace stays literal.\n      return rule.replace;\n    });\n  }\n  return { text: result, applied };\n}\n\n// ---------------------------------------------------------------------------\n// CLI-managed rules file\n// ---------------------------------------------------------------------------\n\ninterface CorrectionsFileShape {\n  version: 1;\n  rules: WearableCorrectionRule[];\n}\n\nexport function correctionsFilePath(memoryDir: string): string {\n  return path.join(memoryDir, \"state\", \"wearables\", \"corrections.json\");\n}\n\n/**\n * Load CLI-managed correction rules. A missing file means no rules; a\n * malformed file throws (operators should know their corrections are\n * not being applied rather than silently losing them).\n */\nexport async function loadCorrectionsFile(\n  memoryDir: string,\n): Promise<WearableCorrectionRule[]> {\n  const filePath = correctionsFilePath(memoryDir);\n  let raw: string;\n  try {\n    raw = await fsPromises.readFile(filePath, \"utf-8\");\n  } catch (err) {\n    if ((err as NodeJS.ErrnoException).code === \"ENOENT\") return [];\n    throw err;\n  }\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw);\n  } catch (err) {\n    throw new Error(\n      `wearables corrections file is not valid JSON (state/wearables/corrections.json): ${\n        err instanceof Error ? err.message : String(err)\n      }`,\n    );\n  }\n  if (\n    typeof parsed !== \"object\" ||\n    parsed === null ||\n    Array.isArray(parsed) ||\n    !Array.isArray((parsed as CorrectionsFileShape).rules)\n  ) {\n    throw new Error(\n      'wearables corrections file has an unexpected shape (state/wearables/corrections.json); expected {\"version\":1,\"rules\":[...]}',\n    );\n  }\n  const rules = (parsed as CorrectionsFileShape).rules;\n  // Validate every persisted rule up front so a hand-edited bad rule\n  // fails at load with its index, not mid-sync.\n  compileCorrectionRules(rules, \"state corrections\");\n  return rules;\n}\n\n/** Persist CLI-managed rules atomically (temp file + rename). */\nexport async function saveCorrectionsFile(\n  memoryDir: string,\n  rules: WearableCorrectionRule[],\n): Promise<void> {\n  compileCorrectionRules(rules, \"state corrections\");\n  const filePath = correctionsFilePath(memoryDir);\n  await fsPromises.mkdir(path.dirname(filePath), { recursive: true });\n  const payload: CorrectionsFileShape = { version: 1, rules };\n  const tmpPath = `${filePath}.tmp-${process.pid}-${Date.now().toString(36)}`;\n  await fsPromises.writeFile(\n    tmpPath,\n    `${JSON.stringify(payload, null, 2)}\\n`,\n    \"utf-8\",\n  );\n  try {\n    await fsPromises.rename(tmpPath, filePath);\n  } catch (err) {\n    // Clean up the temp file on rename failure; the original (if any)\n    // is untouched.\n    await fsPromises.unlink(tmpPath).catch(() => undefined);\n    throw err;\n  }\n}\n","/**\n * Wearable transcript redaction — privacy guard applied before any\n * transcript text is persisted or fed to extraction.\n *\n * Always-on recorders capture things nobody intended to store: card\n * numbers read aloud, SSNs dictated to a pharmacy line. Built-in\n * patterns cover the unambiguous, high-sensitivity cases; users can add\n * their own regexes via `wearables.redactionPatterns` (validated at\n * config parse — invalid patterns are rejected loudly, never ignored).\n *\n * All built-in patterns are simple linear scans (no nested quantifiers)\n * to stay safely outside polynomial-ReDoS territory.\n */\n\nimport type { WearableConversation } from \"./types.js\";\n\nexport const REDACTION_PLACEHOLDER = \"[redacted]\";\n\n/**\n * Built-in patterns. Conservative by design — false positives erase\n * real transcript content, so each pattern targets formats that are\n * near-certain PII:\n *  - US SSN with separators (123-45-6789). Bare 9-digit runs are NOT\n *    matched (too many false positives: ids, tracking numbers).\n *  - Payment-card-like runs: 13–19 digits in groups separated by\n *    spaces/dashes (4111 1111 1111 1111) or contiguous 15–16 digits.\n */\nconst BUILT_IN_PATTERNS: RegExp[] = [\n  /\\b\\d{3}-\\d{2}-\\d{4}\\b/g,\n  // Starts and ENDS on a digit so a trailing separator is never\n  // consumed (replacing it would glue the placeholder to the next word).\n  /\\b\\d(?:[ -]?\\d){12,18}\\b/g,\n];\n\n/** Minimum digit count before a digit-run is treated as a card number. */\nconst CARD_MIN_DIGITS = 13;\n\nexport interface RedactionResult {\n  text: string;\n  redactions: number;\n}\n\nexport function redactText(\n  text: string,\n  userPatterns: RegExp[],\n): RedactionResult {\n  let redactions = 0;\n  let result = text;\n\n  // SSN pattern first (more specific than the digit-run pattern).\n  result = result.replace(BUILT_IN_PATTERNS[0], () => {\n    redactions += 1;\n    return REDACTION_PLACEHOLDER;\n  });\n\n  // Digit-run pattern with a post-match digit-count check so short\n  // grouped numbers (\"call 555 0125 today\") survive.\n  result = result.replace(BUILT_IN_PATTERNS[1], (match) => {\n    const digits = match.replace(/\\D/g, \"\");\n    if (digits.length < CARD_MIN_DIGITS || digits.length > 19) {\n      return match;\n    }\n    redactions += 1;\n    return REDACTION_PLACEHOLDER;\n  });\n\n  for (const pattern of userPatterns) {\n    result = result.replace(pattern, () => {\n      redactions += 1;\n      return REDACTION_PLACEHOLDER;\n    });\n  }\n\n  return { text: result, redactions };\n}\n\n/**\n * Compile user-supplied redaction patterns. Throws with a descriptive\n * message on the first invalid pattern — config parsing surfaces this\n * to the operator instead of silently skipping the rule.\n */\nexport function compileRedactionPatterns(patterns: string[]): RegExp[] {\n  return patterns.map((pattern, index) => {\n    if (typeof pattern !== \"string\" || pattern.trim().length === 0) {\n      throw new Error(\n        `wearables.redactionPatterns[${index}] must be a non-empty string`,\n      );\n    }\n    if (pattern.length > 256) {\n      throw new Error(\n        `wearables.redactionPatterns[${index}] exceeds 256 characters — redaction patterns must stay short`,\n      );\n    }\n    try {\n      // Operator-supplied regexes from the operator's own config —\n      // length-capped above; never request input.\n      return new RegExp(pattern, \"gi\");\n    } catch (err) {\n      throw new Error(\n        `wearables.redactionPatterns[${index}] is not a valid regular expression: ${\n          err instanceof Error ? err.message : String(err)\n        }`,\n      );\n    }\n  });\n}\n\nconst OFF_THE_RECORD = /\\boff\\s+the\\s+record\\b/i;\nconst BACK_ON_THE_RECORD = /\\b(?:back\\s+)?on\\s+the\\s+record\\b/i;\n\nexport interface OffTheRecordResult {\n  conversation: WearableConversation;\n  droppedSegments: number;\n}\n\n/**\n * Drop segments between a spoken \"off the record\" marker and the next\n * \"(back) on the record\" marker (or conversation end). The marker\n * segments themselves are kept, with the off-record span replaced by a\n * visible placeholder so the transcript shows that content was elided\n * by request rather than lost.\n */\nexport function applyOffTheRecord(\n  conversation: WearableConversation,\n): OffTheRecordResult {\n  let offRecord = false;\n  let droppedSegments = 0;\n  const segments = [];\n  for (const segment of conversation.segments) {\n    if (!offRecord && OFF_THE_RECORD.test(segment.text)) {\n      offRecord = true;\n      segments.push({\n        ...segment,\n        text: \"[off the record — segment elided]\",\n      });\n      continue;\n    }\n    if (offRecord) {\n      if (BACK_ON_THE_RECORD.test(segment.text)) {\n        offRecord = false;\n        segments.push({\n          ...segment,\n          text: \"[back on the record]\",\n        });\n      } else {\n        droppedSegments += 1;\n      }\n      continue;\n    }\n    segments.push(segment);\n  }\n  return {\n    conversation: { ...conversation, segments },\n    droppedSegments,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-R3OQGYOU.js → chunk-P2D2MM47.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-HQ6NIBL6.js";
 import {
   StorageManager
-} from "./chunk-PJGB7XRR.js";
+} from "./chunk-UGHUNQ74.js";
 import {
   getCachedEpisodeMap,
   setCachedEpisodeMap
@@ -105,4 +105,4 @@ async function searchVerifiedEpisodes(options) {
 export {
   searchVerifiedEpisodes
 };
-//# sourceMappingURL=chunk-R3OQGYOU.js.map
+//# sourceMappingURL=chunk-P2D2MM47.js.map

package/dist/{chunk-PSUB67YB.js → chunk-PW6GURU3.js}

@@ -3,7 +3,7 @@ import {
 } from "./chunk-SOBJ6NEY.js";
 import {
   summarizeDisclosureTokens
-} from "./chunk-BPSGLMQ4.js";
+} from "./chunk-YQNADJCT.js";
 import {
   summarizeRetrievedMemoryProvenance
 } from "./chunk-AC5LO7IU.js";
@@ -567,4 +567,4 @@ export {
   renderRecallExplain,
   parseRecallExplainFormat
 };
-//# sourceMappingURL=chunk-PSUB67YB.js.map
+//# sourceMappingURL=chunk-PW6GURU3.js.map

package/dist/{chunk-W3BKVM64.js → chunk-QDV6VAD4.js}

@@ -4,7 +4,7 @@ import {
 } from "./chunk-ZFXCQPNO.js";
 import {
   StorageManager
-} from "./chunk-PJGB7XRR.js";
+} from "./chunk-UGHUNQ74.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-U3PN77QT.js";
@@ -161,4 +161,4 @@ export {
   getCategoryDir,
   NamespaceStorageRouter
 };
-//# sourceMappingURL=chunk-W3BKVM64.js.map
+//# sourceMappingURL=chunk-QDV6VAD4.js.map

package/dist/{chunk-3QSU4NFF.js → chunk-QHXW3LZV.js}

@@ -1,10 +1,10 @@
 import {
   parseXrayFormat
-} from "./chunk-PSUB67YB.js";
+} from "./chunk-PW6GURU3.js";
 import {
   RECALL_DISCLOSURE_LEVELS,
   isRecallDisclosure
-} from "./chunk-4R4KTDIE.js";
+} from "./chunk-FPNQF475.js";
 
 // src/recall-xray-cli.ts
 function parseXrayDisclosureFlag(value) {
@@ -50,4 +50,4 @@ export {
   parseXrayBudgetFlag,
   parseXrayCliOptions
 };
-//# sourceMappingURL=chunk-3QSU4NFF.js.map
+//# sourceMappingURL=chunk-QHXW3LZV.js.map

package/dist/{chunk-I6UCUHLK.js → chunk-SHV5Y2WU.js}

@@ -11,13 +11,13 @@ import {
 } from "./chunk-D24OXEPB.js";
 import {
   EngramAccessInputError
-} from "./chunk-KQFQ3IS5.js";
+} from "./chunk-F3FY3D3S.js";
 import {
   projectTagProjectId
 } from "./chunk-EDQVAMQI.js";
 import {
   validateBriefingFormat
-} from "./chunk-OZXVGYGZ.js";
+} from "./chunk-STDAAGH7.js";
 import {
   expandTildePath
 } from "./chunk-EYIEWJNI.js";
@@ -136,6 +136,24 @@ function parseMcpRequest(schemaName, args) {
     details.length > 0 ? `${validation.error.error}: ${details}` : validation.error.error
   );
 }
+function optionalNonEmptyString(value, label) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "string") {
+    throw new Error(`${label} expects a string; got ${JSON.stringify(value)}`);
+  }
+  return value;
+}
+function optionalPositiveInteger(value, label) {
+  if (value === void 0 || value === null || value === "") return void 0;
+  if (typeof value !== "number" && typeof value !== "string") {
+    throw new Error(`${label} expects a positive integer; got ${JSON.stringify(value)}`);
+  }
+  const parsed = typeof value === "number" ? value : Number(value);
+  if (!Number.isFinite(parsed) || parsed <= 0 || !Number.isInteger(parsed)) {
+    throw new Error(`${label} expects a positive integer; got ${JSON.stringify(value)}`);
+  }
+  return parsed;
+}
 function getObjectProperties(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
 }
@@ -324,6 +342,119 @@ var EngramMcpServer = class {
           additionalProperties: false
         }
       },
+      {
+        name: "engram.wearables_status",
+        description: "Status of wearable transcript sources (Limitless / Bee / Omi): configured sources, connector availability, last sync, stored transcript days.",
+        inputSchema: {
+          type: "object",
+          properties: {},
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.wearables_sync",
+        description: "Pull, clean, and store wearable transcripts for one source or all enabled sources; optionally creates trust-gated memories per the source's memoryMode.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: {
+              type: "string",
+              description: "Source id (e.g. limitless, bee, omi). Omit to sync every enabled source."
+            },
+            date: {
+              type: "string",
+              description: "Sync exactly this day (YYYY-MM-DD). Overrides days."
+            },
+            days: {
+              type: "integer",
+              minimum: 1,
+              maximum: 90,
+              description: "Lookback window in days ending today (default 2)."
+            },
+            forceMemories: {
+              type: "boolean",
+              description: "Re-run memory extraction even for unchanged days."
+            }
+          },
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.transcript_day",
+        description: "Return the full stored wearable transcript(s) for a day, across all sources or one source, with cross-source overlap hints.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            date: {
+              type: "string",
+              description: "Day to read (YYYY-MM-DD). Required."
+            },
+            source: {
+              type: "string",
+              description: "Optional source id to scope to (e.g. limitless)."
+            }
+          },
+          required: ["date"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.transcript_search",
+        description: "Search stored wearable transcripts. Results carry source + date so callers can pull the full day via engram.transcript_day.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            query: {
+              type: "string",
+              description: "Search query. Required; non-empty."
+            },
+            source: {
+              type: "string",
+              description: "Optional source id filter."
+            },
+            from: {
+              type: "string",
+              description: "Optional inclusive start date (YYYY-MM-DD)."
+            },
+            to: {
+              type: "string",
+              description: "Optional inclusive end date (YYYY-MM-DD)."
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 50,
+              description: "Maximum results (default 10)."
+            }
+          },
+          required: ["query"],
+          additionalProperties: false
+        }
+      },
+      {
+        name: "engram.transcript_memories",
+        description: "List memories created from wearable transcripts, filterable by source and/or day. Includes pending_review candidates awaiting approval.",
+        inputSchema: {
+          type: "object",
+          properties: {
+            source: {
+              type: "string",
+              description: "Optional source id filter (e.g. limitless)."
+            },
+            date: {
+              type: "string",
+              description: "Optional transcript day filter (YYYY-MM-DD)."
+            },
+            limit: {
+              type: "integer",
+              minimum: 1,
+              maximum: 200,
+              description: "Maximum results (default 50)."
+            }
+          },
+          additionalProperties: false
+        }
+      },
       {
         name: "engram.action_confidence",
         description: "Advisory ask/draft/act/refuse/escalate decision helper for interruption budgeting. Read-only; never mutates memory.",
@@ -2101,6 +2232,54 @@ ${body}`;
           ...disclosure !== void 0 ? { disclosure } : {}
         });
       }
+      case "engram.wearables_status":
+        return this.service.wearablesStatus();
+      case "engram.wearables_sync": {
+        const source = optionalNonEmptyString(args.source, "engram.wearables_sync: source");
+        const date = optionalNonEmptyString(args.date, "engram.wearables_sync: date");
+        const days = optionalPositiveInteger(args.days, "engram.wearables_sync: days");
+        let forceMemories;
+        if (args.forceMemories !== void 0 && args.forceMemories !== null) {
+          if (typeof args.forceMemories !== "boolean") {
+            throw new Error(
+              `engram.wearables_sync: forceMemories expects a boolean; got ${JSON.stringify(args.forceMemories)}`
+            );
+          }
+          forceMemories = args.forceMemories;
+        }
+        return this.service.wearablesSync({ source, date, days, forceMemories });
+      }
+      case "engram.transcript_day": {
+        const date = typeof args.date === "string" ? args.date : "";
+        if (date.trim().length === 0) {
+          throw new Error(
+            "engram.transcript_day: date is required and must be YYYY-MM-DD"
+          );
+        }
+        const source = optionalNonEmptyString(args.source, "engram.transcript_day: source");
+        return this.service.wearablesTranscriptDay({ date, source });
+      }
+      case "engram.transcript_search": {
+        const query = typeof args.query === "string" ? args.query : "";
+        if (query.trim().length === 0) {
+          throw new Error(
+            "engram.transcript_search: query is required and must be non-empty"
+          );
+        }
+        return this.service.wearablesTranscriptSearch({
+          query,
+          source: optionalNonEmptyString(args.source, "engram.transcript_search: source"),
+          from: optionalNonEmptyString(args.from, "engram.transcript_search: from"),
+          to: optionalNonEmptyString(args.to, "engram.transcript_search: to"),
+          limit: optionalPositiveInteger(args.limit, "engram.transcript_search: limit")
+        });
+      }
+      case "engram.transcript_memories":
+        return this.service.wearablesTranscriptMemories({
+          source: optionalNonEmptyString(args.source, "engram.transcript_memories: source"),
+          date: optionalNonEmptyString(args.date, "engram.transcript_memories: date"),
+          limit: optionalPositiveInteger(args.limit, "engram.transcript_memories: limit")
+        });
       case "engram.action_confidence": {
         const body = parseMcpRequest("actionConfidence", args);
         return this.service.actionConfidence(body);
@@ -2903,4 +3082,4 @@ ${body}`;
 export {
   EngramMcpServer
 };
-//# sourceMappingURL=chunk-I6UCUHLK.js.map
+//# sourceMappingURL=chunk-SHV5Y2WU.js.map