@remnic/core 9.29.1 → 9.30.0

package/dist/chunk-PH3ZWL3W.js

@@ -0,0 +1,786 @@
+import {
+  buildExplicitCaptureDedupKey,
+  isTombstoneBlockedCaptureWriteLockBusy,
+  normalizeExplicitCaptureContent
+} from "./chunk-FBUE6PD3.js";
+import {
+  TAG_LIMITS,
+  composeMemoryEnvelope
+} from "./chunk-CGASUJVP.js";
+import {
+  sanitizeMemoryContent
+} from "./chunk-5GKPFL3S.js";
+import {
+  isSafeRouteNamespace
+} from "./chunk-U3PN77QT.js";
+import {
+  resolveNamespaceCapabilities
+} from "./chunk-2XRE6FLM.js";
+import {
+  log
+} from "./chunk-3WCASNQZ.js";
+
+// src/explicit-capture.ts
+import { createHash, randomUUID } from "crypto";
+var INLINE_NOTE_RE = /<memory_note>([\s\S]{0,100000}?)<\/memory_note>/gi;
+var INLINE_NOTE_MARKUP_RE = /<memory_note>[\s\S]{0,100000}?<\/memory_note>/i;
+var INLINE_ALLOWED_CATEGORIES = /* @__PURE__ */ new Set([
+  "fact",
+  "preference",
+  "correction",
+  "entity",
+  "decision",
+  "relationship",
+  "principle",
+  "commitment",
+  "moment",
+  "skill",
+  "rule",
+  "procedure",
+  "reasoning_trace"
+]);
+var SECRET_PATTERNS = [
+  /\bsk-[A-Za-z0-9]{16,}\b/,
+  /\bAKIA[0-9A-Z]{16}\b/,
+  /\bBearer\s+[A-Za-z0-9._-]{16,}\b/i,
+  /\b(?:api[_-]?key|secret|token|password|passwd)\s*[:=]\s*[^\s]{8,}\b/i,
+  /\b(?:authorization)\s*:\s*[^\s]{8,}\b/i
+];
+var SECRET_REDACTION_PATTERNS = [
+  { pattern: /\bsk-[A-Za-z0-9]{16,}\b/g, replacement: "[redacted openai key]" },
+  { pattern: /\bAKIA[0-9A-Z]{16}\b/g, replacement: "[redacted aws key]" },
+  { pattern: /\bBearer\s+[A-Za-z0-9._-]{16,}\b/gi, replacement: "Bearer [redacted token]" },
+  {
+    pattern: /\b(?:api[_-]?key|secret|token|password|passwd)\s*[:=]\s*[^\s]{8,}\b/gi,
+    replacement: "[redacted credential]"
+  },
+  {
+    pattern: /\b(?:authorization)\s*:\s*[^\s]{8,}\b/gi,
+    replacement: "authorization: [redacted credential]"
+  }
+];
+var EXPLICIT_CAPTURE_REVIEW_TAGS = ["explicit-capture", "queued-review"];
+function explicitCaptureActor(source) {
+  switch (source) {
+    case "inline":
+      return "inline.memory_note";
+    case "memory_store":
+      return "tool.memory_store";
+    case "suggestion_submit":
+      return "tool.suggestion_submit";
+    default:
+      return "tool.memory_capture";
+  }
+}
+function asTrimmed(value) {
+  const trimmed = value?.trim();
+  return trimmed && trimmed.length > 0 ? trimmed : void 0;
+}
+function redactSecrets(value) {
+  let redacted = value;
+  for (const { pattern, replacement } of SECRET_REDACTION_PATTERNS) {
+    redacted = redacted.replace(pattern, replacement);
+  }
+  return redacted;
+}
+function containsSecretLikeValue(value) {
+  return SECRET_PATTERNS.some((pattern) => pattern.test(value));
+}
+function assertNoSecretLikeMetadata(field, value) {
+  const trimmed = asTrimmed(value);
+  if (trimmed && containsSecretLikeValue(trimmed)) {
+    throw new Error(`${field} appears to contain a secret or credential`);
+  }
+}
+function assertNoSecretLikeMetadataList(field, values) {
+  for (const value of values ?? []) {
+    assertNoSecretLikeMetadata(field, value);
+  }
+}
+function sanitizeReviewText(value, fallback) {
+  const redacted = redactSecrets(asTrimmed(value) ?? fallback);
+  const sanitized = sanitizeMemoryContent(redacted);
+  const safe = sanitized.text.trim();
+  return safe.length > 0 ? safe : fallback;
+}
+function sanitizeReviewMetadata(value) {
+  const trimmed = asTrimmed(value);
+  if (!trimmed) return void 0;
+  return sanitizeReviewText(trimmed, "[redacted]");
+}
+function sanitizeReviewTags(tags) {
+  return Array.from(
+    new Set(
+      (tags ?? []).map((tag) => sanitizeReviewMetadata(tag)).filter((tag) => typeof tag === "string" && tag.length > 0)
+    )
+  );
+}
+function normalizeExplicitCaptureError(error) {
+  if (error instanceof Error && error.message.trim().length > 0) return error.message.trim();
+  const rendered = String(error).trim();
+  return rendered.length > 0 ? rendered : "explicit capture failed";
+}
+function isUnsupportedExplicitCaptureNamespaceError(error) {
+  return normalizeExplicitCaptureError(error).startsWith("unsupported namespace:");
+}
+function resolveExplicitCaptureReviewNamespace(orchestrator, namespace) {
+  const normalized = asTrimmed(namespace);
+  if (!normalized) return void 0;
+  return resolveExplicitCaptureNamespace(orchestrator, normalized);
+}
+function resolveExplicitCaptureNamespace(orchestrator, namespace) {
+  const normalized = asTrimmed(namespace);
+  if (!normalized) return void 0;
+  if (!resolveNamespaceCapabilities(orchestrator.config).namespaces) {
+    if (normalized !== orchestrator.config.defaultNamespace) {
+      throw new Error(`unsupported namespace: ${normalized}`);
+    }
+    return normalized;
+  }
+  const allowed = new Set(
+    [
+      orchestrator.config.defaultNamespace,
+      orchestrator.config.sharedNamespace,
+      ...orchestrator.config.namespacePolicies.map((policy) => policy.name)
+    ].map((value) => value.trim()).filter(Boolean)
+  );
+  if (!allowed.has(normalized)) {
+    throw new Error(`unsupported namespace: ${normalized}`);
+  }
+  return normalized;
+}
+function parseExplicitCaptureTtl(ttl) {
+  const raw = asTrimmed(ttl);
+  if (!raw) return void 0;
+  const absoluteMs = Date.parse(raw);
+  if (Number.isFinite(absoluteMs)) {
+    return new Date(absoluteMs).toISOString();
+  }
+  const relative = raw.match(/^(\d+)\s*([mhdw])$/i);
+  if (!relative) {
+    throw new Error("ttl must be an ISO-8601 timestamp or relative duration like 30m, 12h, 7d, or 2w");
+  }
+  const amount = Number.parseInt(relative[1] ?? "", 10);
+  const unit = (relative[2] ?? "").toLowerCase();
+  if (!Number.isFinite(amount) || amount <= 0) {
+    throw new Error("ttl duration must be a positive integer");
+  }
+  const multiplier = unit === "m" ? 6e4 : unit === "h" ? 60 * 6e4 : unit === "d" ? 24 * 60 * 6e4 : 7 * 24 * 60 * 6e4;
+  return new Date(Date.now() + amount * multiplier).toISOString();
+}
+function parseInlineConfidence(value) {
+  const trimmed = value.trim();
+  if (!/^[+-]?(?:\d+(?:\.\d*)?|\.\d+)(?:e[+-]?\d+)?$/i.test(trimmed)) {
+    return Number.NaN;
+  }
+  const parsed = Number(trimmed);
+  return Number.isFinite(parsed) ? parsed : Number.NaN;
+}
+function parseInlineNote(block) {
+  const lines = block.replace(/\r/g, "").split("\n");
+  const note = {};
+  let idx = 0;
+  while (idx < lines.length) {
+    const rawLine = lines[idx] ?? "";
+    const line = rawLine.trim();
+    idx += 1;
+    if (line.length === 0) continue;
+    const colonIdx = line.indexOf(":");
+    if (colonIdx < 0) continue;
+    const key = line.slice(0, colonIdx).trim();
+    const value = line.slice(colonIdx + 1).trim();
+    if (key === "content" && value === "|") {
+      const contentLines = [];
+      while (idx < lines.length) {
+        const next = lines[idx] ?? "";
+        if (next.startsWith("  ") || next.startsWith("	")) {
+          contentLines.push(next.replace(/^(  |\t)/, ""));
+          idx += 1;
+          continue;
+        }
+        if (next.trim().length === 0) {
+          contentLines.push("");
+          idx += 1;
+          continue;
+        }
+        break;
+      }
+      note.content = contentLines.join("\n").trim();
+      continue;
+    }
+    switch (key) {
+      case "content":
+        note.content = value;
+        break;
+      case "category":
+        note.category = value;
+        break;
+      case "confidence":
+        note.confidence = parseInlineConfidence(value);
+        break;
+      case "namespace":
+        note.namespace = value;
+        break;
+      case "tags":
+        note.tags = value.split(",").map((entry) => entry.trim()).filter(Boolean);
+        break;
+      case "entityRef":
+        note.entityRef = value;
+        break;
+      case "ttl":
+        note.ttl = value;
+        break;
+      case "sourceReason":
+        note.sourceReason = value;
+        break;
+      default:
+        break;
+    }
+  }
+  return { content: "", ...note };
+}
+function parseInlineExplicitCaptureCandidates(text) {
+  const notes = [];
+  for (const match of text.matchAll(INLINE_NOTE_RE)) {
+    notes.push(parseInlineNote(match[1] ?? ""));
+  }
+  return notes;
+}
+function parseInlineExplicitCaptureNotes(text) {
+  return parseInlineExplicitCaptureCandidates(text).filter((note) => asTrimmed(note.content));
+}
+function hasInlineExplicitCaptureMarkup(text) {
+  return INLINE_NOTE_MARKUP_RE.test(text);
+}
+function stripInlineExplicitCaptureNotes(text) {
+  return text.replace(INLINE_NOTE_RE, "").trim();
+}
+function validateExplicitCaptureInput(input, mode = "strict_explicit") {
+  const content = asTrimmed(input.content);
+  if (!content) throw new Error("content is required");
+  if (mode === "strict_explicit") {
+    if (content.length < 10) throw new Error("content must be at least 10 characters");
+    if (content.length > 4e3) throw new Error("content must be 4000 characters or fewer");
+  }
+  if (/<memory_note>/i.test(content) || /<\/memory_note>/i.test(content)) {
+    throw new Error("nested memory_note blocks are not allowed");
+  }
+  const category = asTrimmed(input.category) ?? "fact";
+  if (!INLINE_ALLOWED_CATEGORIES.has(category)) {
+    throw new Error(`unsupported category: ${input.category ?? category}`);
+  }
+  const sanitized = sanitizeMemoryContent(content);
+  if (!sanitized.clean) {
+    throw new Error("content failed memory sanitization");
+  }
+  for (const pattern of SECRET_PATTERNS) {
+    if (pattern.test(content)) {
+      throw new Error("content appears to contain a secret or credential");
+    }
+  }
+  assertNoSecretLikeMetadata("sourceReason", input.sourceReason);
+  assertNoSecretLikeMetadata("entityRef", input.entityRef);
+  assertNoSecretLikeMetadata("ttl", input.ttl);
+  assertNoSecretLikeMetadataList("tags", input.tags);
+  if (input.confidence !== void 0 && !Number.isFinite(input.confidence)) {
+    throw new Error("confidence must be a finite number");
+  }
+  const confidence = input.confidence === void 0 ? 0.95 : Number(input.confidence);
+  if (confidence < 0 || confidence > 1) {
+    throw new Error("confidence must be between 0 and 1");
+  }
+  const requestedNamespace = asTrimmed(input.namespace);
+  if (requestedNamespace && !isSafeRouteNamespace(requestedNamespace)) {
+    throw new Error(`unsafe namespace: ${requestedNamespace}`);
+  }
+  const expiresAt = parseExplicitCaptureTtl(input.ttl);
+  const dedupedTags = Array.from(new Set((input.tags ?? []).map((tag) => tag.trim()).filter(Boolean)));
+  if (dedupedTags.length > TAG_LIMITS.maxTags) {
+    throw new Error(`too many tags: ${dedupedTags.length} exceeds the ${TAG_LIMITS.maxTags}-tag limit`);
+  }
+  for (const tag of dedupedTags) {
+    if (tag.length > TAG_LIMITS.maxTagLength) {
+      throw new Error(`tag exceeds ${TAG_LIMITS.maxTagLength} characters: ${JSON.stringify(tag.slice(0, 40))}\u2026`);
+    }
+  }
+  return {
+    content,
+    category,
+    confidence,
+    namespace: asTrimmed(input.namespace),
+    tags: dedupedTags,
+    entityRef: asTrimmed(input.entityRef),
+    sourceReason: asTrimmed(input.sourceReason),
+    // Trimmed like the other optional metadata (#2017 review round): a
+    // whitespace-only connector previously passed validation and then blew
+    // up at strict compose time - validated input must always compose.
+    sourceConnector: asTrimmed(input.sourceConnector),
+    expiresAt
+  };
+}
+async function findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate, storageOverride) {
+  const storage = storageOverride ?? await orchestrator.getStorage(resolvedNamespace);
+  let authoritativeFactHashMiss = false;
+  if (candidate.category === "fact" && typeof storage.hasFactContentHash === "function") {
+    try {
+      const hasHash = await storage.hasFactContentHash(candidate.content);
+      if (!hasHash) {
+        const authoritative = typeof storage.isFactContentHashAuthoritative === "function" ? await storage.isFactContentHashAuthoritative() : false;
+        authoritativeFactHashMiss = authoritative;
+      }
+    } catch (err) {
+      void err;
+    }
+  }
+  if (authoritativeFactHashMiss) {
+    const checkBlockedIndex = storage.checkTombstoneBlockedExplicitCapture;
+    if (typeof checkBlockedIndex === "function") {
+      try {
+        const result = await checkBlockedIndex.call(
+          storage,
+          candidate.content,
+          candidate.category,
+          candidate.sourceConnector
+        );
+        if (!result.has && result.authoritative) return null;
+      } catch (err) {
+        void err;
+      }
+    } else {
+      const hasBlockedIndex = storage.hasTombstoneBlockedExplicitCapture;
+      if (typeof hasBlockedIndex === "function") {
+        try {
+          const hasBlocked = await hasBlockedIndex.call(
+            storage,
+            candidate.content,
+            candidate.category,
+            candidate.sourceConnector
+          );
+          if (!hasBlocked) {
+            const isIndexAuthoritative = typeof storage.isTombstoneBlockedExplicitCaptureIndexAuthoritative === "function" ? await storage.isTombstoneBlockedExplicitCaptureIndexAuthoritative() : false;
+            if (isIndexAuthoritative) return null;
+          }
+        } catch (err) {
+          void err;
+        }
+      }
+    }
+  }
+  const hotMemories = await storage.readAllMemories();
+  const coldMemories = typeof storage.readAllColdMemories === "function" ? await storage.readAllColdMemories() : [];
+  const existing = [...hotMemories, ...coldMemories];
+  const normalizedCandidate = normalizeExplicitCaptureContent(candidate.content);
+  const match = existing.find((memory) => {
+    const status = memory.frontmatter.status ?? "active";
+    if (status !== "active" && (status !== "pending_review" || !memory.frontmatter.blockedBy)) {
+      return false;
+    }
+    if (memory.frontmatter.category !== candidate.category) return false;
+    if (normalizeExplicitCaptureContent(memory.content) !== normalizedCandidate) return false;
+    const existingConnector = memory.frontmatter.sourceConnector?.trim() || void 0;
+    const newConnector = candidate.sourceConnector?.trim() || void 0;
+    if (existingConnector !== newConnector) return false;
+    return true;
+  });
+  return match ? {
+    id: match.frontmatter.id,
+    tombstoneBlocked: match.frontmatter.status === "pending_review" && Boolean(match.frontmatter.blockedBy)
+  } : null;
+}
+async function persistExplicitCaptureUnlocked(orchestrator, candidate, source, resolvedNamespace, storage) {
+  const duplicate = await findDuplicateExplicitCapture(orchestrator, resolvedNamespace, candidate, storage);
+  if (duplicate) {
+    return duplicate.tombstoneBlocked ? { id: duplicate.id, duplicateOf: duplicate.id, tombstoneBlocked: true } : { id: duplicate.id, duplicateOf: duplicate.id };
+  }
+  const captureEnvelope = composeMemoryEnvelope(
+    {
+      content: candidate.content,
+      category: candidate.category,
+      confidence: candidate.confidence,
+      tags: candidate.tags,
+      ...candidate.entityRef ? { entityRef: candidate.entityRef } : {},
+      ...candidate.expiresAt ? { ttl: candidate.expiresAt } : {},
+      ...candidate.sourceConnector ? { sourceConnector: candidate.sourceConnector } : {},
+      ...candidate.sourceReason ? { sourceReason: candidate.sourceReason } : {}
+    },
+    { source: source === "inline" ? "explicit-inline" : "explicit" }
+  );
+  const { id, duplicateOf, tombstoneBlocked } = await storage.writeSealedMemory(captureEnvelope);
+  if (duplicateOf) return { id, duplicateOf, tombstoneBlocked };
+  const created = (/* @__PURE__ */ new Date()).toISOString();
+  const event = {
+    eventId: `mle-${randomUUID()}`,
+    memoryId: id,
+    eventType: tombstoneBlocked ? "explicit_capture_queued" : "explicit_capture_accepted",
+    timestamp: created,
+    actor: explicitCaptureActor(source),
+    reasonCode: candidate.sourceReason,
+    ruleVersion: "explicit-capture.v1"
+  };
+  await storage.appendMemoryLifecycleEvents([event]);
+  return { id, duplicateOf, tombstoneBlocked };
+}
+async function persistExplicitCapture(orchestrator, candidate, source) {
+  const resolvedNamespace = candidate.namespacePreResolved ? asTrimmed(candidate.namespace) : resolveExplicitCaptureNamespace(orchestrator, candidate.namespace);
+  const storage = await orchestrator.getStorage(resolvedNamespace);
+  const persist = () => persistExplicitCaptureUnlocked(orchestrator, candidate, source, resolvedNamespace, storage);
+  if (typeof storage.withTombstoneBlockedCaptureWriteLock !== "function") return await persist();
+  const lockIdentity = buildExplicitCaptureDedupKey(candidate.content, candidate.category, candidate.sourceConnector);
+  return await storage.withTombstoneBlockedCaptureWriteLock(persist, lockIdentity);
+}
+function buildExplicitCaptureReviewContent(input, reason) {
+  const requestedContent = asTrimmed(input.content);
+  const safeContent = sanitizeReviewText(requestedContent, "[empty explicit capture]");
+  const safeCategory = sanitizeReviewMetadata(input.category);
+  const safeNamespace = sanitizeReviewMetadata(input.namespace);
+  const safeEntityRef = sanitizeReviewMetadata(input.entityRef);
+  const safeTtl = sanitizeReviewMetadata(input.ttl);
+  const safeSourceReason = sanitizeReviewMetadata(input.sourceReason);
+  const safeTags = sanitizeReviewTags(input.tags);
+  const lines = ["Explicit capture queued for review.", "", `Reason: ${reason}`, "", "Submitted content:", safeContent];
+  const metadata = [
+    safeCategory ? `Requested category: ${safeCategory}` : void 0,
+    safeNamespace ? `Requested namespace: ${safeNamespace}` : void 0,
+    safeEntityRef ? `Requested entityRef: ${safeEntityRef}` : void 0,
+    safeTtl ? `Requested ttl: ${safeTtl}` : void 0,
+    safeSourceReason ? `Requested sourceReason: ${safeSourceReason}` : void 0,
+    safeTags.length > 0 ? `Requested tags: ${safeTags.join(", ")}` : void 0
+  ].filter((entry) => typeof entry === "string" && entry.length > 0);
+  if (metadata.length > 0) {
+    lines.push("", ...metadata);
+  }
+  return lines.join("\n");
+}
+function explicitCaptureReviewNamespaces(orchestrator, queueNamespace) {
+  const config = orchestrator.config;
+  return [asTrimmed(queueNamespace) ?? asTrimmed(config?.defaultNamespace)];
+}
+async function findQueuedExplicitCaptureDuplicate(orchestrator, namespace, content, sourceConnector) {
+  const storages = Array.from(
+    new Set(
+      await Promise.all(
+        explicitCaptureReviewNamespaces(orchestrator, namespace).map(
+          (reviewNamespace) => orchestrator.getStorage(reviewNamespace)
+        )
+      )
+    )
+  );
+  const memorySets = await Promise.all(
+    storages.map(async (storage) => {
+      const hotMemories = await storage.readAllMemories();
+      const coldMemories = typeof storage.readAllColdMemories === "function" ? await storage.readAllColdMemories() : [];
+      return [...hotMemories, ...coldMemories];
+    })
+  );
+  const existing = memorySets.flat();
+  const normalized = normalizeExplicitCaptureContent(content);
+  const match = existing.find((memory) => {
+    const status = memory.frontmatter.status ?? "active";
+    if (status !== "pending_review") return false;
+    if (!(memory.frontmatter.tags ?? []).includes("queued-review")) return false;
+    if (normalizeExplicitCaptureContent(memory.content) !== normalized) return false;
+    const existingConnector = memory.frontmatter.sourceConnector?.trim() || void 0;
+    const newConnector = sourceConnector?.trim() || void 0;
+    if (existingConnector !== newConnector) return false;
+    return true;
+  });
+  return match?.frontmatter.id ?? null;
+}
+async function queueExplicitCaptureForReview(orchestrator, input, source, error, options = {}) {
+  const reason = sanitizeReviewText(normalizeExplicitCaptureError(error), "explicit capture failed");
+  const requestedNamespace = asTrimmed(input.namespace);
+  const resolvedNamespace = asTrimmed(options.resolvedNamespace);
+  const queueNamespace = resolvedNamespace ?? (input.namespacePreResolved ? requestedNamespace : resolveExplicitCaptureReviewNamespace(orchestrator, requestedNamespace));
+  const content = buildExplicitCaptureReviewContent(input, reason);
+  const requestedCategory = asTrimmed(input.category);
+  const reviewCategory = requestedCategory && INLINE_ALLOWED_CATEGORIES.has(requestedCategory) ? requestedCategory : "fact";
+  const requestedTags = sanitizeReviewTags(input.tags);
+  const storage = await orchestrator.getStorage(queueNamespace);
+  const lockIdentity = buildExplicitCaptureDedupKey(content, reviewCategory, input.sourceConnector);
+  const queue = async () => {
+    const duplicateOf = await findQueuedExplicitCaptureDuplicate(
+      orchestrator,
+      queueNamespace,
+      content,
+      input.sourceConnector
+    );
+    if (duplicateOf) {
+      return { id: duplicateOf, duplicateOf };
+    }
+    const reviewEnvelope = composeMemoryEnvelope(
+      {
+        content,
+        category: reviewCategory,
+        confidence: 0.2,
+        tags: Array.from(/* @__PURE__ */ new Set([...EXPLICIT_CAPTURE_REVIEW_TAGS, ...requestedTags])),
+        ...sanitizeReviewMetadata(input.entityRef) ? { entityRef: sanitizeReviewMetadata(input.entityRef) } : {},
+        ...input.sourceConnector ? { sourceConnector: input.sourceConnector } : {}
+      },
+      { source: source === "inline" ? "explicit-inline-review" : "explicit-review" },
+      // The review queue is the FALLBACK for a capture that already failed
+      // primary validation — it must never be un-queueable. The tag list is
+      // machine-assembled (requested tags + the two fixed review tags), so 49+
+      // requested tags would push past the 50-tag limit and strict compose
+      // would throw, losing the capture (#2014 review round). Salvage clamps
+      // instead; the fixed review tags sort first in the assembly above, so
+      // they always survive the clamp.
+      { salvage: true }
+    );
+    const { id } = await storage.writeSealedMemory(reviewEnvelope);
+    try {
+      const created = await storage.getMemoryById(id);
+      if (created) {
+        await storage.writeMemoryFrontmatter(
+          created,
+          {
+            status: "pending_review",
+            updated: (/* @__PURE__ */ new Date()).toISOString()
+          },
+          {
+            actor: explicitCaptureActor(source),
+            reasonCode: reason,
+            ruleVersion: "explicit-capture.v1"
+          }
+        );
+      }
+    } finally {
+    }
+    const event = {
+      eventId: `mle-${randomUUID()}`,
+      memoryId: id,
+      eventType: "explicit_capture_queued",
+      timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+      actor: explicitCaptureActor(source),
+      reasonCode: reason,
+      ruleVersion: "explicit-capture.v1"
+    };
+    await storage.appendMemoryLifecycleEvents([event]);
+    return { id };
+  };
+  if (typeof storage.withTombstoneBlockedCaptureWriteLock !== "function") return await queue();
+  return await storage.withTombstoneBlockedCaptureWriteLock(queue, lockIdentity);
+}
+function shouldSkipImplicitExtraction(cfg) {
+  return cfg.captureMode === "explicit";
+}
+function shouldProcessInlineExplicitCapture(cfg) {
+  return cfg.captureMode !== "implicit";
+}
+var DEFAULT_INLINE_CAPTURE_DEDUPE_KEY_LIMIT = 1024;
+var InlineExplicitCaptureProcessor = class {
+  constructor(orchestrator, options = {}) {
+    this.orchestrator = orchestrator;
+    this.options = options;
+    const requestedLimit = options.maxDedupeKeys ?? DEFAULT_INLINE_CAPTURE_DEDUPE_KEY_LIMIT;
+    this.maxDedupeKeys = Number.isFinite(requestedLimit) && requestedLimit > 0 ? Math.max(1, Math.floor(requestedLimit)) : DEFAULT_INLINE_CAPTURE_DEDUPE_KEY_LIMIT;
+  }
+  orchestrator;
+  options;
+  observedKeys = /* @__PURE__ */ new Set();
+  observedKeyOrder = [];
+  maxDedupeKeys;
+  processingTails = /* @__PURE__ */ new Map();
+  enqueue(key, operation) {
+    const previous = this.processingTails.get(key) ?? Promise.resolve();
+    let release;
+    const current = new Promise((resolve) => {
+      release = resolve;
+    });
+    this.processingTails.set(key, current);
+    return previous.then(operation).finally(() => {
+      if (this.processingTails.get(key) === current) this.processingTails.delete(key);
+      release();
+    });
+  }
+  buildDedupeKeys(dedupeKeys, input, namespacePreResolved, fallbackReviewNamespace) {
+    let fallbackNamespace;
+    let effectiveNamespace = asTrimmed(input.namespace);
+    if (!namespacePreResolved) {
+      try {
+        effectiveNamespace = resolveExplicitCaptureNamespace(this.orchestrator, effectiveNamespace);
+      } catch {
+        fallbackNamespace = asTrimmed(fallbackReviewNamespace) ?? this.orchestrator.config.defaultNamespace;
+        effectiveNamespace = fallbackNamespace;
+      }
+    }
+    const requestedNamespace = asTrimmed(input.namespace);
+    const namespaceScope = fallbackNamespace === void 0 ? effectiveNamespace ?? this.orchestrator.config.defaultNamespace : `${fallbackNamespace}\0requested:${requestedNamespace ?? ""}`;
+    const sourceConnectorScope = asTrimmed(input.sourceConnector) ?? "";
+    const deliveryKeys = Array.from(
+      new Set((dedupeKeys ?? []).map((key) => asTrimmed(key)).filter((key) => key !== void 0))
+    ).sort();
+    const noteHash = createHash("sha256").update(
+      JSON.stringify({
+        content: normalizeExplicitCaptureContent(input.content),
+        category: asTrimmed(input.category) ?? "fact"
+      })
+    ).digest("hex");
+    const validationTags = Array.from(
+      new Set((input.tags ?? []).map((tag) => asTrimmed(tag)).filter((tag) => tag !== void 0))
+    ).sort();
+    const validationHash = createHash("sha256").update(
+      JSON.stringify({
+        content: asTrimmed(input.content) ?? "",
+        category: asTrimmed(input.category) ?? "fact",
+        confidence: input.confidence === void 0 ? "default" : Number.isFinite(input.confidence) ? input.confidence : "invalid",
+        namespace: asTrimmed(input.namespace),
+        tags: validationTags,
+        entityRef: asTrimmed(input.entityRef),
+        sourceReason: asTrimmed(input.sourceReason),
+        ttl: asTrimmed(input.ttl),
+        deliveryKeys
+      })
+    ).digest("hex");
+    const identityPrefix = `${namespaceScope}\0${sourceConnectorScope}\0`;
+    const fallbackKey = `${identityPrefix}fallback:inline-memory-note:${noteHash}`;
+    return {
+      replayKeys: deliveryKeys.length > 0 ? deliveryKeys.map((key) => `${identityPrefix}${key}:inline-memory-note:${noteHash}`) : [fallbackKey],
+      validationFailureKey: `${identityPrefix}validation:inline-memory-note:${validationHash}`
+    };
+  }
+  isNamespacePolicyAuthorized(namespace) {
+    try {
+      resolveExplicitCaptureNamespace(this.orchestrator, namespace);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  resolveReviewFallbackNamespace(request, input) {
+    if (request.namespacePreResolved === true || this.isNamespacePolicyAuthorized(input.namespace)) return void 0;
+    return request.reviewNamespacePreResolved === true ? asTrimmed(request.reviewNamespace) : this.orchestrator.config.defaultNamespace;
+  }
+  remember(keys) {
+    for (const key of keys) {
+      if (this.observedKeys.has(key)) continue;
+      this.observedKeys.add(key);
+      this.observedKeyOrder.push(key);
+    }
+    while (this.observedKeyOrder.length > this.maxDedupeKeys) {
+      const expired = this.observedKeyOrder.shift();
+      if (expired) this.observedKeys.delete(expired);
+    }
+  }
+  async processNote(request, input, replayKeys, validationFailureKey) {
+    const serializationKey = replayKeys.at(-1) ?? validationFailureKey;
+    return this.enqueue(serializationKey, async () => {
+      if (replayKeys.some((key) => this.observedKeys.has(key)) || this.observedKeys.has(validationFailureKey)) {
+        return { processed: 0, accepted: 0, queued: 0, duplicates: 1, failed: 0 };
+      }
+      const classifyPersisted = (persisted) => {
+        this.remember(replayKeys);
+        if (persisted.duplicateOf) {
+          return { processed: 1, accepted: 0, queued: 0, duplicates: 1, failed: 0 };
+        }
+        if (persisted.tombstoneBlocked) {
+          this.orchestrator.requestQmdMaintenanceForTool("inline.memory_note.review");
+          return { processed: 1, accepted: 0, queued: 1, duplicates: 0, failed: 0 };
+        }
+        this.orchestrator.requestQmdMaintenanceForTool("inline.memory_note");
+        return { processed: 1, accepted: 1, queued: 0, duplicates: 0, failed: 0 };
+      };
+      const persistCandidate = async (candidate2) => classifyPersisted(await persistExplicitCapture(this.orchestrator, candidate2, "inline"));
+      let validationSucceeded = false;
+      let candidate;
+      try {
+        candidate = validateExplicitCaptureInput(input);
+        if (request.namespacePreResolved === true) candidate.namespacePreResolved = true;
+        validationSucceeded = true;
+        return await persistCandidate(candidate);
+      } catch (error) {
+        let captureError = error;
+        if (validationSucceeded && candidate && isTombstoneBlockedCaptureWriteLockBusy(error)) {
+          try {
+            return await persistCandidate(candidate);
+          } catch (retryError) {
+            if (isTombstoneBlockedCaptureWriteLockBusy(retryError)) {
+              log.warn(
+                `explicit inline capture deferred after tombstone write lock contention: ${normalizeExplicitCaptureError(retryError)}`
+              );
+              return { processed: 0, accepted: 0, queued: 0, duplicates: 0, failed: 1 };
+            }
+            captureError = retryError;
+          }
+        }
+        if (validationSucceeded && !isUnsupportedExplicitCaptureNamespaceError(captureError)) {
+          log.warn(`explicit inline capture persistence failed: ${normalizeExplicitCaptureError(captureError)}`);
+          return { processed: 0, accepted: 0, queued: 0, duplicates: 0, failed: 1 };
+        }
+        const queueInput = request.namespacePreResolved === true ? { ...input, namespacePreResolved: true } : input;
+        const reviewNamespace = this.resolveReviewFallbackNamespace(request, input);
+        try {
+          const review = await queueExplicitCaptureForReview(
+            this.orchestrator,
+            queueInput,
+            "inline",
+            captureError,
+            reviewNamespace ? { resolvedNamespace: reviewNamespace } : void 0
+          );
+          this.remember(validationSucceeded ? replayKeys : [validationFailureKey]);
+          if (review.duplicateOf) {
+            return { processed: 1, accepted: 0, queued: 0, duplicates: 1, failed: 0 };
+          }
+          this.orchestrator.requestQmdMaintenanceForTool("inline.memory_note.review");
+          return { processed: 1, accepted: 0, queued: 1, duplicates: 0, failed: 0 };
+        } catch (queueError) {
+          log.warn(
+            `explicit inline capture rejected: ${normalizeExplicitCaptureError(captureError)}; review queue fallback failed: ${normalizeExplicitCaptureError(queueError)}`
+          );
+          return { processed: 0, accepted: 0, queued: 0, duplicates: 0, failed: 1 };
+        }
+      }
+    });
+  }
+  async process(request) {
+    if (!shouldProcessInlineExplicitCapture({ captureMode: request.captureMode })) {
+      return { content: request.content, processed: 0, accepted: 0, queued: 0, duplicates: 0, failed: 0 };
+    }
+    if (request.namespacePreResolved === true && !asTrimmed(request.namespace)) {
+      throw new Error("namespacePreResolved requires a resolved namespace");
+    }
+    if (request.reviewNamespacePreResolved === true && !asTrimmed(request.reviewNamespace)) {
+      throw new Error("reviewNamespacePreResolved requires a resolved namespace");
+    }
+    const notes = parseInlineExplicitCaptureCandidates(request.content);
+    const content = hasInlineExplicitCaptureMarkup(request.content) ? stripInlineExplicitCaptureNotes(request.content) : request.content;
+    const sourceConnector = asTrimmed(request.sourceConnector) ?? asTrimmed(this.options.sourceConnector);
+    let processed = 0;
+    let accepted = 0;
+    let queued = 0;
+    let duplicates = 0;
+    let failed = 0;
+    for (const note of notes) {
+      const input = {
+        ...note,
+        ...request.namespace !== void 0 ? { namespace: request.namespace } : {},
+        ...sourceConnector ? { sourceConnector } : {}
+      };
+      const { replayKeys, validationFailureKey } = this.buildDedupeKeys(
+        request.dedupeKeys,
+        input,
+        request.namespacePreResolved === true,
+        this.resolveReviewFallbackNamespace(request, input)
+      );
+      const result = await this.processNote(request, input, replayKeys, validationFailureKey);
+      processed += result.processed;
+      accepted += result.accepted;
+      queued += result.queued;
+      duplicates += result.duplicates;
+      failed += result.failed;
+    }
+    return { content, processed, accepted, queued, duplicates, failed };
+  }
+};
+
+export {
+  parseInlineExplicitCaptureNotes,
+  hasInlineExplicitCaptureMarkup,
+  stripInlineExplicitCaptureNotes,
+  validateExplicitCaptureInput,
+  persistExplicitCapture,
+  queueExplicitCaptureForReview,
+  shouldSkipImplicitExtraction,
+  shouldProcessInlineExplicitCapture,
+  InlineExplicitCaptureProcessor
+};
+//# sourceMappingURL=chunk-PH3ZWL3W.js.map