@remnic/core 1.0.2 → 1.1.0

package/dist/chunk-EJI5XIBB.js

@@ -0,0 +1,232 @@
+// src/memory-extension-host/host-discovery.ts
+import { readdir, readFile, lstat, realpath } from "fs/promises";
+import path from "path";
+var REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT = 5e3;
+var MAX_EXAMPLES_PER_EXTENSION = 10;
+var VALID_SLUG_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;
+var VALID_MEMORY_TYPES = /* @__PURE__ */ new Set(["fact", "preference", "procedure", "reference"]);
+async function discoverMemoryExtensions(root, log) {
+  let rootStat;
+  try {
+    rootStat = await lstat(root);
+  } catch {
+    return [];
+  }
+  if (rootStat.isSymbolicLink()) {
+    let resolved;
+    try {
+      resolved = await realpath(root);
+    } catch {
+      return [];
+    }
+    let expectedParent;
+    try {
+      expectedParent = await realpath(path.resolve(path.dirname(root)));
+    } catch {
+      return [];
+    }
+    if (!resolved.startsWith(expectedParent + path.sep) && resolved !== expectedParent) {
+      log.warn?.(
+        `[memory-extensions] root "${root}" is a symlink resolving outside the expected parent directory, skipping`
+      );
+      return [];
+    }
+    try {
+      rootStat = await lstat(resolved);
+    } catch {
+      return [];
+    }
+  }
+  if (!rootStat.isDirectory()) {
+    return [];
+  }
+  let entries;
+  try {
+    entries = await readdir(root);
+  } catch {
+    return [];
+  }
+  const extensions = [];
+  for (const entry of entries) {
+    const entryPath = path.join(root, entry);
+    let entryStat;
+    try {
+      entryStat = await lstat(entryPath);
+    } catch {
+      continue;
+    }
+    if (entryStat.isSymbolicLink()) {
+      log.warn?.(
+        `[memory-extensions] skipping "${entry}": symlinks are not followed for security`
+      );
+      continue;
+    }
+    if (!entryStat.isDirectory()) continue;
+    if (!VALID_SLUG_RE.test(entry)) {
+      log.warn?.(
+        `[memory-extensions] skipping "${entry}": invalid slug (must be lowercase alphanumeric + hyphens, 1-64 chars)`
+      );
+      continue;
+    }
+    const instructionsPath = path.join(entryPath, "instructions.md");
+    if (await isSymlink(instructionsPath)) {
+      log.warn?.(
+        `[memory-extensions] skipping "${entry}": instructions.md is a symlink`
+      );
+      continue;
+    }
+    let instructions;
+    try {
+      instructions = await readFile(instructionsPath, "utf-8");
+    } catch {
+      log.warn?.(
+        `[memory-extensions] skipping "${entry}": missing instructions.md`
+      );
+      continue;
+    }
+    let schema;
+    const schemaPath = path.join(entryPath, "schema.json");
+    if (await isSymlink(schemaPath)) {
+      log.warn?.(
+        `[memory-extensions] "${entry}": schema.json is a symlink, ignoring schema`
+      );
+    } else {
+      try {
+        const schemaRaw = await readFile(schemaPath, "utf-8");
+        const parsed = JSON.parse(schemaRaw);
+        if (typeof parsed === "object" && parsed !== null && !Array.isArray(parsed)) {
+          schema = validateSchema(parsed);
+        } else {
+          log.warn?.(
+            `[memory-extensions] "${entry}": schema.json is not a valid object, ignoring schema`
+          );
+        }
+      } catch (err) {
+        if (isFileNotFoundError(err)) {
+        } else {
+          log.warn?.(
+            `[memory-extensions] "${entry}": malformed schema.json, ignoring schema`
+          );
+        }
+      }
+    }
+    const examplesPaths = [];
+    const examplesDir = path.join(entryPath, "examples");
+    try {
+      const exampleEntries = await readdir(examplesDir);
+      const mdFiles = exampleEntries.filter((f) => f.endsWith(".md")).sort().slice(0, MAX_EXAMPLES_PER_EXTENSION);
+      for (const f of mdFiles) {
+        examplesPaths.push(path.join(examplesDir, f));
+      }
+    } catch {
+    }
+    extensions.push({
+      name: entry,
+      root: entryPath,
+      instructionsPath,
+      instructions,
+      schema,
+      examplesPaths
+    });
+  }
+  extensions.sort((a, b) => {
+    if (a.name < b.name) return -1;
+    if (a.name > b.name) return 1;
+    return 0;
+  });
+  return extensions;
+}
+function validateSchema(raw) {
+  const memoryTypes = (() => {
+    if (!Array.isArray(raw.memoryTypes)) return void 0;
+    const valid = raw.memoryTypes.filter(
+      (t) => typeof t === "string" && VALID_MEMORY_TYPES.has(t)
+    );
+    return valid.length > 0 ? valid : void 0;
+  })();
+  const groupingHints = (() => {
+    if (!Array.isArray(raw.groupingHints)) return void 0;
+    const valid = raw.groupingHints.filter(
+      (h) => typeof h === "string" && h.length > 0
+    );
+    return valid.length > 0 ? valid : void 0;
+  })();
+  const version = typeof raw.version === "string" && raw.version.length > 0 ? raw.version : void 0;
+  return {
+    ...memoryTypes ? { memoryTypes } : {},
+    ...groupingHints ? { groupingHints } : {},
+    ...version ? { version } : {}
+  };
+}
+function isFileNotFoundError(err) {
+  return typeof err === "object" && err !== null && "code" in err && err.code === "ENOENT";
+}
+async function isSymlink(filePath) {
+  try {
+    const s = await lstat(filePath);
+    return s.isSymbolicLink();
+  } catch {
+    return false;
+  }
+}
+function resolveExtensionsRoot(config) {
+  if (config.memoryExtensionsRoot.length > 0) {
+    return config.memoryExtensionsRoot;
+  }
+  return path.join(path.dirname(config.memoryDir), "memory_extensions");
+}
+
+// src/memory-extension-host/render-extensions-block.ts
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function renderExtensionsBlock(extensions) {
+  if (extensions.length === 0) return "";
+  const header = `## Active memory extensions
+
+You are running with the following third-party memory extensions. Each
+extension's \`instructions.md\` tells you how to interpret memories that
+extension produces or curates.
+
+`;
+  let budget = REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT;
+  budget -= estimateTokens(header);
+  const inlined = [];
+  const omitted = [];
+  for (const ext of extensions) {
+    const block = `### remnic-extension/${ext.name}
+\`\`\`
+${ext.instructions}
+\`\`\`
+
+`;
+    const cost = estimateTokens(block);
+    if (cost <= budget) {
+      inlined.push(block);
+      budget -= cost;
+    } else {
+      omitted.push(ext.name);
+    }
+  }
+  let result = header;
+  result += inlined.join("");
+  if (omitted.length > 0) {
+    result += `> **Note:** ${omitted.length} extension(s) omitted due to token budget: ${omitted.join(", ")}
+`;
+  }
+  return result;
+}
+function renderExtensionsFooter(extensions) {
+  if (extensions.length === 0) return "";
+  const names = extensions.map((ext) => ext.name).join(", ");
+  return `Active extensions: ${names}`;
+}
+
+export {
+  REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT,
+  discoverMemoryExtensions,
+  resolveExtensionsRoot,
+  renderExtensionsBlock,
+  renderExtensionsFooter
+};
+//# sourceMappingURL=chunk-EJI5XIBB.js.map

package/dist/chunk-EJI5XIBB.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/memory-extension-host/host-discovery.ts","../src/memory-extension-host/render-extensions-block.ts"],"sourcesContent":["/**\n * memory-extension-host/host-discovery.ts — Discover third-party memory extensions.\n *\n * Scans a root directory (typically ~/.remnic/memory_extensions/) for valid\n * extension subdirectories. Each extension must contain an instructions.md.\n * The discovery process is read-only and NEVER reads or executes files under\n * any extension's scripts/ directory.\n */\n\nimport { readdir, readFile, lstat, realpath } from \"node:fs/promises\";\nimport path from \"node:path\";\nimport type { LoggerBackend } from \"../logger.js\";\nimport type { PluginConfig } from \"../types.js\";\nimport type { DiscoveredExtension, ExtensionSchema } from \"./types.js\";\n\n/** Total token budget for all discovered extension instructions combined. */\nexport const REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT = 5_000;\n\n/** Maximum number of example files collected per extension. */\nconst MAX_EXAMPLES_PER_EXTENSION = 10;\n\n/** Slug validation: lowercase letters, digits, hyphens, 1-64 chars. */\nconst VALID_SLUG_RE = /^[a-z0-9][a-z0-9-]{0,63}$/;\n\nconst VALID_MEMORY_TYPES = new Set([\"fact\", \"preference\", \"procedure\", \"reference\"]);\n\n/**\n * Discover all valid memory extensions under the given root directory.\n *\n * Returns extensions sorted by name. Skips entries with warnings when:\n * - The slug is invalid (not lowercase alphanumeric + hyphens, or > 64 chars)\n * - instructions.md is missing\n * - schema.json is malformed (extension still returned but schema is undefined)\n *\n * NEVER reads files under any extension's scripts/ directory.\n */\nexport async function discoverMemoryExtensions(\n  root: string,\n  log: Pick<LoggerBackend, \"warn\" | \"debug\">,\n): Promise<DiscoveredExtension[]> {\n  // If root doesn't exist, return empty silently (not even a warning).\n  // Use lstat() for root — a symlinked extensions root could redirect\n  // discovery to an untrusted directory tree (#428 P2).  When the root\n  // IS a symlink, resolve it and verify it still lives under the parent\n  // memory directory so that an attacker-controlled symlink can't point\n  // discovery at /etc or another user's home.\n  let rootStat;\n  try {\n    rootStat = await lstat(root);\n  } catch {\n    return [];\n  }\n  if (rootStat.isSymbolicLink()) {\n    // Resolve and verify the real path is inside the expected parent.\n    let resolved: string;\n    try {\n      resolved = await realpath(root);\n    } catch {\n      return [];\n    }\n    // Normalize the parent path through realpath so that:\n    // 1. Relative roots (e.g. \"memory_extensions\") become absolute (#431 Finding 1)\n    // 2. Intermediate symlinks (e.g. macOS /var -> /private/var) are resolved (#431 Finding 2)\n    let expectedParent: string;\n    try {\n      expectedParent = await realpath(path.resolve(path.dirname(root)));\n    } catch {\n      // Parent directory doesn't exist or is inaccessible — reject.\n      return [];\n    }\n    if (!resolved.startsWith(expectedParent + path.sep) && resolved !== expectedParent) {\n      log.warn?.(\n        `[memory-extensions] root \"${root}\" is a symlink resolving outside the expected parent directory, skipping`,\n      );\n      return [];\n    }\n    // Re-check the resolved path is a directory.\n    try {\n      rootStat = await lstat(resolved);\n    } catch {\n      return [];\n    }\n  }\n  if (!rootStat.isDirectory()) {\n    return [];\n  }\n\n  let entries: string[];\n  try {\n    entries = await readdir(root);\n  } catch {\n    return [];\n  }\n\n  const extensions: DiscoveredExtension[] = [];\n\n  for (const entry of entries) {\n    const entryPath = path.join(root, entry);\n\n    // Must be a real directory (not a symlink) — lstat() blocks symlink\n    // traversal that could escape the extensions root (#382 P2).\n    let entryStat;\n    try {\n      entryStat = await lstat(entryPath);\n    } catch {\n      continue;\n    }\n    if (entryStat.isSymbolicLink()) {\n      log.warn?.(\n        `[memory-extensions] skipping \"${entry}\": symlinks are not followed for security`,\n      );\n      continue;\n    }\n    if (!entryStat.isDirectory()) continue;\n\n    // Validate slug\n    if (!VALID_SLUG_RE.test(entry)) {\n      log.warn?.(\n        `[memory-extensions] skipping \"${entry}\": invalid slug (must be lowercase alphanumeric + hyphens, 1-64 chars)`,\n      );\n      continue;\n    }\n\n    // Require instructions.md — reject symlinked files (#428 P1)\n    const instructionsPath = path.join(entryPath, \"instructions.md\");\n    if (await isSymlink(instructionsPath)) {\n      log.warn?.(\n        `[memory-extensions] skipping \"${entry}\": instructions.md is a symlink`,\n      );\n      continue;\n    }\n    let instructions: string;\n    try {\n      instructions = await readFile(instructionsPath, \"utf-8\");\n    } catch {\n      log.warn?.(\n        `[memory-extensions] skipping \"${entry}\": missing instructions.md`,\n      );\n      continue;\n    }\n\n    // Read optional schema.json — reject symlinked files (#428 P1)\n    let schema: ExtensionSchema | undefined;\n    const schemaPath = path.join(entryPath, \"schema.json\");\n    if (await isSymlink(schemaPath)) {\n      log.warn?.(\n        `[memory-extensions] \"${entry}\": schema.json is a symlink, ignoring schema`,\n      );\n    } else {\n      try {\n        const schemaRaw = await readFile(schemaPath, \"utf-8\");\n        const parsed = JSON.parse(schemaRaw);\n        if (typeof parsed === \"object\" && parsed !== null && !Array.isArray(parsed)) {\n          schema = validateSchema(parsed);\n        } else {\n          log.warn?.(\n            `[memory-extensions] \"${entry}\": schema.json is not a valid object, ignoring schema`,\n          );\n        }\n      } catch (err) {\n        // File doesn't exist → fine, no warning needed\n        if (isFileNotFoundError(err)) {\n          // schema remains undefined\n        } else {\n          log.warn?.(\n            `[memory-extensions] \"${entry}\": malformed schema.json, ignoring schema`,\n          );\n        }\n      }\n    }\n\n    // Collect examples/*.md (cap at MAX_EXAMPLES_PER_EXTENSION)\n    // NEVER read from scripts/ directory\n    const examplesPaths: string[] = [];\n    const examplesDir = path.join(entryPath, \"examples\");\n    try {\n      const exampleEntries = await readdir(examplesDir);\n      const mdFiles = exampleEntries\n        .filter((f) => f.endsWith(\".md\"))\n        .sort()\n        .slice(0, MAX_EXAMPLES_PER_EXTENSION);\n      for (const f of mdFiles) {\n        examplesPaths.push(path.join(examplesDir, f));\n      }\n    } catch {\n      // No examples dir — fine\n    }\n\n    extensions.push({\n      name: entry,\n      root: entryPath,\n      instructionsPath,\n      instructions,\n      schema,\n      examplesPaths,\n    });\n  }\n\n  // Sort by name for deterministic ordering\n  extensions.sort((a, b) => {\n    if (a.name < b.name) return -1;\n    if (a.name > b.name) return 1;\n    return 0;\n  });\n\n  return extensions;\n}\n\nfunction validateSchema(raw: Record<string, unknown>): ExtensionSchema {\n  const memoryTypes: ExtensionSchema[\"memoryTypes\"] = (() => {\n    if (!Array.isArray(raw.memoryTypes)) return undefined;\n    const valid = raw.memoryTypes.filter(\n      (t): t is \"fact\" | \"preference\" | \"procedure\" | \"reference\" =>\n        typeof t === \"string\" && VALID_MEMORY_TYPES.has(t),\n    );\n    return valid.length > 0 ? valid : undefined;\n  })();\n\n  const groupingHints: ExtensionSchema[\"groupingHints\"] = (() => {\n    if (!Array.isArray(raw.groupingHints)) return undefined;\n    const valid = raw.groupingHints.filter(\n      (h): h is string => typeof h === \"string\" && h.length > 0,\n    );\n    return valid.length > 0 ? valid : undefined;\n  })();\n\n  const version: ExtensionSchema[\"version\"] =\n    typeof raw.version === \"string\" && raw.version.length > 0\n      ? raw.version\n      : undefined;\n\n  return {\n    ...(memoryTypes ? { memoryTypes } : {}),\n    ...(groupingHints ? { groupingHints } : {}),\n    ...(version ? { version } : {}),\n  };\n}\n\nfunction isFileNotFoundError(err: unknown): boolean {\n  return (\n    typeof err === \"object\" &&\n    err !== null &&\n    \"code\" in err &&\n    (err as { code: string }).code === \"ENOENT\"\n  );\n}\n\n/**\n * Returns true if the path exists and is a symlink.\n * Returns false if the path does not exist or is not a symlink.\n */\nasync function isSymlink(filePath: string): Promise<boolean> {\n  try {\n    const s = await lstat(filePath);\n    return s.isSymbolicLink();\n  } catch {\n    return false;\n  }\n}\n\n/**\n * Resolve the memory extensions root directory from config.\n * If memoryExtensionsRoot is empty, derive from memoryDir by going up to\n * the Remnic home dir and appending memory_extensions.\n *\n * Moved here from semantic-consolidation.ts (#428 Finding 3) because this\n * is a generic config-to-path resolver with no consolidation logic.\n */\nexport function resolveExtensionsRoot(config: PluginConfig): string {\n  if (config.memoryExtensionsRoot.length > 0) {\n    return config.memoryExtensionsRoot;\n  }\n  // Default: memoryDir is typically ~/.openclaw/workspace/memory/local\n  // Go up to the parent that owns the memory tree and append memory_extensions\n  return path.join(path.dirname(config.memoryDir), \"memory_extensions\");\n}\n","/**\n * memory-extension-host/render-extensions-block.ts — Render discovered extensions\n * into a markdown block for injection into consolidation prompts.\n *\n * Respects the global token budget (REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT) and\n * truncates with a footer listing omitted extensions when over budget.\n */\n\nimport { REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT } from \"./host-discovery.js\";\nimport type { DiscoveredExtension } from \"./types.js\";\n\n/**\n * Approximate token count using the 4 chars per token heuristic.\n */\nfunction estimateTokens(text: string): number {\n  return Math.ceil(text.length / 4);\n}\n\n/**\n * Render a markdown block containing extension instructions for injection\n * into consolidation prompts.\n *\n * If the list is empty, returns \"\".\n * Inlines extensions in name order until the token budget is exhausted.\n * If the budget is exceeded, appends a truncation footer listing omitted extensions.\n */\nexport function renderExtensionsBlock(extensions: DiscoveredExtension[]): string {\n  if (extensions.length === 0) return \"\";\n\n  const header = `## Active memory extensions\n\nYou are running with the following third-party memory extensions. Each\nextension's \\`instructions.md\\` tells you how to interpret memories that\nextension produces or curates.\n\n`;\n\n  let budget = REMNIC_EXTENSIONS_TOTAL_TOKEN_LIMIT;\n  budget -= estimateTokens(header);\n\n  const inlined: string[] = [];\n  const omitted: string[] = [];\n\n  for (const ext of extensions) {\n    const block = `### remnic-extension/${ext.name}\\n\\`\\`\\`\\n${ext.instructions}\\n\\`\\`\\`\\n\\n`;\n    const cost = estimateTokens(block);\n    if (cost <= budget) {\n      inlined.push(block);\n      budget -= cost;\n    } else {\n      omitted.push(ext.name);\n    }\n  }\n\n  let result = header;\n  result += inlined.join(\"\");\n\n  if (omitted.length > 0) {\n    result += `> **Note:** ${omitted.length} extension(s) omitted due to token budget: ${omitted.join(\", \")}\\n`;\n  }\n\n  return result;\n}\n\n/**\n * Render a compact one-line footer listing active extension names.\n * Used by day-summary and summary-snapshot where full instructions are not needed.\n */\nexport function renderExtensionsFooter(extensions: DiscoveredExtension[]): string {\n  if (extensions.length === 0) return \"\";\n  const names = extensions.map((ext) => ext.name).join(\", \");\n  return `Active extensions: ${names}`;\n}\n"],"mappings":"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","names":[]}

package/dist/{chunk-ONRU4L2N.js → chunk-FEMOX5AD.js}

@@ -1,6 +1,6 @@
 import {
   log
-} from "./chunk-KWBU5S5U.js";
+} from "./chunk-2ODBA7MQ.js";
 
 // src/model-registry.ts
 import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
@@ -237,4 +237,4 @@ var ModelRegistry = class {
 export {
   ModelRegistry
 };
-//# sourceMappingURL=chunk-ONRU4L2N.js.map
+//# sourceMappingURL=chunk-FEMOX5AD.js.map

package/dist/{chunk-IFFFR3MR.js → chunk-FSFEQI74.js}

@@ -1,9 +1,9 @@
 import {
   readUtilityLearningSnapshot
-} from "./chunk-OTAVQCSF.js";
+} from "./chunk-PYXS46O7.js";
 import {
   clamp01
-} from "./chunk-QCCCQT3O.js";
+} from "./chunk-TBBDFYXW.js";
 
 // src/utility-runtime.ts
 var RANKING_MULTIPLIER_LIMIT = 0.12;
@@ -65,4 +65,4 @@ export {
   applyUtilityRankingRuntimeDelta,
   applyUtilityPromotionRuntimePolicy
 };
-//# sourceMappingURL=chunk-IFFFR3MR.js.map
+//# sourceMappingURL=chunk-FSFEQI74.js.map

package/dist/chunk-G4SK7DSQ.js

@@ -0,0 +1,121 @@
+import {
+  collapseWhitespace,
+  truncateCodePointSafe
+} from "./chunk-6MKAMLQL.js";
+import {
+  canReadNamespace,
+  defaultNamespaceForPrincipal,
+  resolvePrincipal
+} from "./chunk-N5AKDXAI.js";
+
+// src/active-memory-bridge.ts
+function isArtifactPath(value) {
+  return typeof value === "string" && /(?:^|[\\/])artifacts(?:[\\/]|$)/i.test(value);
+}
+function clampLimit(value) {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 8;
+  return Math.max(1, Math.min(50, Math.floor(value)));
+}
+function truncateSnippet(value, maxChars) {
+  const compact = collapseWhitespace(value);
+  return truncateCodePointSafe(compact, maxChars);
+}
+function pickMetadata(value) {
+  if (!value) return void 0;
+  const metadata = {};
+  if (typeof value.type === "string") metadata.type = value.type;
+  if (typeof value.topic === "string") metadata.topic = value.topic;
+  if (typeof value.updatedAt === "string") metadata.updatedAt = value.updatedAt;
+  if (typeof value.sourceUri === "string") metadata.sourceUri = value.sourceUri;
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+function resolveActiveMemoryNamespace(orchestrator, sessionKey, requestedNamespace) {
+  const explicitNamespace = typeof requestedNamespace === "string" && requestedNamespace.trim().length > 0 ? requestedNamespace.trim() : void 0;
+  const config = orchestrator.config;
+  if (config?.namespacesEnabled === false) {
+    if (typeof orchestrator.resolveSelfNamespace === "function") {
+      return orchestrator.resolveSelfNamespace(sessionKey);
+    }
+    return "default";
+  }
+  if (!config) {
+    if (explicitNamespace) return explicitNamespace;
+    if (typeof orchestrator.resolveSelfNamespace === "function") {
+      return orchestrator.resolveSelfNamespace(sessionKey);
+    }
+    return "default";
+  }
+  const principal = typeof orchestrator.resolvePrincipal === "function" ? orchestrator.resolvePrincipal(sessionKey) : resolvePrincipal(sessionKey, config);
+  if (explicitNamespace) {
+    if (!canReadNamespace(principal, explicitNamespace, config)) {
+      throw new Error(`namespace ${explicitNamespace} is not readable for principal ${principal}`);
+    }
+    return explicitNamespace;
+  }
+  if (typeof orchestrator.resolveSelfNamespace === "function") {
+    return orchestrator.resolveSelfNamespace(sessionKey);
+  }
+  return defaultNamespaceForPrincipal(principal, config);
+}
+async function recallForActiveMemory(orchestrator, params) {
+  const limit = clampLimit(params.limit);
+  const requestedResults = Math.min(200, limit + 20);
+  const snippetMaxChars = typeof params.snippetMaxChars === "number" && Number.isFinite(params.snippetMaxChars) ? Math.max(1, Math.min(4e3, Math.floor(params.snippetMaxChars))) : 600;
+  const namespace = resolveActiveMemoryNamespace(
+    orchestrator,
+    params.sessionKey,
+    typeof params.filters?.namespace === "string" ? params.filters.namespace : void 0
+  );
+  const raw = await orchestrator.searchAcrossNamespaces({
+    query: params.query,
+    maxResults: requestedResults,
+    namespaces: [namespace],
+    mode: "search"
+  });
+  const visible = raw.filter((candidate) => !isArtifactPath(candidate.path));
+  return {
+    results: visible.slice(0, limit).map((candidate, index) => ({
+      id: candidate.id ?? candidate.path ?? `memory-${index + 1}`,
+      score: typeof candidate.score === "number" ? candidate.score : 0,
+      text: truncateSnippet(candidate.snippet ?? candidate.text ?? "", snippetMaxChars),
+      metadata: pickMetadata(candidate.metadata)
+    })),
+    truncated: visible.length > limit
+  };
+}
+function buildActiveMemoryMetadataFromMemory(memory) {
+  const metadata = {};
+  if (typeof memory.frontmatter.category === "string") {
+    const category = memory.frontmatter.category;
+    if (category === "fact" || category === "preference") {
+      metadata.type = category;
+    }
+  }
+  if (Array.isArray(memory.frontmatter.tags) && memory.frontmatter.tags.length > 0) {
+    metadata.topic = memory.frontmatter.tags[0];
+  }
+  if (typeof memory.frontmatter.updated === "string") metadata.updatedAt = memory.frontmatter.updated;
+  if (typeof memory.frontmatter.source === "string") metadata.sourceUri = memory.frontmatter.source;
+  return Object.keys(metadata).length > 0 ? metadata : void 0;
+}
+async function getMemoryForActiveMemory(orchestrator, id, options = {}) {
+  const namespace = resolveActiveMemoryNamespace(
+    orchestrator,
+    options.sessionKey,
+    options.namespace
+  );
+  const storage = typeof orchestrator.getStorageForNamespace === "function" ? await orchestrator.getStorageForNamespace(namespace) : orchestrator.storage;
+  const memory = await storage?.getMemoryById?.(id);
+  if (!memory) return { error: "not_found" };
+  return {
+    id,
+    text: collapseWhitespace(memory.content),
+    metadata: buildActiveMemoryMetadataFromMemory(memory)
+  };
+}
+
+export {
+  recallForActiveMemory,
+  getMemoryForActiveMemory
+};
+//# sourceMappingURL=chunk-G4SK7DSQ.js.map

package/dist/chunk-G4SK7DSQ.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/active-memory-bridge.ts"],"sourcesContent":["import { canReadNamespace, defaultNamespaceForPrincipal, resolvePrincipal } from \"./namespaces/principal.js\";\nimport type { MemoryFile, PluginConfig } from \"./types.js\";\nimport { collapseWhitespace, truncateCodePointSafe } from \"./whitespace.js\";\n\nexport interface ActiveMemoryMetadata {\n  type?: \"fact\" | \"preference\";\n  topic?: string;\n  updatedAt?: string;\n  sourceUri?: string;\n}\n\nexport interface ActiveMemorySearchResult {\n  id: string;\n  score: number;\n  text: string;\n  metadata?: ActiveMemoryMetadata;\n}\n\nexport interface ActiveMemorySearchOutput {\n  results: ActiveMemorySearchResult[];\n  truncated: boolean;\n}\n\nexport interface ActiveMemoryGetOutput {\n  id?: string;\n  text?: string;\n  metadata?: ActiveMemoryMetadata;\n  error?: \"not_found\";\n}\n\nexport interface ActiveMemoryRecallParams {\n  query: string;\n  limit?: number;\n  sessionKey: string;\n  filters?: Record<string, unknown>;\n  snippetMaxChars?: number;\n}\n\ninterface ActiveMemoryScopedOrchestrator {\n  config?: PluginConfig;\n  resolvePrincipal?: (sessionKey?: string) => string;\n  resolveSelfNamespace?: (sessionKey?: string) => string;\n}\n\ntype ActiveMemorySearchCandidate = {\n  id?: string;\n  score?: number;\n  snippet?: string;\n  text?: string;\n  path?: string;\n  metadata?: Record<string, unknown>;\n};\n\nfunction isArtifactPath(value: string | undefined): boolean {\n  return typeof value === \"string\" && /(?:^|[\\\\/])artifacts(?:[\\\\/]|$)/i.test(value);\n}\n\nfunction clampLimit(value: number | undefined): number {\n  if (typeof value !== \"number\" || !Number.isFinite(value)) return 8;\n  return Math.max(1, Math.min(50, Math.floor(value)));\n}\n\nfunction truncateSnippet(value: string, maxChars: number): string {\n  const compact = collapseWhitespace(value);\n  return truncateCodePointSafe(compact, maxChars);\n}\n\nfunction pickMetadata(value: Record<string, unknown> | undefined): ActiveMemoryMetadata | undefined {\n  if (!value) return undefined;\n  const metadata: ActiveMemoryMetadata = {};\n  if (typeof value.type === \"string\") metadata.type = value.type as ActiveMemoryMetadata[\"type\"];\n  if (typeof value.topic === \"string\") metadata.topic = value.topic;\n  if (typeof value.updatedAt === \"string\") metadata.updatedAt = value.updatedAt;\n  if (typeof value.sourceUri === \"string\") metadata.sourceUri = value.sourceUri;\n  return Object.keys(metadata).length > 0 ? metadata : undefined;\n}\n\nfunction resolveActiveMemoryNamespace(\n  orchestrator: ActiveMemoryScopedOrchestrator,\n  sessionKey: string | undefined,\n  requestedNamespace: string | undefined,\n): string {\n  const explicitNamespace =\n    typeof requestedNamespace === \"string\" && requestedNamespace.trim().length > 0\n      ? requestedNamespace.trim()\n      : undefined;\n  const config = orchestrator.config;\n\n  if (config?.namespacesEnabled === false) {\n    if (typeof orchestrator.resolveSelfNamespace === \"function\") {\n      return orchestrator.resolveSelfNamespace(sessionKey);\n    }\n    return \"default\";\n  }\n\n  if (!config) {\n    if (explicitNamespace) return explicitNamespace;\n    if (typeof orchestrator.resolveSelfNamespace === \"function\") {\n      return orchestrator.resolveSelfNamespace(sessionKey);\n    }\n    return \"default\";\n  }\n\n  const principal =\n    typeof orchestrator.resolvePrincipal === \"function\"\n      ? orchestrator.resolvePrincipal(sessionKey)\n      : resolvePrincipal(sessionKey, config);\n  if (explicitNamespace) {\n    if (!canReadNamespace(principal, explicitNamespace, config)) {\n      throw new Error(`namespace ${explicitNamespace} is not readable for principal ${principal}`);\n    }\n    return explicitNamespace;\n  }\n  if (typeof orchestrator.resolveSelfNamespace === \"function\") {\n    return orchestrator.resolveSelfNamespace(sessionKey);\n  }\n  return defaultNamespaceForPrincipal(principal, config);\n}\n\nexport async function recallForActiveMemory(\n  orchestrator: {\n    config?: PluginConfig;\n    resolvePrincipal?: (sessionKey?: string) => string;\n    resolveSelfNamespace?: (sessionKey?: string) => string;\n    searchAcrossNamespaces: (params: {\n      query: string;\n      maxResults?: number;\n      namespaces?: string[];\n      mode?: string;\n    }) => Promise<ActiveMemorySearchCandidate[]>;\n  },\n  params: ActiveMemoryRecallParams,\n): Promise<ActiveMemorySearchOutput> {\n  const limit = clampLimit(params.limit);\n  const requestedResults = Math.min(200, limit + 20);\n  const snippetMaxChars =\n    typeof params.snippetMaxChars === \"number\" && Number.isFinite(params.snippetMaxChars)\n      ? Math.max(1, Math.min(4000, Math.floor(params.snippetMaxChars)))\n      : 600;\n  const namespace = resolveActiveMemoryNamespace(\n    orchestrator,\n    params.sessionKey,\n    typeof params.filters?.namespace === \"string\" ? params.filters.namespace : undefined,\n  );\n\n  const raw = await orchestrator.searchAcrossNamespaces({\n    query: params.query,\n    maxResults: requestedResults,\n    namespaces: [namespace],\n    mode: \"search\",\n  });\n  const visible = raw.filter((candidate) => !isArtifactPath(candidate.path));\n\n  return {\n    results: visible.slice(0, limit).map((candidate, index) => ({\n      id: candidate.id ?? candidate.path ?? `memory-${index + 1}`,\n      score: typeof candidate.score === \"number\" ? candidate.score : 0,\n      text: truncateSnippet(candidate.snippet ?? candidate.text ?? \"\", snippetMaxChars),\n      metadata: pickMetadata(candidate.metadata),\n    })),\n    truncated: visible.length > limit,\n  };\n}\n\nfunction buildActiveMemoryMetadataFromMemory(memory: MemoryFile): ActiveMemoryMetadata | undefined {\n  const metadata: ActiveMemoryMetadata = {};\n  if (typeof memory.frontmatter.category === \"string\") {\n    const category = memory.frontmatter.category;\n    if (category === \"fact\" || category === \"preference\") {\n      metadata.type = category;\n    }\n  }\n  if (Array.isArray(memory.frontmatter.tags) && memory.frontmatter.tags.length > 0) {\n    metadata.topic = memory.frontmatter.tags[0];\n  }\n  if (typeof memory.frontmatter.updated === \"string\") metadata.updatedAt = memory.frontmatter.updated;\n  if (typeof memory.frontmatter.source === \"string\") metadata.sourceUri = memory.frontmatter.source;\n  return Object.keys(metadata).length > 0 ? metadata : undefined;\n}\n\nexport async function getMemoryForActiveMemory(\n  orchestrator: {\n    config?: PluginConfig;\n    resolvePrincipal?: (sessionKey?: string) => string;\n    resolveSelfNamespace?: (sessionKey?: string) => string;\n    getStorageForNamespace?: (namespace: string) => Promise<{\n      getMemoryById?: (id: string) => Promise<MemoryFile | null>;\n    }>;\n    storage?: {\n      getMemoryById?: (id: string) => Promise<MemoryFile | null>;\n    };\n  },\n  id: string,\n  options: {\n    namespace?: string;\n    sessionKey?: string;\n  } = {},\n): Promise<ActiveMemoryGetOutput> {\n  const namespace = resolveActiveMemoryNamespace(\n    orchestrator,\n    options.sessionKey,\n    options.namespace,\n  );\n\n  const storage =\n    typeof orchestrator.getStorageForNamespace === \"function\"\n      ? await orchestrator.getStorageForNamespace(namespace)\n      : orchestrator.storage;\n\n  const memory = await storage?.getMemoryById?.(id);\n  if (!memory) return { error: \"not_found\" };\n  return {\n    id,\n    text: collapseWhitespace(memory.content),\n    metadata: buildActiveMemoryMetadataFromMemory(memory),\n  };\n}\n"],"mappings":";;;;;;;;;;;AAqDA,SAAS,eAAe,OAAoC;AAC1D,SAAO,OAAO,UAAU,YAAY,mCAAmC,KAAK,KAAK;AACnF;AAEA,SAAS,WAAW,OAAmC;AACrD,MAAI,OAAO,UAAU,YAAY,CAAC,OAAO,SAAS,KAAK,EAAG,QAAO;AACjE,SAAO,KAAK,IAAI,GAAG,KAAK,IAAI,IAAI,KAAK,MAAM,KAAK,CAAC,CAAC;AACpD;AAEA,SAAS,gBAAgB,OAAe,UAA0B;AAChE,QAAM,UAAU,mBAAmB,KAAK;AACxC,SAAO,sBAAsB,SAAS,QAAQ;AAChD;AAEA,SAAS,aAAa,OAA8E;AAClG,MAAI,CAAC,MAAO,QAAO;AACnB,QAAM,WAAiC,CAAC;AACxC,MAAI,OAAO,MAAM,SAAS,SAAU,UAAS,OAAO,MAAM;AAC1D,MAAI,OAAO,MAAM,UAAU,SAAU,UAAS,QAAQ,MAAM;AAC5D,MAAI,OAAO,MAAM,cAAc,SAAU,UAAS,YAAY,MAAM;AACpE,MAAI,OAAO,MAAM,cAAc,SAAU,UAAS,YAAY,MAAM;AACpE,SAAO,OAAO,KAAK,QAAQ,EAAE,SAAS,IAAI,WAAW;AACvD;AAEA,SAAS,6BACP,cACA,YACA,oBACQ;AACR,QAAM,oBACJ,OAAO,uBAAuB,YAAY,mBAAmB,KAAK,EAAE,SAAS,IACzE,mBAAmB,KAAK,IACxB;AACN,QAAM,SAAS,aAAa;AAE5B,MAAI,QAAQ,sBAAsB,OAAO;AACvC,QAAI,OAAO,aAAa,yBAAyB,YAAY;AAC3D,aAAO,aAAa,qBAAqB,UAAU;AAAA,IACrD;AACA,WAAO;AAAA,EACT;AAEA,MAAI,CAAC,QAAQ;AACX,QAAI,kBAAmB,QAAO;AAC9B,QAAI,OAAO,aAAa,yBAAyB,YAAY;AAC3D,aAAO,aAAa,qBAAqB,UAAU;AAAA,IACrD;AACA,WAAO;AAAA,EACT;AAEA,QAAM,YACJ,OAAO,aAAa,qBAAqB,aACrC,aAAa,iBAAiB,UAAU,IACxC,iBAAiB,YAAY,MAAM;AACzC,MAAI,mBAAmB;AACrB,QAAI,CAAC,iBAAiB,WAAW,mBAAmB,MAAM,GAAG;AAC3D,YAAM,IAAI,MAAM,aAAa,iBAAiB,kCAAkC,SAAS,EAAE;AAAA,IAC7F;AACA,WAAO;AAAA,EACT;AACA,MAAI,OAAO,aAAa,yBAAyB,YAAY;AAC3D,WAAO,aAAa,qBAAqB,UAAU;AAAA,EACrD;AACA,SAAO,6BAA6B,WAAW,MAAM;AACvD;AAEA,eAAsB,sBACpB,cAWA,QACmC;AACnC,QAAM,QAAQ,WAAW,OAAO,KAAK;AACrC,QAAM,mBAAmB,KAAK,IAAI,KAAK,QAAQ,EAAE;AACjD,QAAM,kBACJ,OAAO,OAAO,oBAAoB,YAAY,OAAO,SAAS,OAAO,eAAe,IAChF,KAAK,IAAI,GAAG,KAAK,IAAI,KAAM,KAAK,MAAM,OAAO,eAAe,CAAC,CAAC,IAC9D;AACN,QAAM,YAAY;AAAA,IAChB;AAAA,IACA,OAAO;AAAA,IACP,OAAO,OAAO,SAAS,cAAc,WAAW,OAAO,QAAQ,YAAY;AAAA,EAC7E;AAEA,QAAM,MAAM,MAAM,aAAa,uBAAuB;AAAA,IACpD,OAAO,OAAO;AAAA,IACd,YAAY;AAAA,IACZ,YAAY,CAAC,SAAS;AAAA,IACtB,MAAM;AAAA,EACR,CAAC;AACD,QAAM,UAAU,IAAI,OAAO,CAAC,cAAc,CAAC,eAAe,UAAU,IAAI,CAAC;AAEzE,SAAO;AAAA,IACL,SAAS,QAAQ,MAAM,GAAG,KAAK,EAAE,IAAI,CAAC,WAAW,WAAW;AAAA,MAC1D,IAAI,UAAU,MAAM,UAAU,QAAQ,UAAU,QAAQ,CAAC;AAAA,MACzD,OAAO,OAAO,UAAU,UAAU,WAAW,UAAU,QAAQ;AAAA,MAC/D,MAAM,gBAAgB,UAAU,WAAW,UAAU,QAAQ,IAAI,eAAe;AAAA,MAChF,UAAU,aAAa,UAAU,QAAQ;AAAA,IAC3C,EAAE;AAAA,IACF,WAAW,QAAQ,SAAS;AAAA,EAC9B;AACF;AAEA,SAAS,oCAAoC,QAAsD;AACjG,QAAM,WAAiC,CAAC;AACxC,MAAI,OAAO,OAAO,YAAY,aAAa,UAAU;AACnD,UAAM,WAAW,OAAO,YAAY;AACpC,QAAI,aAAa,UAAU,aAAa,cAAc;AACpD,eAAS,OAAO;AAAA,IAClB;AAAA,EACF;AACA,MAAI,MAAM,QAAQ,OAAO,YAAY,IAAI,KAAK,OAAO,YAAY,KAAK,SAAS,GAAG;AAChF,aAAS,QAAQ,OAAO,YAAY,KAAK,CAAC;AAAA,EAC5C;AACA,MAAI,OAAO,OAAO,YAAY,YAAY,SAAU,UAAS,YAAY,OAAO,YAAY;AAC5F,MAAI,OAAO,OAAO,YAAY,WAAW,SAAU,UAAS,YAAY,OAAO,YAAY;AAC3F,SAAO,OAAO,KAAK,QAAQ,EAAE,SAAS,IAAI,WAAW;AACvD;AAEA,eAAsB,yBACpB,cAWA,IACA,UAGI,CAAC,GAC2B;AAChC,QAAM,YAAY;AAAA,IAChB;AAAA,IACA,QAAQ;AAAA,IACR,QAAQ;AAAA,EACV;AAEA,QAAM,UACJ,OAAO,aAAa,2BAA2B,aAC3C,MAAM,aAAa,uBAAuB,SAAS,IACnD,aAAa;AAEnB,QAAM,SAAS,MAAM,SAAS,gBAAgB,EAAE;AAChD,MAAI,CAAC,OAAQ,QAAO,EAAE,OAAO,YAAY;AACzC,SAAO;AAAA,IACL;AAAA,IACA,MAAM,mBAAmB,OAAO,OAAO;AAAA,IACvC,UAAU,oCAAoC,MAAM;AAAA,EACtD;AACF;","names":[]}

package/dist/{chunk-WWIQTB2Y.js → chunk-GGD5W7TB.js}

@@ -20,6 +20,7 @@ var ENTITY_PATTERNS = [
   { re: /\b(model|llm|qmd|embedding|retrieval|memory)\b/i, entityType: "ai" },
   { re: /\b(doc|readme|docs|changelog)\b/i, entityType: "docs" }
 ];
+var TASK_INITIATION_RE = /\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;
 function normalizeTextInput(input) {
   return typeof input === "string" ? input : "";
 }
@@ -30,12 +31,17 @@ function inferIntentFromText(text) {
   const entityTypes = Array.from(
     new Set(ENTITY_PATTERNS.filter((p) => p.re.test(safeText)).map((p) => p.entityType))
   );
+  const taskInitiation = TASK_INITIATION_RE.test(safeText);
   return {
     goal,
     actionType,
-    entityTypes
+    entityTypes,
+    taskInitiation
   };
 }
+function isTaskInitiationIntent(intent) {
+  return intent.taskInitiation === true;
+}
 function intentCompatibilityScore(queryIntent, memoryIntent) {
   const queryHasSignal = queryIntent.goal !== "unknown" || queryIntent.actionType !== "unknown" || queryIntent.entityTypes.length > 0;
   const memoryHasSignal = memoryIntent.goal !== "unknown" || memoryIntent.actionType !== "unknown" || memoryIntent.entityTypes.length > 0;
@@ -91,8 +97,9 @@ function hasBroadGraphIntent(prompt) {
 
 export {
   inferIntentFromText,
+  isTaskInitiationIntent,
   intentCompatibilityScore,
   planRecallMode,
   hasBroadGraphIntent
 };
-//# sourceMappingURL=chunk-WWIQTB2Y.js.map
+//# sourceMappingURL=chunk-GGD5W7TB.js.map

package/dist/chunk-GGD5W7TB.js.map

@@ -0,0 +1 @@
+{"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\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 = 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\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":[]}