@remnic/core 9.63.1 → 9.63.3

package/dist/chunk-DJ7HMNSL.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/recall-tokenization.ts"],"sourcesContent":["export interface NormalizeRecallTokenOptions {\n  minTokenLength?: number;\n}\n\nconst DEFAULT_RECALL_STOP_WORDS = [\"the\", \"and\", \"for\", \"with\", \"from\", \"into\", \"that\", \"this\", \"why\", \"did\"];\n\nexport function isUnsegmentableRecallChar(char: string): boolean {\n  if (char === \"ー\" || char === \"ｰ\") return true;\n  return /[\\p{Script=Han}\\p{Script=Hiragana}\\p{Script=Katakana}]/u.test(char);\n}\n\nfunction isRecallCombiningMark(char: string): boolean {\n  return /\\p{M}/u.test(char);\n}\n\nfunction buildRecallStopWords(extraStopWords: string[]): Set<string> {\n  return new Set([...DEFAULT_RECALL_STOP_WORDS, ...extraStopWords.map((word) => word.toLowerCase())]);\n}\n\nfunction shouldKeepRecallToken(token: string, minTokenLength: number, stopWords: Set<string>): boolean {\n  if (stopWords.has(token)) return false;\n  if (token.length >= minTokenLength) return true;\n  const hasNonAsciiCodepoint = [...token].some((ch) => (ch.codePointAt(0) ?? 0) > 0x7f);\n  return token.length >= 2 && hasNonAsciiCodepoint && /\\p{L}/u.test(token);\n}\n\nexport function expandUnsegmentableRecallNGrams(segment: string): string[] {\n  const chars = [...segment].filter((ch) => /[\\p{L}\\p{N}\\p{M}]/u.test(ch) || isUnsegmentableRecallChar(ch));\n  const tokens: string[] = [];\n  for (const ch of chars) {\n    tokens.push(ch);\n  }\n  for (const size of [2, 3, 4]) {\n    if (chars.length < size) continue;\n    for (let index = 0; index <= chars.length - size; index += 1) {\n      tokens.push(chars.slice(index, index + size).join(\"\"));\n    }\n  }\n  if (chars.length > 3) {\n    tokens.push(chars.join(\"\"));\n  }\n  return tokens;\n}\n\nfunction addUnsegmentableRecallSegment(tokens: Set<string>, segment: string, stopWords: Set<string>): void {\n  for (const token of expandUnsegmentableRecallNGrams(segment)) {\n    if (!stopWords.has(token)) tokens.add(token);\n  }\n}\n\nfunction isUnsegmentableRecallToken(token: string): boolean {\n  const chars = [...token].filter((ch) => /[\\p{L}\\p{N}\\p{M}]/u.test(ch) || isUnsegmentableRecallChar(ch));\n  return (\n    chars.length > 0 &&\n    chars.some(isUnsegmentableRecallChar) &&\n    chars.every((ch) => isUnsegmentableRecallChar(ch) || isRecallCombiningMark(ch))\n  );\n}\n\nfunction addBridgedUnsegmentableRecallSegments(tokens: Set<string>, cleaned: string, stopWords: Set<string>): void {\n  let segment = \"\";\n  const flushSegment = () => {\n    addUnsegmentableRecallSegment(tokens, segment, stopWords);\n    segment = \"\";\n  };\n\n  for (const token of cleaned.split(/\\s+/)) {\n    if (isUnsegmentableRecallToken(token)) {\n      segment += token;\n    } else {\n      flushSegment();\n    }\n  }\n  flushSegment();\n}\n\nexport function normalizeRecallTokenSet(\n  value: string,\n  extraStopWords: string[] = [],\n  options: NormalizeRecallTokenOptions = {}\n): Set<string> {\n  const minTokenLength = Math.max(1, Math.floor(options.minTokenLength ?? 3));\n  const stopWords = buildRecallStopWords(extraStopWords);\n  const cleaned = value\n    .toLowerCase()\n    .normalize(\"NFC\")\n    .replace(/[^\\p{L}\\p{N}\\p{M}\\u30fc\\uff70]+/gu, \" \")\n    .trim();\n  if (cleaned.length === 0) return new Set();\n\n  const tokens = new Set<string>();\n  addBridgedUnsegmentableRecallSegments(tokens, cleaned, stopWords);\n  for (const token of cleaned.split(/\\s+/)) {\n    if (!token) continue;\n    if ([...token].some(isUnsegmentableRecallChar)) {\n      let segment = \"\";\n      let unsegmentableSegment = \"\";\n      const flushSegment = () => {\n        if (shouldKeepRecallToken(segment, minTokenLength, stopWords)) {\n          tokens.add(segment);\n        }\n        segment = \"\";\n      };\n      const flushUnsegmentableSegment = () => {\n        addUnsegmentableRecallSegment(tokens, unsegmentableSegment, stopWords);\n        unsegmentableSegment = \"\";\n      };\n      for (const ch of token) {\n        if (!/[\\p{L}\\p{N}\\p{M}]/u.test(ch) && !isUnsegmentableRecallChar(ch)) continue;\n        if (isUnsegmentableRecallChar(ch)) {\n          flushSegment();\n          unsegmentableSegment += ch;\n        } else if (isRecallCombiningMark(ch)) {\n          if (unsegmentableSegment.length > 0) {\n            unsegmentableSegment += ch;\n          } else {\n            segment += ch;\n          }\n        } else {\n          flushUnsegmentableSegment();\n          segment += ch;\n        }\n      }\n      flushUnsegmentableSegment();\n      flushSegment();\n      continue;\n    }\n    if (shouldKeepRecallToken(token, minTokenLength, stopWords)) {\n      tokens.add(token);\n    }\n  }\n  return tokens;\n}\n\nexport function normalizeRecallTokens(value: string, extraStopWords: string[] = []): string[] {\n  return Array.from(normalizeRecallTokenSet(value, extraStopWords));\n}\n\nexport function countRecallTokenOverlap(\n  queryTokens: Set<string>,\n  value: string | undefined,\n  extraStopWords: string[] = []\n): number {\n  if (!value) return 0;\n  const tokens = normalizeRecallTokenSet(value, extraStopWords);\n  let matches = 0;\n  for (const token of queryTokens) {\n    if (tokens.has(token)) matches += 1;\n  }\n  return matches;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-PD6O7AXF.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/intent.ts"],"sourcesContent":["import type { MemoryIntent, RecallPlanMode } from \"./types.js\";\n\nconst GOAL_PATTERNS: Array<{ re: RegExp; goal: string }> = [\n  { re: /\\b(debug(?:s|ged|ging)?|fix(?:es|ed|ing)?|error(?:s)?|incident(?:s)?|outage(?:s)?|failure(?:s)?)\\b/i, goal: \"stabilize\" },\n  { re: /\\b(deploy(?:s|ed|ing)?|release(?:s|d|ing)?|ship(?:s|ped|ping)?|publish(?:es|ed|ing)?)\\b/i, goal: \"release\" },\n  { re: /\\b(plan(?:s|ned|ning)?|roadmap(?:s)?|strateg(?:y|ies)|design(?:s|ed|ing)?)\\b/i, goal: \"plan\" },\n  { re: /\\b(review(?:s|ed|ing)?|audit(?:s|ed|ing)?|security|hardening)\\b/i, goal: \"review\" },\n  { re: /\\b(sales|deal|customer|client|prospect)\\b/i, goal: \"close_deal\" },\n];\n\nconst ACTION_PATTERNS: Array<{ re: RegExp; action: string }> = [\n  { re: /\\b(review(?:s|ed|ing)?|audit(?:s|ed|ing)?|inspect(?:s|ed|ing)?|check(?:s|ed|ing)?)\\b/i, action: \"review\" },\n  { re: /\\b(plan(?:s|ned|ning)?|design(?:s|ed|ing)?|brainstorm(?:s|ed|ing)?|spec(?:s)?)\\b/i, action: \"plan\" },\n  { re: /\\b(implement(?:s|ed|ing)?|build(?:s|ing)?|built|code(?:s|d|ing)?|patch(?:es|ed|ing)?|fix(?:es|ed|ing)?)\\b/i, action: \"execute\" },\n  { re: /\\b(summariz(?:e|es|ed|ing)|recap(?:s|ped|ping)?|what happened|timeline)\\b/i, action: \"summarize\" },\n  { re: /\\b(decid(?:e|es|ed|ing)|decision(?:s)?|cho(?:ose|oses|osing)|chose|chosen)\\b/i, action: \"decide\" },\n];\n\nconst ENTITY_PATTERNS: Array<{ re: RegExp; entityType: string }> = [\n  { re: /\\b(pr|pull request|branch|repo|github|ci|workflow)\\b/i, entityType: \"repo\" },\n  { re: /\\b(discord|slack|channel|gateway|agent)\\b/i, entityType: \"ops\" },\n  { re: /\\b(customer|client|deal|lead|account)\\b/i, entityType: \"client\" },\n  { re: /\\b(model|llm|qmd|embedding|retrieval|memory)\\b/i, entityType: \"ai\" },\n  { re: /\\b(doc|readme|docs|changelog)\\b/i, entityType: \"docs\" },\n];\n\n/** User/agent is starting a hands-on task (issue #519 procedure recall gate). */\nconst TASK_INITIATION_RE =\n  /\\b(ship(?:ping|ped)?|deploy(?:ing|ed)?|release|publish|open(?:ing)?\\s+(?:a\\s+)?(?:pr|pull\\s+request)|merge(?:ing)?\\s+(?:the\\s+)?(?:pr|pull\\s+request)|run\\s+(?:the\\s+)?tests?|start(?:ing)?\\s+(?:work|on|the)|kick\\s+off|implement(?:ing|ed)?|let's\\s+(?:ship|deploy|release|publish|open|run|merge|implement|fix|patch|build|start|do|get|put|wire|hook|land|roll)\\b|going\\s+to\\s+(?:ship|deploy|release|open|run|merge)|need\\s+to\\s+(?:ship|deploy|run|open|merge|test)|fix(?:ing|ed)?\\s+(?:(?:the|a)\\s+)?(?:\\w+\\s+){0,4}(?:bug|build)\\b|patch(?:ing|ed)?|build(?:ing)?\\s+(?:and\\s+)?(?:ship|deploy))\\b/i;\n\nconst MEMORY_LOOKUP_RE =\n  /^(?:what|when|where|who|which|why|how|did)\\b/i;\n\nfunction normalizeTextInput(input: unknown): string {\n  return typeof input === \"string\" ? input : \"\";\n}\n\nexport function inferIntentFromText(text: string): MemoryIntent {\n  const safeText = normalizeTextInput(text);\n  const goal = GOAL_PATTERNS.find((p) => p.re.test(safeText))?.goal ?? \"unknown\";\n  const actionType = ACTION_PATTERNS.find((p) => p.re.test(safeText))?.action ?? \"unknown\";\n  const entityTypes = Array.from(\n    new Set(ENTITY_PATTERNS.filter((p) => p.re.test(safeText)).map((p) => p.entityType)),\n  );\n  const taskInitiation = !isMemoryLookupPrompt(safeText) && TASK_INITIATION_RE.test(safeText);\n\n  return {\n    goal,\n    actionType,\n    entityTypes,\n    taskInitiation,\n  };\n}\n\nexport function isTaskInitiationIntent(intent: MemoryIntent): boolean {\n  return intent.taskInitiation === true;\n}\n\nfunction isMemoryLookupPrompt(text: string): boolean {\n  const trimmed = text.trim();\n  return MEMORY_LOOKUP_RE.test(trimmed) ||\n    /\\b(?:previous|earlier|last week|last time|remember|recall|what did we decide)\\b/i.test(trimmed);\n}\n\nexport function intentCompatibilityScore(queryIntent: MemoryIntent, memoryIntent: MemoryIntent): number {\n  const queryHasSignal =\n    queryIntent.goal !== \"unknown\" ||\n    queryIntent.actionType !== \"unknown\" ||\n    queryIntent.entityTypes.length > 0;\n  const memoryHasSignal =\n    memoryIntent.goal !== \"unknown\" ||\n    memoryIntent.actionType !== \"unknown\" ||\n    memoryIntent.entityTypes.length > 0;\n  if (!queryHasSignal || !memoryHasSignal) return 0;\n\n  let score = 0;\n  if (\n    queryIntent.goal !== \"unknown\" &&\n    memoryIntent.goal !== \"unknown\" &&\n    queryIntent.goal === memoryIntent.goal\n  ) {\n    score += 0.5;\n  }\n  if (\n    queryIntent.actionType !== \"unknown\" &&\n    memoryIntent.actionType !== \"unknown\" &&\n    queryIntent.actionType === memoryIntent.actionType\n  ) {\n    score += 0.3;\n  }\n\n  const overlap = queryIntent.entityTypes.filter((et) => memoryIntent.entityTypes.includes(et)).length;\n  if (overlap > 0) {\n    const denom = Math.max(queryIntent.entityTypes.length, memoryIntent.entityTypes.length, 1);\n    score += 0.2 * (overlap / denom);\n  }\n\n  return Math.max(0, Math.min(1, score));\n}\n\nexport function planRecallMode(prompt: string): RecallPlanMode {\n  const p = normalizeTextInput(prompt).trim();\n  let ackCandidate = p;\n  while (ackCandidate.length > 0) {\n    const ch = ackCandidate.charCodeAt(ackCandidate.length - 1);\n    const isDigit = ch >= 48 && ch <= 57;\n    const isUpper = ch >= 65 && ch <= 90;\n    const isLower = ch >= 97 && ch <= 122;\n    // Strip any trailing non-alphanumeric noise (punctuation/emojis/symbols).\n    if (isDigit || isUpper || isLower) break;\n    ackCandidate = ackCandidate.slice(0, -1);\n  }\n  ackCandidate = ackCandidate.trim();\n  if (p.length === 0) return \"no_recall\";\n\n  if (/\\b(timeline|sequence|history|what happened|chain of events|root cause)\\b/i.test(p)) {\n    return \"graph_mode\";\n  }\n\n  // Reserve no_recall for low-information acknowledgements; avoid broad regressions.\n  if (\n    p.length <= 18 &&\n    /^(ok|okay|kk|thanks|thx|got it|sounds good|yep|yes|nope|no|done|cool|works)$/i.test(ackCandidate)\n  ) {\n    return \"no_recall\";\n  }\n\n  // Full recall for prompts that are explicitly memory-seeking or analytical questions.\n  if (\n    /\\b(previous|earlier|remember|last time|did we|what did we decide|context|summarize|summary|recap|key points|decision)\\b/i.test(p) ||\n    /\\?$/.test(p) ||\n    /^(what|why|how|when|where|who|which)\\b/i.test(p.toLowerCase())\n  ) {\n    return \"full\";\n  }\n\n  // Minimal for short, non-question operational directives to keep latency/tokens down.\n  if (\n    p.length <= 100 &&\n    /^(check|reload|restart|run|verify|show|status|sync|update|open|close|set|enable|disable|fix|patch)\\b/i.test(p)\n  ) {\n    return \"minimal\";\n  }\n\n  return \"full\";\n}\n\nexport function hasBroadGraphIntent(prompt: string): boolean {\n  const p = normalizeTextInput(prompt).trim().toLowerCase();\n  if (!p) return false;\n  return /\\b(what changed|how did we get here|why did this happen|what led to|cause chain|dependency chain|regression chain|failure chain)\\b/i.test(\n    p,\n  );\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-XPRJSHNI.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../src/retrieval-agents.ts"],"sourcesContent":["/**\n * Parallel Specialized Retrieval (v9.1 — ASMR-inspired)\n *\n * Replaces single-pass hybrid search with three parallel specialized agents:\n *\n *   1. DirectFactAgent  — entity-first lookup via entity filename index (<5ms)\n *   2. ContextualAgent  — existing hybridSearch (same cost as current single-pass)\n *   3. TemporalAgent    — temporal index prefilter + recency scoring (<10ms)\n *\n * All agents run via Promise.all(), so total latency = max(agents), not sum.\n * No new LLM inference is introduced — agents reuse existing search primitives.\n *\n * Graceful degradation: any agent error/timeout does not block the others.\n *\n * References:\n *   - Supermemory ASMR: https://blog.supermemory.ai/...\n *   - Spec: docs/ideas/parallel-specialized-retrieval.md\n */\n\nimport path from \"node:path\";\nimport { lstat, readdir, readFile, realpath, stat } from \"node:fs/promises\";\nimport { log } from \"./logger.js\";\nimport type { QmdSearchResult } from \"./types.js\";\nimport type { QmdClient } from \"./qmd.js\";\nimport { isTemporalQuery, recencyWindowBoundsFromPrompt } from \"./temporal-index.js\";\nimport { isAbortError } from \"./abort-error.js\";\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\nexport type SearchAgentSource = \"direct\" | \"contextual\" | \"temporal\";\n\nexport interface ParallelSearchResult extends QmdSearchResult {\n  /** Which retrieval agent produced this result. */\n  agentSource: SearchAgentSource;\n}\n\n/** Source-based weights applied during merge. Higher = higher confidence/precision. */\nexport const PARALLEL_AGENT_WEIGHTS: Record<SearchAgentSource, number> = {\n  direct: 1.0, // entity-first: high precision\n  temporal: 0.85, // recency-boosted: relevant but broader\n  contextual: 0.7, // semantic: broadest, lower precision\n};\n\n// ─── Query classification ────────────────────────────────────────────────────\n\n/**\n * Decide whether a given agent should run for this query.\n * Agent 1 (direct) is the only one that may be skipped — when the query\n * contains no proper-noun-like tokens, entity lookups will return nothing.\n * Agents 2 (contextual) and 3 (temporal) always run.\n */\nexport function shouldRunAgent(\n  agent: SearchAgentSource,\n  query: string,\n  knownEntityCount: number,\n): boolean {\n  switch (agent) {\n    case \"direct\":\n      // Skip only if query has no word-like tokens at all. Both capitalized and\n      // lowercase entity names are stored (normalizeEntityName lowercases them),\n      // so gating on capitalization would silently skip most real entity lookups.\n      return knownEntityCount > 0 || /\\b\\w{2,}/.test(query);\n    case \"temporal\":\n      // Only run temporal agent when the query actually asks about a time window.\n      // Running it for every query injects recency bias into semantic searches.\n      return isTemporalQuery(query);\n    case \"contextual\":\n      return true;\n    default:\n      return true;\n  }\n}\n\n// ─── Helpers ─────────────────────────────────────────────────────────────────\n\nfunction tokenize(value: string): string[] {\n  return value\n    .toLowerCase()\n    .replace(/[^a-z0-9]+/g, \" \")\n    .trim()\n    .split(/\\s+/)\n    .filter((t) => t.length >= 2);\n}\n\nfunction overlapScore(queryTokens: string[], candidateTokens: string[]): number {\n  if (queryTokens.length === 0 || candidateTokens.length === 0) return 0;\n  const candidateSet = new Set(candidateTokens);\n  const hits = queryTokens.filter((t) => candidateSet.has(t)).length;\n  return hits / Math.max(queryTokens.length, candidateTokens.length);\n}\n\nasync function resolveContainedRegularFile(\n  memoryDir: string,\n  candidatePath: string,\n  canonicalRoot?: string,\n): Promise<string | null> {\n  try {\n    const root = canonicalRoot ?? await realpath(memoryDir);\n    const absolute = path.isAbsolute(candidatePath)\n      ? path.resolve(candidatePath)\n      : path.resolve(memoryDir, candidatePath);\n    const entryStat = await lstat(absolute);\n    if (entryStat.isSymbolicLink()) return null;\n    const fileStat = await stat(absolute);\n    if (!fileStat.isFile()) return null;\n    const canonical = await realpath(absolute);\n    if (canonical !== root && !canonical.startsWith(root + path.sep)) return null;\n    return absolute;\n  } catch {\n    return null;\n  }\n}\n\n// ─── Agent 1: Direct Facts ───────────────────────────────────────────────────\n\n/**\n * Direct Facts Agent — entity-first retrieval.\n *\n * Reads entity filenames from the entities directory and scores them by\n * keyword overlap with the query. Returns matching entity file paths as\n * QmdSearchResult[]. Zero LLM inference; pure file I/O.\n *\n * Cost: readdir on entities/ + filename scoring. Typically <5ms.\n *\n */\n// Agents scan one namespace storage dir and return absolute paths. Contextual\n// fanout hits are also absolute (globally-unique identity), so we keep the\n// agent path absolute and only stamp the owning namespace here — that carries\n// the namespace through merge/tracking without re-deriving it (#2020). No-op\n// without a resolver.\nfunction namespaceRelativeResult(\n  result: ParallelSearchResult,\n  _memoryDir: string,\n  namespaceFromPath?: (p: string) => string,\n): ParallelSearchResult {\n  if (!namespaceFromPath || !result.path || result.namespace) return result;\n  return { ...result, namespace: namespaceFromPath(result.path) };\n}\n\nexport async function runDirectAgent(\n  query: string,\n  memoryDir: string,\n  maxResults = 10,\n  namespaceFromPath?: (p: string) => string,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const canonicalRoot = await realpath(memoryDir);\n    const entitiesDir = path.join(memoryDir, \"entities\");\n    let entries: string[];\n    try {\n      entries = await readdir(entitiesDir);\n    } catch {\n      return []; // entities dir missing or unreadable — not an error\n    }\n\n    const queryTokens = tokenize(query);\n    if (queryTokens.length === 0) return [];\n\n    const results: ParallelSearchResult[] = [];\n    for (const entry of entries) {\n      if (!entry.endsWith(\".md\")) continue;\n\n      // Filename tokens: split on hyphens (normalizeEntityName uses hyphens)\n      const nameWithoutExt = entry.slice(0, -3);\n      const entityTokens = nameWithoutExt.split(\"-\").filter((t) => t.length >= 2).map((t) => t.toLowerCase());\n\n      const score = overlapScore(queryTokens, entityTokens);\n      if (score <= 0) continue;\n\n      const fullPath = path.join(entitiesDir, entry);\n      const safePath = await resolveContainedRegularFile(memoryDir, fullPath, canonicalRoot);\n      if (!safePath) continue;\n\n      results.push(\n        namespaceRelativeResult(\n          {\n            docid: nameWithoutExt,\n            path: safePath,\n            snippet: \"\", // populated by augmentWithDirectAndTemporal after merge\n            score,\n            transport: \"scoped_prefilter\",\n            agentSource: \"direct\",\n          },\n          memoryDir,\n          namespaceFromPath,\n        ),\n      );\n    }\n\n    return results\n      .sort((a, b) => b.score - a.score)\n      .slice(0, maxResults);\n  } catch (err) {\n    log.debug(`DirectFactAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Agent 3: Temporal ───────────────────────────────────────────────────────\n\n/**\n * Temporal Agent — recency-focused retrieval.\n *\n * Uses the temporal index (index_time.json) to find memories from the\n * recent time window derived from the query (default: last 7 days).\n * Combines recency decay with query-filename token overlap so results stay\n * relevant to the query content, not just recency. Zero LLM inference; File I/O + math.\n *\n * Cost: read index_time.json + date range scan. Typically <10ms.\n */\nexport async function runTemporalAgent(\n  query: string,\n  memoryDir: string,\n  maxResults = 20,\n  /** Optional candidate set from query-aware prefilter. Applied BEFORE the top-K cap so\n   * in-scope entries are not displaced by newer out-of-scope entries. */\n  candidatePaths?: Set<string> | null,\n  namespaceFromPath?: (p: string) => string,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const canonicalRoot = await realpath(memoryDir);\n    // Read index_time.json once — used for both date-range filtering and recency scoring.\n    let dateIndex: Record<string, string[]> = {};\n    try {\n      const indexPath = path.join(memoryDir, \"state\", \"index_time.json\");\n      const raw = await readFile(indexPath, \"utf-8\");\n      const parsed = JSON.parse(raw) as { dates?: Record<string, string[]> };\n      dateIndex = parsed.dates ?? {};\n    } catch {\n      return []; // Index missing or unreadable — nothing to return\n    }\n\n    // Derive both window edges from the same function so fromDate/toDate always use\n    // consistent pattern-matching and priority ordering.\n    const { fromDate, toDate } = recencyWindowBoundsFromPrompt(query);\n\n    // Build path → date map, filtering to the recency window in one pass.\n    // Apply candidatePaths here (before scoring + top-K) so in-scope entries are\n    // not displaced by newer out-of-scope entries at the slice boundary.\n    const pathToDate = new Map<string, string>();\n    for (const [date, datePaths] of Object.entries(dateIndex)) {\n      // toDate is an exclusive upper bound (the first day NOT included in the window).\n      // e.g. \"3 days ago\" → fromDate=\"2026-03-12\", toDate=\"2026-03-13\" → only includes 2026-03-12.\n      if (date >= fromDate && date < toDate) {\n        for (const p of datePaths) {\n          // Skip paths excluded by the query-aware prefilter scope\n          if (candidatePaths && !candidatePaths.has(p)) continue;\n          if (!pathToDate.has(p)) pathToDate.set(p, date);\n        }\n      }\n    }\n\n    if (pathToDate.size === 0) return [];\n\n    const todayMs = Date.now();\n\n    // Extract non-temporal topic tokens for tag-based relevance boost.\n    // Purely temporal words (dates, relative time) and common stopwords are stripped\n    // so the signal reflects the subject the user is asking about (e.g. \"auth\" in\n    // \"what changed in auth last week\"), not the time window itself.\n    const TEMPORAL_STOPWORDS = new Set([\n      \"today\", \"yesterday\", \"this\", \"last\", \"week\", \"month\", \"year\",\n      \"morning\", \"night\", \"now\", \"earlier\", \"since\", \"after\", \"before\",\n      \"ago\", \"hours\", \"days\", \"weeks\", \"months\",\n      \"january\", \"february\", \"march\", \"april\", \"may\", \"june\",\n      \"july\", \"august\", \"september\", \"october\", \"november\", \"december\",\n      \"monday\", \"tuesday\", \"wednesday\", \"thursday\", \"friday\", \"saturday\", \"sunday\",\n      \"what\", \"when\", \"where\", \"who\", \"why\", \"how\", \"the\", \"a\", \"an\",\n      \"and\", \"or\", \"in\", \"on\", \"at\", \"to\", \"of\", \"for\", \"with\", \"by\",\n      \"from\", \"changed\", \"happened\", \"was\", \"were\", \"is\", \"are\", \"did\",\n      \"about\", \"that\", \"have\", \"had\", \"has\", \"been\", \"any\", \"all\",\n    ]);\n    const topicTokens = tokenize(query).filter((t) => !TEMPORAL_STOPWORDS.has(t));\n\n    // Load tag index for topical scoring, in parallel with existence checks.\n    // Fail-open: if the tag index is unavailable, topicBoost = 0 and scores\n    // degrade gracefully to recency-only ordering (existing behaviour).\n    const entries = [...pathToDate.entries()];\n    const tagIndexPromise: Promise<Map<string, string[]>> = topicTokens.length > 0\n      ? readFile(path.join(memoryDir, \"state\", \"index_tags.json\"), \"utf-8\")\n          .then((raw) => {\n            const parsed = JSON.parse(raw) as { tags?: Record<string, { paths?: string[] } | string[]> };\n            const result = new Map<string, string[]>();\n            for (const [tag, node] of Object.entries(parsed.tags ?? {})) {\n              const tagPaths = Array.isArray(node) ? node : (node.paths ?? []);\n              for (const tp of tagPaths) {\n                const existing = result.get(tp);\n                if (existing) existing.push(tag);\n                else result.set(tp, [tag]);\n              }\n            }\n            return result;\n          })\n          .catch(() => new Map<string, string[]>())\n      : Promise.resolve(new Map<string, string[]>());\n\n    // Parallel: existence checks + tag index read.\n    const [safePathResults, pathToTags] = await Promise.all([\n      Promise.all(entries.map(([p]) => resolveContainedRegularFile(memoryDir, p, canonicalRoot))),\n      tagIndexPromise,\n    ]);\n\n    const results: ParallelSearchResult[] = [];\n\n    for (let i = 0; i < entries.length; i++) {\n      const [p, dateStr] = entries[i];\n      const safePath = safePathResults[i];\n      if (!safePath) continue; // skip stale or out-of-root index entry\n      const ageMs = todayMs - new Date(dateStr).getTime();\n      const ageDays = ageMs / 86_400_000;\n      // Exponential recency decay with half-life of ~30 days.\n      // score ≈ 1.0 at day 0, ≈ 0.79 at 7 days, ≈ 0.36 at 30 days, ≈ 0.13 at 60 days.\n      const recencyScore = Math.exp(-ageDays / 30);\n\n      // Topical boost: fraction of non-temporal query tokens matched by this file's tags.\n      // Adds up to +30% on recency score for a perfect tag match; zero when query is\n      // purely temporal (no topic tokens) or the tag index doesn't cover the file.\n      let topicBoost = 0;\n      if (topicTokens.length > 0) {\n        const tags = pathToTags.get(p) ?? pathToTags.get(safePath);\n        if (tags && tags.length > 0) {\n          const tagSet = new Set(tags.flatMap((t) => tokenize(t)));\n          const hits = topicTokens.filter((t) => tagSet.has(t)).length;\n          topicBoost = hits / topicTokens.length;\n        }\n      }\n      const score = recencyScore * (1 + topicBoost * 0.3);\n\n      const baseName = path.basename(safePath, \".md\");\n\n      results.push(\n        namespaceRelativeResult(\n          {\n            docid: baseName,\n            path: safePath,\n            snippet: \"\", // populated by augmentWithDirectAndTemporal after merge\n            score,\n            transport: \"scoped_prefilter\",\n            agentSource: \"temporal\",\n          },\n          memoryDir,\n          namespaceFromPath,\n        ),\n      );\n    }\n\n    return results\n      .sort((a, b) => b.score - a.score)\n      .slice(0, maxResults);\n  } catch (err) {\n    log.debug(`TemporalAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Agent 2: Contextual ─────────────────────────────────────────────────────\n\n/**\n * Contextual Agent — broad semantic/hybrid search.\n *\n * Delegates to the existing hybridSearch (BM25 + vector). Same cost as the\n * current single-pass retrieval — this agent introduces no additional LLM calls.\n */\nexport async function runContextualAgent(\n  query: string,\n  qmd: QmdClient,\n  collection: string | undefined,\n  maxResults: number,\n  signal?: AbortSignal,\n): Promise<ParallelSearchResult[]> {\n  try {\n    const results = await qmd.hybridSearch(\n      query,\n      collection,\n      maxResults,\n      signal ? { signal } : undefined,\n    );\n    return results.map((r: QmdSearchResult) => ({ ...r, agentSource: \"contextual\" as const }));\n  } catch (err) {\n    if (isAbortError(err)) throw err;\n    log.debug(`ContextualAgent error: ${err}`);\n    return [];\n  }\n}\n\n// ─── Merge helper ─────────────────────────────────────────────────────────────\n\n/**\n * Merge results from multiple agents into a single deduplicated, weighted list.\n * Deduplicates by (namespace, path). Contextual results carry a `namespace`\n * (from the namespace-fanout search); direct/temporal results do not. When a\n * `resolveNamespace` resolver is supplied, the missing namespace is derived from\n * the result path the same canonical way the contextual side derives it\n * (`result.namespace ?? resolveNamespace(result.path)`), so a direct/temporal hit\n * and a contextual hit for the same (namespace, path) collapse to ONE merge key\n * instead of being injected and access-counted twice. Preserves snippets: if a\n * higher-scoring result lacks a snippet, the existing snippet from a lower-scoring\n * source is retained.\n */\nfunction mergeAgentResults(\n  allResults: ParallelSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxResults: number,\n  resolveNamespace?: (path: string) => string,\n): QmdSearchResult[] {\n  const merged = new Map<string, QmdSearchResult>();\n  for (const result of allResults) {\n    const namespace =\n      result.namespace ?? (resolveNamespace && result.path ? resolveNamespace(result.path) : undefined);\n    const key = `${namespace ?? \"\"}\\0${result.path || result.docid}`;\n    const weightedScore = result.score * weights[result.agentSource];\n    const existing = merged.get(key);\n    if (!existing || weightedScore > existing.score) {\n      merged.set(key, {\n        docid: result.docid,\n        path: result.path,\n        namespace,\n        // Preserve any snippet from the existing entry when the new one has none\n        snippet: result.snippet || existing?.snippet || \"\",\n        score: weightedScore,\n        transport: \"hybrid\",\n      });\n    }\n  }\n  return [...merged.values()]\n    .sort((a, b) => b.score - a.score)\n    .slice(0, maxResults);\n}\n\n/**\n * For merged results that have an empty snippet, attempt to read the first\n * 200 characters of the file as a fallback preview. Bounded to MAX_SNIPPET_READS\n * to cap I/O when many specialized-agent results are present.\n */\nconst SNIPPET_PREVIEW_CHARS = 200;\nconst MAX_SNIPPET_READS = 8;\n\n/** Strip YAML frontmatter (---...---) and return the document body. */\nfunction stripFrontmatter(raw: string): string {\n  if (!raw.startsWith(\"---\")) return raw;\n  const end = raw.indexOf(\"\\n---\", 3);\n  if (end === -1) return raw;\n  // Skip the closing \"---\" line and any leading blank lines\n  return raw.slice(end + 4).replace(/^\\n+/, \"\");\n}\n\nasync function populateEmptySnippets(results: QmdSearchResult[], memoryDir?: string): Promise<QmdSearchResult[]> {\n  const needsSnippet = results.filter((r) => !r.snippet && r.path);\n  if (needsSnippet.length === 0) return results;\n  const canonicalRoot = memoryDir ? await realpath(memoryDir).catch(() => null) : null;\n\n  const toRead = needsSnippet.slice(0, MAX_SNIPPET_READS);\n  const snippetMap = new Map<string, string>();\n\n  await Promise.all(\n    toRead.map(async (r) => {\n      try {\n        const safePath = canonicalRoot && r.path\n          ? await resolveContainedRegularFile(memoryDir!, r.path, canonicalRoot)\n          : null;\n        if (!safePath) return;\n        const raw = await readFile(safePath, \"utf-8\");\n        // Memory files start with YAML frontmatter — skip it so the snippet\n        // contains actual memory content, not metadata fields.\n        const body = stripFrontmatter(raw);\n        const preview = body.slice(0, SNIPPET_PREVIEW_CHARS).replace(/\\s+/g, \" \").trim();\n        if (preview) snippetMap.set(r.path, preview);\n      } catch {\n        // File unreadable — leave snippet empty\n      }\n    }),\n  );\n\n  if (snippetMap.size === 0) return results;\n  return results.map((r) => (r.path && snippetMap.has(r.path) ? { ...r, snippet: snippetMap.get(r.path)! } : r));\n}\n\n/**\n * Merge pre-computed direct and temporal agent results with contextual results.\n *\n * This is the merge half of augmentWithDirectAndTemporal. Expose it separately so\n * callers that started agents concurrently with the contextual search (for true\n * parallel latency) can merge after all three complete, without re-running agents.\n *\n * Handles the same cases as augmentWithDirectAndTemporal:\n * - Returns contextual unchanged (no reweighting) when both agents return nothing\n * - Applies maxResults cap in all paths\n * - Populates snippets for results discovered only by specialized agents\n */\nexport async function mergeWithAgentResults(\n  contextualResults: QmdSearchResult[],\n  directResults: ParallelSearchResult[],\n  temporalResults: ParallelSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxResults: number,\n  memoryDir?: string,\n  /** Optional namespace resolver. Direct/temporal results lack a namespace under\n   * namespace fanout; deriving it from the path lets them collapse onto the same\n   * merge key as the contextual result for the same (namespace, path). */\n  resolveNamespace?: (path: string) => string,\n): Promise<QmdSearchResult[]> {\n  if (directResults.length === 0 && temporalResults.length === 0) {\n    return contextualResults.slice(0, maxResults);\n  }\n\n  const contextualTagged: ParallelSearchResult[] = contextualResults.map((r) => ({\n    ...r,\n    agentSource: \"contextual\" as const,\n  }));\n\n  const merged = mergeAgentResults(\n    [...contextualTagged, ...directResults, ...temporalResults],\n    weights,\n    maxResults,\n    resolveNamespace,\n  );\n  return populateEmptySnippets(merged, memoryDir);\n}\n\n// ─── Augmentation helper (used by tests; orchestrator uses inline logic) ─────\n//\n// NOTE: This function passes the same `memoryDir` to both direct and temporal\n// agents. The orchestrator's inline implementation differs: it passes a\n// namespace-specific storage dir to runDirectAgent and the shared root to\n// runTemporalAgent. augmentWithDirectAndTemporal is intentionally simpler\n// (single-dir assumption) and is exercised by unit tests where both agents\n// operate on the same temporary directory.\n\n/**\n * Augment a set of contextual (hybridSearch) results with direct and temporal\n * agent results, returning a merged, deduplicated list.\n *\n * **Test helper** — production recall uses the inline orchestrator path which\n * passes namespace-specific directories to each agent. This function uses a\n * simplified single-directory contract suitable for unit tests.\n *\n * Direct and temporal agents run in parallel, then all three are merged with\n * configurable weights.\n *\n * Contextual weight is always applied to `contextualResults` so scoring is\n * consistent regardless of whether direct/temporal agents return anything.\n *\n * Snippets: snippets from contextual results are preserved during merge. For\n * results discovered only by direct/temporal agents (no contextual match),\n * the first ~200 chars of the file are read as a fallback preview so downstream\n * formatters and rerankers have content to work with, not just a path.\n */\nexport async function augmentWithDirectAndTemporal(\n  query: string,\n  memoryDir: string,\n  contextualResults: QmdSearchResult[],\n  weights: Record<SearchAgentSource, number>,\n  maxPerAgent: number,\n  maxResults: number,\n  /** Optional candidate set from query-aware prefilter (time/tag scoped). Agents' results are\n   * filtered to this set when provided so recall stays within the operator-specified scope. */\n  candidatePaths?: Set<string> | null,\n  /** Optional namespace resolver so direct/temporal results collapse onto the same\n   * (namespace, path) merge key as their contextual counterpart. */\n  resolveNamespace?: (path: string) => string,\n): Promise<QmdSearchResult[]> {\n  // maxPerAgent=0 is a hard disable: skip agents entirely and return contextual unchanged\n  if (maxPerAgent === 0) return contextualResults;\n\n  const knownEntityCount = (query.match(/\\b[A-Z][a-z]{1,}/g) ?? []).length;\n  const runDirect = shouldRunAgent(\"direct\", query, knownEntityCount);\n  const runTemporal = shouldRunAgent(\"temporal\", query, knownEntityCount);\n\n  const startMs = Date.now();\n  const [directResults, temporalResults] = await Promise.all([\n    runDirect\n      ? runDirectAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`augmentWithDirectAndTemporal: DirectAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runTemporal\n      // Pass candidatePaths so scope-filtering happens before the top-K cap inside runTemporalAgent,\n      // preventing out-of-scope newer entries from displacing in-scope ones at the slice boundary.\n      ? runTemporalAgent(query, memoryDir, maxPerAgent, candidatePaths).catch((err) => {\n        log.debug(`augmentWithDirectAndTemporal: TemporalAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n  ]);\n  const durationMs = Date.now() - startMs;\n\n  // Direct agent results (entities/) intentionally bypass candidatePaths.\n  //\n  // Why: candidatePaths is built from temporal + tag indexes, which never include\n  // entity files (entities/*.md). Applying the filter here would silently drop ALL\n  // direct-agent results for any scoped query, making the direct agent a no-op.\n  // Entity files are identified by filename matching (query tokens vs. entity name),\n  // so they are already query-scoped independently of the time/tag prefilter.\n  // Temporal results are scoped inside runTemporalAgent() before the top-K cap.\n  const scopedDirect = directResults;\n\n  // Tag contextual results with their source so they can participate in weighted merge.\n  // We do NOT cap contextual here: contextualResults comes from fetchQmdMemoryResultsWithArtifactTopUp\n  // which intentionally over-fetches so downstream phases (graph expansion, lifecycle filtering,\n  // reranking) can drop candidates. Capping before the merge would remove that headroom.\n  const contextualTagged: ParallelSearchResult[] = contextualResults.map((r) => ({\n    ...r,\n    agentSource: \"contextual\" as const,\n  }));\n\n  log.debug(\n    `augmentWithDirectAndTemporal: direct=${scopedDirect.length} temporal=${temporalResults.length} contextual=${contextualTagged.length} agentMs=${durationMs}ms`,\n  );\n\n  // If no specialized agents contributed anything (e.g. fresh setup without entities/ or temporal\n  // index), skip reweighting entirely — applying the contextual weight penalty with zero benefit\n  // would silently reduce every result score by ~30% compared to the non-augmented path.\n  if (scopedDirect.length === 0 && temporalResults.length === 0) {\n    return (contextualResults as QmdSearchResult[]).slice(0, maxResults);\n  }\n\n  // Merge all three; contextual first so its snippets are preserved when a higher-scoring\n  // direct/temporal result overrides the same path (see mergeAgentResults snippet logic).\n  // Note: maxPerAgent=0 is handled by the early-return guard above; we never reach here with 0.\n  const merged = mergeAgentResults(\n    [...contextualTagged, ...scopedDirect, ...temporalResults],\n    weights,\n    maxResults,\n    resolveNamespace,\n  );\n\n  // Populate snippets for results discovered only by direct/temporal (no contextual preview)\n  return populateEmptySnippets(merged, memoryDir);\n}\n\n// ─── Orchestrator ─────────────────────────────────────────────────────────────\n\nexport interface ParallelRetrievalOptions {\n  collection?: string;\n  maxResults?: number;\n  signal?: AbortSignal;\n  /** If true, skip the contextual agent (hybridSearch is already running externally). */\n  skipContextual?: boolean;\n  /** Max results per agent (capped before merge). */\n  maxResultsPerAgent?: number;\n  /** Override default agent weights. Falls back to PARALLEL_AGENT_WEIGHTS when absent. */\n  agentWeights?: Record<SearchAgentSource, number>;\n  /** Optional namespace resolver so direct/temporal results collapse onto the same\n   * (namespace, path) merge key as the contextual result for the same path. */\n  resolveNamespace?: (path: string) => string;\n}\n\n/**\n * Run parallel specialized retrieval agents and merge results.\n *\n * When `skipContextual` is true, only the direct and temporal agents run.\n * This is the intended usage inside the orchestrator, where hybridSearch\n * already runs as the primary search — we augment with the cheap extra agents.\n *\n * Total latency = max(agent_latencies), not sum.\n * Agent errors are isolated — others still return results.\n */\nexport async function parallelRetrieval(\n  query: string,\n  qmd: QmdClient,\n  memoryDir: string,\n  options: ParallelRetrievalOptions = {},\n): Promise<QmdSearchResult[]> {\n  const maxResults = options.maxResults ?? 20;\n  const maxPerAgent = options.maxResultsPerAgent ?? maxResults;\n  const startMs = Date.now();\n\n  // Rough entity detection: count proper-noun-like tokens in query\n  const knownEntityCount = (query.match(/\\b[A-Z][a-z]{1,}/g) ?? []).length;\n\n  const runDirect = shouldRunAgent(\"direct\", query, knownEntityCount);\n  const runTemporal = shouldRunAgent(\"temporal\", query, knownEntityCount);\n  const runContextual = !options.skipContextual && shouldRunAgent(\"contextual\", query, knownEntityCount);\n\n  const [directResults, temporalResults, contextualResults] = await Promise.all([\n    runDirect\n      ? runDirectAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`parallelRetrieval: DirectAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runTemporal\n      ? runTemporalAgent(query, memoryDir, maxPerAgent).catch((err) => {\n        log.debug(`parallelRetrieval: TemporalAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n    runContextual\n      ? runContextualAgent(query, qmd, options.collection, maxPerAgent, options.signal).catch((err) => {\n        if (isAbortError(err)) throw err;\n        log.debug(`parallelRetrieval: ContextualAgent failed — ${err}`);\n        return [] as ParallelSearchResult[];\n      })\n      : Promise.resolve([] as ParallelSearchResult[]),\n  ]);\n\n  const durationMs = Date.now() - startMs;\n  log.debug(\n    `parallelRetrieval: direct=${directResults.length} temporal=${temporalResults.length} contextual=${contextualResults.length} durationMs=${durationMs}ms`,\n  );\n\n  // Contextual results go first so their snippets are preserved when a higher-scoring\n  // direct/temporal result overrides the same path in mergeAgentResults.\n  const merged = mergeAgentResults(\n    [...contextualResults, ...directResults, ...temporalResults],\n    options.agentWeights ?? PARALLEL_AGENT_WEIGHTS,\n    maxResults,\n    options.resolveNamespace,\n  );\n  return populateEmptySnippets(merged, memoryDir);\n}\n"],"mappings":"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","names":[]}

package/dist/{access-service-DBpEnlzA.d.ts → access-service-M4LgO141.d.ts}

@@ -937,24 +937,24 @@ declare const SupportPassportDraftCardSchema: z.ZodEffects<z.ZodObject<{
     category: z.ZodEnum<["communication", "environment", "transitions", "sensory", "regulation", "interests", "other"]>;
     sourceMemoryIds: z.ZodArray<z.ZodString, "many">;
 }, "strict", z.ZodTypeAny, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
     sourceMemoryIds: string[];
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     statement: string;
 }, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
     sourceMemoryIds: string[];
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     statement: string;
 }>, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
     sourceMemoryIds: string[];
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     statement: string;
 }, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
     sourceMemoryIds: string[];
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     statement: string;
 }>;
 declare const SupportPassportDraftOutputSchema: z.ZodObject<{
@@ -964,38 +964,38 @@ declare const SupportPassportDraftOutputSchema: z.ZodObject<{
         category: z.ZodEnum<["communication", "environment", "transitions", "sensory", "regulation", "interests", "other"]>;
         sourceMemoryIds: z.ZodArray<z.ZodString, "many">;
     }, "strict", z.ZodTypeAny, {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
         sourceMemoryIds: string[];
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         statement: string;
     }, {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
         sourceMemoryIds: string[];
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         statement: string;
     }>, {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
         sourceMemoryIds: string[];
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         statement: string;
     }, {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
         sourceMemoryIds: string[];
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         statement: string;
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     cards: {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
         sourceMemoryIds: string[];
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         statement: string;
     }[];
 }, {
     cards: {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
         sourceMemoryIds: string[];
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         statement: string;
     }[];
 }>;
@@ -1005,34 +1005,34 @@ declare const SupportPassportDraftModelInputSchema: z.ZodEffects<z.ZodObject<{
         memoryId: z.ZodString;
         content: z.ZodString;
     }, "strict", z.ZodTypeAny, {
-        content: string;
         memoryId: string;
-    }, {
         content: string;
+    }, {
         memoryId: string;
+        content: string;
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
     memories: {
-        content: string;
         memoryId: string;
+        content: string;
     }[];
     consent: true;
 }, {
     memories: {
-        content: string;
         memoryId: string;
+        content: string;
     }[];
     consent: true;
 }>, {
     memories: {
-        content: string;
         memoryId: string;
+        content: string;
     }[];
     consent: true;
 }, {
     memories: {
-        content: string;
         memoryId: string;
+        content: string;
     }[];
     consent: true;
 }>;
@@ -1070,38 +1070,38 @@ declare const SupportPassportAnswerModelInputSchema: z.ZodObject<{
             category: z.ZodEnum<["communication", "environment", "transitions", "sensory", "regulation", "interests", "other"]>;
             updatedAt: z.ZodEffects<z.ZodString, string, string>;
         }, "strict", z.ZodTypeAny, {
-            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             title: string;
+            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             updatedAt: string;
             cardId: string;
             statement: string;
         }, {
-            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             title: string;
+            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             updatedAt: string;
             cardId: string;
             statement: string;
         }>, "many">;
     }, "strict", z.ZodTypeAny, {
-        expiresAt: string;
         schemaVersion: 1;
+        expiresAt: string;
         updatedAt: string;
         grantId: string;
         cards: {
-            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             title: string;
+            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             updatedAt: string;
             cardId: string;
             statement: string;
         }[];
     }, {
-        expiresAt: string;
         schemaVersion: 1;
+        expiresAt: string;
         updatedAt: string;
         grantId: string;
         cards: {
-            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             title: string;
+            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             updatedAt: string;
             cardId: string;
             statement: string;
@@ -1111,13 +1111,13 @@ declare const SupportPassportAnswerModelInputSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     question: string;
     guide: {
-        expiresAt: string;
         schemaVersion: 1;
+        expiresAt: string;
         updatedAt: string;
         grantId: string;
         cards: {
-            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             title: string;
+            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             updatedAt: string;
             cardId: string;
             statement: string;
@@ -1126,13 +1126,13 @@ declare const SupportPassportAnswerModelInputSchema: z.ZodObject<{
 }, {
     question: string;
     guide: {
-        expiresAt: string;
         schemaVersion: 1;
+        expiresAt: string;
         updatedAt: string;
         grantId: string;
         cards: {
-            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             title: string;
+            category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
             updatedAt: string;
             cardId: string;
             statement: string;
@@ -1249,18 +1249,18 @@ declare const SupportPassportCardSchema: z.ZodObject<{
     reviewBy: z.ZodEffects<z.ZodString, string, string>;
     revision: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
-    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
     title: string;
+    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
     reviewBy: string;
     revision: string;
 }, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
-    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
     title: string;
+    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
@@ -1277,36 +1277,36 @@ declare const SupportPassportCardListSchema: z.ZodEffects<z.ZodArray<z.ZodObject
     reviewBy: z.ZodEffects<z.ZodString, string, string>;
     revision: z.ZodString;
 }, "strict", z.ZodTypeAny, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
-    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
     title: string;
+    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
     reviewBy: string;
     revision: string;
 }, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
-    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
     title: string;
+    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
     reviewBy: string;
     revision: string;
 }>, "many">, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
-    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
     title: string;
+    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
     reviewBy: string;
     revision: string;
 }[], {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
-    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
     title: string;
+    status: "active" | "pending_review" | "rejected" | "superseded" | "archived";
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
@@ -1327,14 +1327,14 @@ declare const SupportPassportManualDraftInputSchema: z.ZodObject<{
     category: z.ZodEnum<["communication", "environment", "transitions", "sensory", "regulation", "interests", "other"]>;
     reviewBy: z.ZodEffects<z.ZodString, string, string>;
 }, "strict", z.ZodTypeAny, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     statement: string;
     reviewBy: string;
     principal: string;
 }, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     statement: string;
     reviewBy: string;
     principal: string;
@@ -1366,8 +1366,8 @@ declare const SupportPassportReplaceCardInputSchema: z.ZodObject<{
     category: z.ZodEnum<["communication", "environment", "transitions", "sensory", "regulation", "interests", "other"]>;
     reviewBy: z.ZodEffects<z.ZodString, string, string>;
 }, "strict", z.ZodTypeAny, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     cardId: string;
     statement: string;
     reviewBy: string;
@@ -1375,8 +1375,8 @@ declare const SupportPassportReplaceCardInputSchema: z.ZodObject<{
     expectedRevision: string;
     reasonCode?: string | undefined;
 }, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     cardId: string;
     statement: string;
     reviewBy: string;
@@ -1435,10 +1435,10 @@ declare const SupportPassportGrantStateSchema: z.ZodEffects<z.ZodObject<{
     expiresAt: z.ZodEffects<z.ZodString, string, string>;
     revokedAt: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
 }, "strict", z.ZodTypeAny, {
-    namespace: string;
+    schemaVersion: 1;
     createdAt: string;
     expiresAt: string;
-    schemaVersion: 1;
+    namespace: string;
     stateVersion: number;
     grantId: string;
     principalHash: string;
@@ -1450,10 +1450,10 @@ declare const SupportPassportGrantStateSchema: z.ZodEffects<z.ZodObject<{
     }[];
     revokedAt?: string | undefined;
 }, {
-    namespace: string;
+    schemaVersion: 1;
     createdAt: string;
     expiresAt: string;
-    schemaVersion: 1;
+    namespace: string;
     stateVersion: number;
     grantId: string;
     principalHash: string;
@@ -1465,10 +1465,10 @@ declare const SupportPassportGrantStateSchema: z.ZodEffects<z.ZodObject<{
     }[];
     revokedAt?: string | undefined;
 }>, {
-    namespace: string;
+    schemaVersion: 1;
     createdAt: string;
     expiresAt: string;
-    schemaVersion: 1;
+    namespace: string;
     stateVersion: number;
     grantId: string;
     principalHash: string;
@@ -1480,10 +1480,10 @@ declare const SupportPassportGrantStateSchema: z.ZodEffects<z.ZodObject<{
     }[];
     revokedAt?: string | undefined;
 }, {
-    namespace: string;
+    schemaVersion: 1;
     createdAt: string;
     expiresAt: string;
-    schemaVersion: 1;
+    namespace: string;
     stateVersion: number;
     grantId: string;
     principalHash: string;
@@ -1654,9 +1654,9 @@ declare const SupportPassportOwnerGrantSchema: z.ZodObject<{
     revokedAt: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
     status: z.ZodEnum<["active", "expired", "revoked"]>;
 }, "strict", z.ZodTypeAny, {
+    status: "active" | "expired" | "revoked";
     createdAt: string;
     expiresAt: string;
-    status: "active" | "expired" | "revoked";
     stateVersion: number;
     grantId: string;
     cards: {
@@ -1665,9 +1665,9 @@ declare const SupportPassportOwnerGrantSchema: z.ZodObject<{
     }[];
     revokedAt?: string | undefined;
 }, {
+    status: "active" | "expired" | "revoked";
     createdAt: string;
     expiresAt: string;
-    status: "active" | "expired" | "revoked";
     stateVersion: number;
     grantId: string;
     cards: {
@@ -1695,9 +1695,9 @@ declare const SupportPassportCreatedGrantSchema: z.ZodObject<{
         revokedAt: z.ZodOptional<z.ZodEffects<z.ZodString, string, string>>;
         status: z.ZodEnum<["active", "expired", "revoked"]>;
     }, "strict", z.ZodTypeAny, {
+        status: "active" | "expired" | "revoked";
         createdAt: string;
         expiresAt: string;
-        status: "active" | "expired" | "revoked";
         stateVersion: number;
         grantId: string;
         cards: {
@@ -1706,9 +1706,9 @@ declare const SupportPassportCreatedGrantSchema: z.ZodObject<{
         }[];
         revokedAt?: string | undefined;
     }, {
+        status: "active" | "expired" | "revoked";
         createdAt: string;
         expiresAt: string;
-        status: "active" | "expired" | "revoked";
         stateVersion: number;
         grantId: string;
         cards: {
@@ -1721,9 +1721,9 @@ declare const SupportPassportCreatedGrantSchema: z.ZodObject<{
 }, "strict", z.ZodTypeAny, {
     secret: string;
     grant: {
+        status: "active" | "expired" | "revoked";
         createdAt: string;
         expiresAt: string;
-        status: "active" | "expired" | "revoked";
         stateVersion: number;
         grantId: string;
         cards: {
@@ -1735,9 +1735,9 @@ declare const SupportPassportCreatedGrantSchema: z.ZodObject<{
 }, {
     secret: string;
     grant: {
+        status: "active" | "expired" | "revoked";
         createdAt: string;
         expiresAt: string;
-        status: "active" | "expired" | "revoked";
         stateVersion: number;
         grantId: string;
         cards: {
@@ -1754,14 +1754,14 @@ declare const SupportPassportPublicCardSchema: z.ZodObject<{
     category: z.ZodEnum<["communication", "environment", "transitions", "sensory", "regulation", "interests", "other"]>;
     updatedAt: z.ZodEffects<z.ZodString, string, string>;
 }, "strict", z.ZodTypeAny, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
 }, {
-    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     title: string;
+    category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
     updatedAt: string;
     cardId: string;
     statement: string;
@@ -1778,38 +1778,38 @@ declare const SupportPassportPublicGuideSchema: z.ZodObject<{
         category: z.ZodEnum<["communication", "environment", "transitions", "sensory", "regulation", "interests", "other"]>;
         updatedAt: z.ZodEffects<z.ZodString, string, string>;
     }, "strict", z.ZodTypeAny, {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         updatedAt: string;
         cardId: string;
         statement: string;
     }, {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         updatedAt: string;
         cardId: string;
         statement: string;
     }>, "many">;
 }, "strict", z.ZodTypeAny, {
-    expiresAt: string;
     schemaVersion: 1;
+    expiresAt: string;
     updatedAt: string;
     grantId: string;
     cards: {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         updatedAt: string;
         cardId: string;
         statement: string;
     }[];
 }, {
-    expiresAt: string;
     schemaVersion: 1;
+    expiresAt: string;
     updatedAt: string;
     grantId: string;
     cards: {
-        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         title: string;
+        category: "other" | "communication" | "environment" | "transitions" | "sensory" | "regulation" | "interests";
         updatedAt: string;
         cardId: string;
         statement: string;