@remnic/core 1.1.30 → 9.3.515

package/dist/chunk-ECZU5BJH.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/tmt.ts"],"sourcesContent":["/**\n * Temporal Memory Tree (TiMem-inspired, v8.2)\n *\n * Builds a hierarchy of summarised memory nodes:\n *   hour-HH.md → day.md → week-YYYY-WW.md → persona.md\n *\n * Stored under `<baseDir>/tmt/`.\n * All writes are fail-open: errors are caught and logged, never thrown.\n */\n\nimport * as fs from \"fs\";\nimport * as path from \"path\";\nimport { mkdir, readFile, writeFile, readdir } from \"node:fs/promises\";\n\nexport const TMT_DIR = \"tmt\";\n\nexport type TmtLevel = \"hour\" | \"day\" | \"week\" | \"persona\";\n\nexport interface TmtNodeFrontmatter {\n  level: TmtLevel;\n  periodStart: string; // ISO date-time\n  periodEnd: string;   // ISO date-time\n  memoryCount: number;\n  sourceIds: string[];\n  builtAt: string;     // ISO date-time\n}\n\nexport interface TmtConfig {\n  temporalMemoryTreeEnabled: boolean;\n  tmtHourlyMinMemories: number;   // default 3\n  tmtSummaryMaxTokens: number;    // default 300\n}\n\nexport interface MemoryEntry {\n  path: string;\n  id: string;\n  created: string; // ISO date-time\n  content: string;\n}\n\nconst TMT_LEVEL_INPUT_LIMITS: Record<TmtLevel, { totalChars: number; itemChars: number; maxItems: number }> = {\n  hour: { totalChars: 48_000, itemChars: 2_000, maxItems: 64 },\n  day: { totalChars: 64_000, itemChars: 1_800, maxItems: 96 },\n  week: { totalChars: 72_000, itemChars: 1_600, maxItems: 120 },\n  persona: { totalChars: 80_000, itemChars: 1_600, maxItems: 120 },\n};\n\nexport function capTmtSummaryInputs(inputs: string[], level: TmtLevel): string[] {\n  const { totalChars, itemChars, maxItems } = TMT_LEVEL_INPUT_LIMITS[level];\n  if (inputs.length === 0) return [];\n\n  const capped: string[] = [];\n  let usedChars = 0;\n\n  for (const raw of inputs) {\n    if (capped.length >= maxItems || usedChars >= totalChars) break;\n    const trimmed = raw.trim();\n    if (!trimmed) continue;\n\n    const next = trimmed.length > itemChars ? `${trimmed.slice(0, itemChars - 1)}…` : trimmed;\n    const separator = capped.length === 0 ? 0 : 2;\n    if (usedChars + separator + next.length > totalChars) break;\n    capped.push(next);\n    usedChars += separator + next.length;\n  }\n\n  if (capped.length > 0) return capped;\n  const fallback = inputs[0]?.trim() ?? \"\";\n  if (!fallback) return [];\n  return [fallback.length > itemChars ? `${fallback.slice(0, itemChars - 1)}…` : fallback];\n}\n\n// ── Path helpers ────────────────────────────────────────────────────────────\n\nexport function tmtDir(baseDir: string): string {\n  return path.join(baseDir, TMT_DIR);\n}\n\nexport function hourNodePath(baseDir: string, date: string, hour: string): string {\n  return path.join(tmtDir(baseDir), date, `hour-${hour}.md`);\n}\n\nexport function dayNodePath(baseDir: string, date: string): string {\n  return path.join(tmtDir(baseDir), date, \"day.md\");\n}\n\nexport function weekNodePath(baseDir: string, weekKey: string): string {\n  return path.join(tmtDir(baseDir), `week-${weekKey}.md`);\n}\n\nexport function personaNodePath(baseDir: string): string {\n  return path.join(tmtDir(baseDir), \"persona.md\");\n}\n\n// ── Frontmatter helpers ─────────────────────────────────────────────────────\n\nexport function serialiseTmtNode(fm: TmtNodeFrontmatter, summary: string): string {\n  const yaml = [\n    \"---\",\n    `level: ${fm.level}`,\n    `periodStart: \"${fm.periodStart}\"`,\n    `periodEnd: \"${fm.periodEnd}\"`,\n    `memoryCount: ${fm.memoryCount}`,\n    `sourceIds: [${fm.sourceIds.map((id) => `\"${id}\"`).join(\", \")}]`,\n    `builtAt: \"${fm.builtAt}\"`,\n    \"---\",\n  ].join(\"\\n\");\n  return `${yaml}\\n\\n${summary}\\n`;\n}\n\nexport function parseIsoDate(iso: string): string {\n  return parseTmtInstant(iso)?.date ?? \"\";\n}\n\nexport function parseIsoHour(iso: string): string {\n  return parseTmtInstant(iso)?.hour ?? \"\";\n}\n\nfunction parseTmtInstant(iso: string): { date: string; hour: string; dateValue: Date } | null {\n  if (typeof iso !== \"string\") return null;\n  const value = iso.trim();\n  if (\n    !/^\\d{4}-\\d{2}-\\d{2}T\\d{2}:\\d{2}:\\d{2}(?:\\.\\d{1,9})?(?:Z|[+-]\\d{2}:\\d{2})$/.test(value)\n  ) {\n    return null;\n  }\n  const dateValue = new Date(value);\n  if (!Number.isFinite(dateValue.getTime())) return null;\n  const utc = dateValue.toISOString();\n  return {\n    date: utc.slice(0, 10),\n    hour: utc.slice(11, 13),\n    dateValue,\n  };\n}\n\n// Returns ISO week key: YYYY-WW\nexport function isoWeekKey(date: Date): string {\n  const d = new Date(Date.UTC(date.getUTCFullYear(), date.getUTCMonth(), date.getUTCDate()));\n  const dayNum = d.getUTCDay() || 7;\n  d.setUTCDate(d.getUTCDate() + 4 - dayNum);\n  const yearStart = new Date(Date.UTC(d.getUTCFullYear(), 0, 1));\n  const weekNo = Math.ceil((((d.getTime() - yearStart.getTime()) / 86400000) + 1) / 7);\n  return `${d.getUTCFullYear()}-${String(weekNo).padStart(2, \"0\")}`;\n}\n\n// ── TmtBuilder ──────────────────────────────────────────────────────────────\n\nexport type SummarizeFn = (memories: string[], level: TmtLevel) => Promise<string>;\n\nexport class TmtBuilder {\n  constructor(\n    private readonly baseDir: string,\n    private readonly cfg: TmtConfig,\n  ) {}\n\n  /**\n   * Called after each consolidation pass.\n   * Groups memories by hour, builds any missing hour nodes,\n   * then rolls up to day → week → persona if needed.\n   * All errors are caught and logged; never throws.\n   */\n  async maybeRebuildNodes(\n    memories: MemoryEntry[],\n    summarize: SummarizeFn,\n  ): Promise<void> {\n    if (!this.cfg.temporalMemoryTreeEnabled || memories.length === 0) return;\n    try {\n      await mkdir(tmtDir(this.baseDir), { recursive: true });\n      await this.buildHourNodes(memories, summarize);\n      await this.buildDayNodes(memories, summarize);\n      await this.buildWeekNodes(memories, summarize);\n      await this.buildPersonaNode(summarize);\n    } catch (err) {\n      console.warn(`[engram] tmt: rebuild failed (ignored): ${err}`);\n    }\n  }\n\n  private async buildHourNodes(memories: MemoryEntry[], summarize: SummarizeFn): Promise<void> {\n    // Group by date+hour\n    const byHour = new Map<string, MemoryEntry[]>();\n    for (const m of memories) {\n      const instant = parseTmtInstant(m.created);\n      if (!instant) continue;\n      const { date, hour } = instant;\n      const key = `${date}::${hour}`;\n      if (!byHour.has(key)) byHour.set(key, []);\n      byHour.get(key)!.push(m);\n    }\n\n    for (const [key, entries] of byHour) {\n      if (entries.length < this.cfg.tmtHourlyMinMemories) continue;\n      const [date, hour] = key.split(\"::\");\n      const nodePath = hourNodePath(this.baseDir, date, hour);\n\n      // Rebuild if missing or if more memories arrived for this hour\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) !== entries.length) {\n            shouldBuild = true; // active memory set changed — rebuild\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) continue;\n\n      let summary: string;\n      try {\n        summary = await summarize(capTmtSummaryInputs(entries.map((e) => e.content), \"hour\"), \"hour\");\n      } catch (err) {\n        console.warn(`[engram] tmt: hour node summarize failed for ${key} (ignored): ${err}`);\n        continue;\n      }\n      const sortedCreated = entries.map((e) => e.created).sort();\n      const fm: TmtNodeFrontmatter = {\n        level: \"hour\",\n        periodStart: sortedCreated[0],\n        periodEnd: sortedCreated[sortedCreated.length - 1],\n        memoryCount: entries.length,\n        sourceIds: entries.map((e) => e.id),\n        builtAt: new Date().toISOString(),\n      };\n      await mkdir(path.dirname(nodePath), { recursive: true });\n      await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n    }\n  }\n\n  private async buildDayNodes(memories: MemoryEntry[], summarize: SummarizeFn): Promise<void> {\n    // Group by date\n    const byDate = new Map<string, MemoryEntry[]>();\n    for (const m of memories) {\n      const instant = parseTmtInstant(m.created);\n      if (!instant) continue;\n      const { date } = instant;\n      if (!byDate.has(date)) byDate.set(date, []);\n      byDate.get(date)!.push(m);\n    }\n\n    for (const [date, entries] of byDate) {\n      const nodePath = dayNodePath(this.baseDir, date);\n      // Rebuild day node if it doesn't exist or if memory count changed\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) !== entries.length) {\n            shouldBuild = true; // active memory set changed — rebuild\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) continue;\n\n      // Per-hour: use hour node summary if available, raw content otherwise\n      const inputs: string[] = [];\n      const hourToEntries = new Map<string, MemoryEntry[]>();\n      for (const e of entries) {\n        const h = parseIsoHour(e.created);\n        if (!h) continue;\n        if (!hourToEntries.has(h)) hourToEntries.set(h, []);\n        hourToEntries.get(h)!.push(e);\n      }\n      for (const [h, hourEntries] of hourToEntries) {\n        const hPath = hourNodePath(this.baseDir, date, h);\n        if (fs.existsSync(hPath)) {\n          try {\n            const hContent = await readFile(hPath, \"utf8\");\n            const hSummary = hContent.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n            if (hSummary) { inputs.push(hSummary); continue; }\n          } catch { /* fall through to raw content */ }\n        }\n        inputs.push(...hourEntries.map((e) => e.content));\n      }\n      if (inputs.length === 0) inputs.push(...entries.map((e) => e.content));\n\n      let summary: string;\n      try {\n        summary = await summarize(capTmtSummaryInputs(inputs, \"day\"), \"day\");\n      } catch (err) {\n        console.warn(`[engram] tmt: day node summarize failed for ${date} (ignored): ${err}`);\n        continue;\n      }\n      const sortedCreated = entries.map((e) => e.created).sort();\n      const fm: TmtNodeFrontmatter = {\n        level: \"day\",\n        periodStart: sortedCreated[0],\n        periodEnd: sortedCreated[sortedCreated.length - 1],\n        memoryCount: entries.length,\n        sourceIds: entries.map((e) => e.id),\n        builtAt: new Date().toISOString(),\n      };\n      await mkdir(path.dirname(nodePath), { recursive: true });\n      await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n    }\n  }\n\n  /**\n   * Build or update week-level nodes from the day nodes already on disk.\n   * Groups memories by ISO week; for each week that has a day node but no\n   * (or stale) week node, reads day node summaries and builds a week node.\n   * Fail-open: errors per week are caught and skipped.\n   */\n  private async buildWeekNodes(memories: MemoryEntry[], summarize: SummarizeFn): Promise<void> {\n    // Determine which ISO weeks appear in this memory batch\n    const weekToEntries = new Map<string, MemoryEntry[]>();\n    for (const m of memories) {\n      const instant = parseTmtInstant(m.created);\n      if (!instant) continue;\n      const week = isoWeekKey(instant.dateValue);\n      if (!weekToEntries.has(week)) weekToEntries.set(week, []);\n      weekToEntries.get(week)!.push(m);\n    }\n\n    for (const [week, entries] of weekToEntries) {\n      const nodePath = weekNodePath(this.baseDir, week);\n\n      // Rebuild if missing or if memory count grew\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) !== entries.length) {\n            shouldBuild = true;\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) continue;\n\n      try {\n        // Collect day-node summaries for days that fall in this week\n        const dir = tmtDir(this.baseDir);\n        let allDirs: string[] = [];\n        try { allDirs = await readdir(dir); } catch { continue; }\n        const dateDirs = allDirs.filter((d) => /^\\d{4}-\\d{2}-\\d{2}$/.test(d));\n\n        const daySummaries: string[] = [];\n        for (const dateDir of dateDirs) {\n          const w = isoWeekKey(new Date(dateDir + \"T00:00:00Z\"));\n          if (w !== week) continue;\n          const dayPath = dayNodePath(this.baseDir, dateDir);\n          if (fs.existsSync(dayPath)) {\n            try {\n              const content = await readFile(dayPath, \"utf8\");\n              const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n              if (summary) daySummaries.push(summary);\n            } catch { /* skip */ }\n          }\n        }\n\n        // Fall back to raw memory content if no day summaries available\n        const inputs = daySummaries.length > 0 ? daySummaries : entries.map((e) => e.content);\n        const summary = await summarize(capTmtSummaryInputs(inputs, \"week\"), \"week\");\n        const sortedCreated = entries.map((e) => e.created).sort();\n        const fm: TmtNodeFrontmatter = {\n          level: \"week\",\n          periodStart: sortedCreated[0],\n          periodEnd: sortedCreated[sortedCreated.length - 1],\n          memoryCount: entries.length,\n          sourceIds: entries.map((e) => e.id),\n          builtAt: new Date().toISOString(),\n        };\n        await mkdir(path.dirname(nodePath), { recursive: true });\n        await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n      } catch (err) {\n        console.warn(`[engram] tmt: week node build failed for ${week} (ignored): ${err}`);\n      }\n    }\n  }\n\n  /**\n   * Build or update the persona node from the most recent week-level summaries.\n   * Reads up to 4 recent week nodes and synthesizes a persona-level narrative.\n   * Fail-open: skips silently if no week nodes exist or summarize fails.\n   */\n  private async buildPersonaNode(summarize: SummarizeFn): Promise<void> {\n    try {\n      const dir = tmtDir(this.baseDir);\n      let allFiles: string[] = [];\n      try { allFiles = await readdir(dir); } catch { return; }\n\n      const weekFiles = allFiles\n        .filter((f) => /^week-\\d{4}-\\d{2}\\.md$/.test(f))\n        .sort()\n        .reverse()\n        .slice(0, 4); // Use at most 4 recent weeks\n\n      if (weekFiles.length === 0) return;\n\n      const weekSummaries: string[] = [];\n      let totalCount = 0;\n      let earliestStart: string | undefined;\n      let latestEnd: string | undefined;\n      for (const f of weekFiles) {\n        try {\n          const content = await readFile(path.join(dir, f), \"utf8\");\n          const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n          if (summary) weekSummaries.push(summary);\n          const countMatch = content.match(/memoryCount: (\\d+)/);\n          if (countMatch) totalCount += parseInt(countMatch[1], 10);\n          const startMatch = content.match(/periodStart: \"([^\"]+)\"/);\n          const endMatch = content.match(/periodEnd: \"([^\"]+)\"/);\n          if (startMatch) {\n            if (!earliestStart || startMatch[1] < earliestStart) earliestStart = startMatch[1];\n          }\n          if (endMatch) {\n            if (!latestEnd || endMatch[1] > latestEnd) latestEnd = endMatch[1];\n          }\n        } catch { /* skip */ }\n      }\n\n      if (weekSummaries.length === 0) return;\n\n      const nodePath = personaNodePath(this.baseDir);\n\n      // Skip rebuild if persona node already reflects current week data\n      let shouldBuild = !fs.existsSync(nodePath);\n      if (!shouldBuild) {\n        try {\n          const existing = await readFile(nodePath, \"utf8\");\n          const countMatch = existing.match(/memoryCount: (\\d+)/);\n          if (!countMatch || parseInt(countMatch[1], 10) !== totalCount) {\n            shouldBuild = true;\n          }\n        } catch { shouldBuild = true; }\n      }\n      if (!shouldBuild) return;\n\n      const summary = await summarize(capTmtSummaryInputs(weekSummaries, \"persona\"), \"persona\");\n\n      const now = new Date().toISOString();\n      const fm: TmtNodeFrontmatter = {\n        level: \"persona\",\n        periodStart: earliestStart ?? now,\n        periodEnd: latestEnd ?? now,\n        memoryCount: totalCount,\n        sourceIds: [],\n        builtAt: now,\n      };\n      await writeFile(nodePath, serialiseTmtNode(fm, summary), \"utf8\");\n    } catch (err) {\n      console.warn(`[engram] tmt: persona node build failed (ignored): ${err}`);\n    }\n  }\n\n  /**\n   * Return the summary text of the most relevant TMT node for a given prompt.\n   * Preference: day node for today > most recent day node.\n   * Returns null if no nodes exist or feature is disabled.\n   */\n  async getMostRelevantNode(): Promise<{ level: TmtLevel; summary: string } | null> {\n    if (!this.cfg.temporalMemoryTreeEnabled) return null;\n    try {\n      const dir = tmtDir(this.baseDir);\n      if (!fs.existsSync(dir)) return null;\n\n      // Try today's day node first\n      const today = new Date().toISOString().slice(0, 10);\n      const todayDay = dayNodePath(this.baseDir, today);\n      if (fs.existsSync(todayDay)) {\n        const content = await readFile(todayDay, \"utf8\");\n        const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n        if (summary) return { level: \"day\", summary };\n      }\n\n      // Find most recent date directory\n      let entries: string[] = [];\n      try { entries = await readdir(dir); } catch { return null; }\n      const dateDirs = entries.filter((e) => /^\\d{4}-\\d{2}-\\d{2}$/.test(e)).sort().reverse();\n\n      for (const dateDir of dateDirs) {\n        const dayPath = dayNodePath(this.baseDir, dateDir);\n        if (fs.existsSync(dayPath)) {\n          const content = await readFile(dayPath, \"utf8\");\n          const summary = content.replace(/^---[\\s\\S]*?---\\n\\n?/, \"\").trim();\n          if (summary) return { level: \"day\", summary };\n        }\n      }\n      return null;\n    } catch {\n      return null;\n    }\n  }\n}\n"],"mappings":"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","names":["summary"]}

package/dist/{chunk-77H5NU3M.js → chunk-EDBEWFJO.js}

@@ -1,31 +1,29 @@
 import {
+  namespaceCollectionName
+} from "./chunk-7MV5CWTE.js";
+import {
+  ALL_CATEGORY_DIRS,
   NamespaceStorageRouter
-} from "./chunk-RR2PKP3I.js";
+} from "./chunk-CHBI22MI.js";
 import {
-  namespaceCollectionName
-} from "./chunk-575RMLWN.js";
+  namespaceIdentityFromToken,
+  namespaceIdentityToken
+} from "./chunk-ZFXCQPNO.js";
 import {
   isSafeRouteNamespace
 } from "./chunk-U3PN77QT.js";
 
 // src/namespaces/migrate.ts
 import path from "path";
-import { access, mkdir, readdir, rename } from "fs/promises";
+import { access, lstat, mkdir, readdir, realpath, rename, rmdir } from "fs/promises";
 var LEGACY_NAMESPACE_CHILDREN = [
-  "facts",
-  "corrections",
+  ...ALL_CATEGORY_DIRS,
   "entities",
-  "questions",
   "artifacts",
   "identity",
   "state",
   "config",
   "summaries",
-  "procedures",
-  // Issue #564 PR 3: reasoning_trace memories live in their own subtree.
-  // Must be included here so namespace migration moves existing traces
-  // into the target namespace root alongside other memory data.
-  "reasoning-traces",
   "profile.md"
 ];
 async function exists(p) {
@@ -48,12 +46,15 @@ async function discoverConfiguredNamespaces(config) {
     config.sharedNamespace,
     ...config.namespacePolicies.map((policy) => policy.name)
   ]);
+  const configuredNamespaces = new Set(discovered);
   const namespacesDir = path.join(config.memoryDir, "namespaces");
   try {
     const entries = await readdir(namespacesDir, { withFileTypes: true });
     for (const entry of entries) {
-      if (entry.isDirectory() && isSafeRouteNamespace(entry.name)) {
-        discovered.add(entry.name);
+      if (!entry.isDirectory()) continue;
+      const namespace = configuredNamespaces.has(entry.name) ? entry.name : namespaceIdentityFromToken(entry.name) ?? entry.name;
+      if (isSafeRouteNamespace(namespace)) {
+        discovered.add(namespace);
       }
     }
   } catch {
@@ -104,8 +105,13 @@ async function runNamespaceMigration(options) {
   if (!isSafeRouteNamespace(targetNamespace)) {
     throw new Error(`Invalid namespace: ${options.to}`);
   }
-  const targetRoot = path.join(options.config.memoryDir, "namespaces", targetNamespace);
+  const targetRoot = path.join(
+    options.config.memoryDir,
+    "namespaces",
+    namespaceIdentityToken(targetNamespace)
+  );
   const moved = [];
+  const renamePath = options.renameFn ?? rename;
   for (const child of LEGACY_NAMESPACE_CHILDREN) {
     const from = path.join(options.config.memoryDir, child);
     if (!await exists(from)) continue;
@@ -113,12 +119,42 @@ async function runNamespaceMigration(options) {
     if (await exists(to)) {
       throw new Error(`Target already contains ${child}: ${to}`);
     }
+    const sourceStat = await lstat(from);
+    if (sourceStat.isSymbolicLink()) {
+      throw new Error(`Refusing to migrate symlinked legacy path: ${from}`);
+    }
     moved.push({ from, to });
   }
   if (!options.dryRun && moved.length > 0) {
+    await assertSafeNamespaceTarget(options.config.memoryDir, targetRoot);
     await mkdir(targetRoot, { recursive: true });
-    for (const move of moved) {
-      await rename(move.from, move.to);
+    await assertSafeNamespaceTarget(options.config.memoryDir, targetRoot);
+    const completed = [];
+    try {
+      for (const move of moved) {
+        await renamePath(move.from, move.to);
+        completed.push(move);
+      }
+    } catch (cause) {
+      const rollbackErrors = [];
+      for (const move of completed.reverse()) {
+        try {
+          if (!await exists(move.from) && await exists(move.to)) {
+            await rename(move.to, move.from);
+          }
+        } catch (rollbackCause) {
+          rollbackErrors.push(rollbackCause instanceof Error ? rollbackCause.message : String(rollbackCause));
+        }
+      }
+      try {
+        await rmdir(targetRoot);
+      } catch {
+      }
+      const message = cause instanceof Error ? cause.message : String(cause);
+      throw new Error(
+        `Namespace migration failed and was rolled back: ${message}` + (rollbackErrors.length > 0 ? `; rollback errors: ${rollbackErrors.join("; ")}` : ""),
+        { cause }
+      );
     }
   }
   return {
@@ -132,10 +168,38 @@ async function runNamespaceMigration(options) {
     })
   };
 }
+async function assertSafeNamespaceTarget(memoryDir, targetRoot) {
+  const memoryReal = await realpath(memoryDir);
+  const namespacesDir = path.join(memoryDir, "namespaces");
+  if (await exists(namespacesDir)) {
+    const namespacesStat = await lstat(namespacesDir);
+    if (namespacesStat.isSymbolicLink()) {
+      throw new Error(`Refusing to migrate through symlinked namespaces directory: ${namespacesDir}`);
+    }
+    const namespacesReal = await realpath(namespacesDir);
+    if (!isPathInside(memoryReal, namespacesReal)) {
+      throw new Error(`Refusing to migrate through namespaces directory outside memoryDir: ${namespacesDir}`);
+    }
+  }
+  if (await exists(targetRoot)) {
+    const targetStat = await lstat(targetRoot);
+    if (targetStat.isSymbolicLink()) {
+      throw new Error(`Refusing to migrate into symlinked namespace root: ${targetRoot}`);
+    }
+    const targetReal = await realpath(targetRoot);
+    if (!isPathInside(memoryReal, targetReal)) {
+      throw new Error(`Refusing to migrate into namespace root outside memoryDir: ${targetRoot}`);
+    }
+  }
+}
+function isPathInside(root, child) {
+  const relative = path.relative(root, child);
+  return relative === "" || !relative.startsWith("..") && !path.isAbsolute(relative);
+}
 
 export {
   listNamespaces,
   verifyNamespaces,
   runNamespaceMigration
 };
-//# sourceMappingURL=chunk-77H5NU3M.js.map
+//# sourceMappingURL=chunk-EDBEWFJO.js.map

package/dist/chunk-EDBEWFJO.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/namespaces/migrate.ts"],"sourcesContent":["import path from \"node:path\";\nimport { access, lstat, mkdir, readdir, realpath, rename, rmdir } from \"node:fs/promises\";\nimport type { PluginConfig } from \"../types.js\";\nimport { NamespaceStorageRouter } from \"./storage.js\";\nimport { namespaceCollectionName } from \"./search.js\";\nimport { isSafeRouteNamespace } from \"../routing/engine.js\";\nimport { namespaceIdentityFromToken, namespaceIdentityToken } from \"./identity.js\";\nimport { ALL_CATEGORY_DIRS } from \"../utils/category-dir.js\";\n\nconst LEGACY_NAMESPACE_CHILDREN = [\n  ...ALL_CATEGORY_DIRS,\n  \"entities\",\n  \"artifacts\",\n  \"identity\",\n  \"state\",\n  \"config\",\n  \"summaries\",\n  \"profile.md\",\n] as const;\n\nexport interface NamespaceInventoryEntry {\n  namespace: string;\n  rootDir: string;\n  exists: boolean;\n  usesLegacyRoot: boolean;\n  hasMemoryData: boolean;\n  collection: string;\n}\n\nexport interface NamespaceVerifyReport {\n  ok: boolean;\n  problems: string[];\n  namespaces: NamespaceInventoryEntry[];\n}\n\nexport interface NamespaceMigrationMove {\n  from: string;\n  to: string;\n}\n\nexport interface NamespaceMigrationReport {\n  dryRun: boolean;\n  fromRoot: string;\n  targetRoot: string;\n  moved: NamespaceMigrationMove[];\n  collection: string;\n}\n\nasync function exists(p: string): Promise<boolean> {\n  try {\n    await access(p);\n    return true;\n  } catch {\n    return false;\n  }\n}\n\nasync function hasAnyLegacyData(rootDir: string): Promise<boolean> {\n  for (const child of LEGACY_NAMESPACE_CHILDREN) {\n    if (await exists(path.join(rootDir, child))) return true;\n  }\n  return false;\n}\n\nasync function discoverConfiguredNamespaces(\n  config: PluginConfig,\n): Promise<string[]> {\n  const discovered = new Set<string>([\n    config.defaultNamespace,\n    config.sharedNamespace,\n    ...config.namespacePolicies.map((policy) => policy.name),\n  ]);\n  const configuredNamespaces = new Set(discovered);\n\n  const namespacesDir = path.join(config.memoryDir, \"namespaces\");\n  try {\n    const entries = await readdir(namespacesDir, { withFileTypes: true });\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue;\n      const namespace = configuredNamespaces.has(entry.name)\n        ? entry.name\n        : namespaceIdentityFromToken(entry.name) ?? entry.name;\n      if (isSafeRouteNamespace(namespace)) {\n        discovered.add(namespace);\n      }\n    }\n  } catch {\n    // No namespace directory yet.\n  }\n\n  return [...discovered];\n}\n\nexport async function listNamespaces(options: {\n  config: PluginConfig;\n  storageRouter?: NamespaceStorageRouter;\n}): Promise<NamespaceInventoryEntry[]> {\n  const storageRouter = options.storageRouter ?? new NamespaceStorageRouter(options.config);\n  const namespaces = await discoverConfiguredNamespaces(options.config);\n  const items = await Promise.all(\n    namespaces.map(async (namespace) => {\n      const storage = await storageRouter.storageFor(namespace);\n      const usesLegacyRoot =\n        namespace === options.config.defaultNamespace &&\n        storage.dir === options.config.memoryDir;\n      return {\n        namespace,\n        rootDir: storage.dir,\n        exists: await exists(storage.dir),\n        usesLegacyRoot,\n        hasMemoryData: await hasAnyLegacyData(storage.dir),\n        collection: namespaceCollectionName(options.config.qmdCollection, namespace, {\n          defaultNamespace: options.config.defaultNamespace,\n          useLegacyDefaultCollection: usesLegacyRoot,\n        }),\n      } satisfies NamespaceInventoryEntry;\n    }),\n  );\n\n  return items.sort((a, b) => a.namespace.localeCompare(b.namespace));\n}\n\nexport async function verifyNamespaces(options: {\n  config: PluginConfig;\n  storageRouter?: NamespaceStorageRouter;\n}): Promise<NamespaceVerifyReport> {\n  const namespaces = await listNamespaces(options);\n  const problems: string[] = [];\n\n  for (const entry of namespaces) {\n    if (entry.exists && !entry.hasMemoryData) {\n      problems.push(`${entry.namespace}: root exists but contains no Engram data`);\n    }\n  }\n\n  return {\n    ok: problems.length === 0,\n    problems,\n    namespaces,\n  };\n}\n\nexport async function runNamespaceMigration(options: {\n  config: PluginConfig;\n  to: string;\n  dryRun?: boolean;\n  renameFn?: typeof rename;\n}): Promise<NamespaceMigrationReport> {\n  if (!options.config.namespacesEnabled) {\n    throw new Error(\"Namespaces are disabled.\");\n  }\n\n  const targetNamespace = options.to.trim();\n  if (!isSafeRouteNamespace(targetNamespace)) {\n    throw new Error(`Invalid namespace: ${options.to}`);\n  }\n\n  const targetRoot = path.join(\n    options.config.memoryDir,\n    \"namespaces\",\n    namespaceIdentityToken(targetNamespace),\n  );\n  const moved: NamespaceMigrationMove[] = [];\n  const renamePath = options.renameFn ?? rename;\n\n  for (const child of LEGACY_NAMESPACE_CHILDREN) {\n    const from = path.join(options.config.memoryDir, child);\n    if (!(await exists(from))) continue;\n    const to = path.join(targetRoot, child);\n    if (await exists(to)) {\n      throw new Error(`Target already contains ${child}: ${to}`);\n    }\n    const sourceStat = await lstat(from);\n    if (sourceStat.isSymbolicLink()) {\n      throw new Error(`Refusing to migrate symlinked legacy path: ${from}`);\n    }\n    moved.push({ from, to });\n  }\n\n  if (!options.dryRun && moved.length > 0) {\n    await assertSafeNamespaceTarget(options.config.memoryDir, targetRoot);\n    await mkdir(targetRoot, { recursive: true });\n    await assertSafeNamespaceTarget(options.config.memoryDir, targetRoot);\n    const completed: NamespaceMigrationMove[] = [];\n    try {\n      for (const move of moved) {\n        await renamePath(move.from, move.to);\n        completed.push(move);\n      }\n    } catch (cause) {\n      const rollbackErrors: string[] = [];\n      for (const move of completed.reverse()) {\n        try {\n          if (!(await exists(move.from)) && (await exists(move.to))) {\n            await rename(move.to, move.from);\n          }\n        } catch (rollbackCause) {\n          rollbackErrors.push(rollbackCause instanceof Error ? rollbackCause.message : String(rollbackCause));\n        }\n      }\n      try {\n        await rmdir(targetRoot);\n      } catch {\n        // Target may predate migration or still contain unrelated files.\n      }\n      const message = cause instanceof Error ? cause.message : String(cause);\n      throw new Error(\n        `Namespace migration failed and was rolled back: ${message}` +\n          (rollbackErrors.length > 0 ? `; rollback errors: ${rollbackErrors.join(\"; \")}` : \"\"),\n        { cause },\n      );\n    }\n  }\n\n  return {\n    dryRun: options.dryRun === true,\n    fromRoot: options.config.memoryDir,\n    targetRoot,\n    moved,\n    collection: namespaceCollectionName(options.config.qmdCollection, targetNamespace, {\n      defaultNamespace: options.config.defaultNamespace,\n      useLegacyDefaultCollection: false,\n    }),\n  };\n}\n\nasync function assertSafeNamespaceTarget(memoryDir: string, targetRoot: string): Promise<void> {\n  const memoryReal = await realpath(memoryDir);\n  const namespacesDir = path.join(memoryDir, \"namespaces\");\n  if (await exists(namespacesDir)) {\n    const namespacesStat = await lstat(namespacesDir);\n    if (namespacesStat.isSymbolicLink()) {\n      throw new Error(`Refusing to migrate through symlinked namespaces directory: ${namespacesDir}`);\n    }\n    const namespacesReal = await realpath(namespacesDir);\n    if (!isPathInside(memoryReal, namespacesReal)) {\n      throw new Error(`Refusing to migrate through namespaces directory outside memoryDir: ${namespacesDir}`);\n    }\n  }\n  if (await exists(targetRoot)) {\n    const targetStat = await lstat(targetRoot);\n    if (targetStat.isSymbolicLink()) {\n      throw new Error(`Refusing to migrate into symlinked namespace root: ${targetRoot}`);\n    }\n    const targetReal = await realpath(targetRoot);\n    if (!isPathInside(memoryReal, targetReal)) {\n      throw new Error(`Refusing to migrate into namespace root outside memoryDir: ${targetRoot}`);\n    }\n  }\n}\n\nfunction isPathInside(root: string, child: string): boolean {\n  const relative = path.relative(root, child);\n  return relative === \"\" || (!relative.startsWith(\"..\") && !path.isAbsolute(relative));\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-EDQVAMQI.js

@@ -0,0 +1,308 @@
+import {
+  launchProcessSync
+} from "./chunk-NNVTUXEB.js";
+import {
+  expandTildePath
+} from "./chunk-EYIEWJNI.js";
+
+// src/coding/git-context.ts
+import path from "path";
+var DEFAULT_GIT_TIMEOUT_MS = 2e3;
+function defaultGitInvoker() {
+  return (cwd, args) => {
+    const result = launchProcessSync("git", args, {
+      cwd,
+      encoding: "utf-8",
+      timeout: DEFAULT_GIT_TIMEOUT_MS,
+      shell: false
+    });
+    if (result.error) {
+      return { stdout: "", exitCode: 127 };
+    }
+    return {
+      stdout: typeof result.stdout === "string" ? result.stdout : "",
+      exitCode: typeof result.status === "number" ? result.status : 1
+    };
+  };
+}
+function stableHash(input) {
+  let hash = 2166136261;
+  for (let i = 0; i < input.length; i++) {
+    hash ^= input.charCodeAt(i);
+    hash = Math.imul(hash, 16777619) >>> 0;
+  }
+  return hash.toString(16).padStart(8, "0");
+}
+function normalizeOriginUrl(rawUrl) {
+  let url = rawUrl.trim();
+  if (!url) return "";
+  if (/\.git$/i.test(url)) url = url.slice(0, -4);
+  if (/^[A-Za-z]:[\\/]/.test(url)) {
+    return url.toLowerCase();
+  }
+  const protoMatch = /^[a-z][a-z0-9+.-]*:\/\/(?:[^@/]+@)?(\[[^\]]+\]|[^/:]*)(?::(\d+))?(\/.*)?$/i.exec(url);
+  if (protoMatch) {
+    let host = protoMatch[1] ?? "";
+    const wasBracketed = host.startsWith("[") && host.endsWith("]");
+    if (wasBracketed) host = host.slice(1, -1);
+    const port = protoMatch[2];
+    const repoPath = (protoMatch[3] ?? "").replace(/^\/+/, "");
+    const hostPort = port ? wasBracketed ? `[${host}]:${port}` : `${host}:${port}` : host;
+    const prefix = hostPort.length > 0 ? hostPort : "localhost";
+    return `${prefix}/${repoPath}`.toLowerCase();
+  }
+  const scpMatch = /^(?:([^@\s/]+)@)?(\[[^\]]+\]|[^:@\s/]+):(.+)$/.exec(url);
+  if (scpMatch) {
+    let host = scpMatch[2] ?? "";
+    if (host.startsWith("[") && host.endsWith("]")) host = host.slice(1, -1);
+    const repoPath = scpMatch[3] ?? "";
+    if (repoPath.startsWith("//")) {
+      return url.toLowerCase();
+    }
+    return `${host}/${repoPath.replace(/^\/+/, "")}`.toLowerCase();
+  }
+  return url.toLowerCase();
+}
+async function resolveGitContext(cwd, options = {}) {
+  try {
+    if (typeof cwd !== "string" || cwd.length === 0) return null;
+    const expanded = expandTildePath(cwd);
+    if (!path.isAbsolute(expanded)) return null;
+    const invoker = options.invoker ?? defaultGitInvoker();
+    const topLevel = invoker(expanded, ["rev-parse", "--show-toplevel"]);
+    if (topLevel.exitCode !== 0) return null;
+    const rootPath = topLevel.stdout.trim();
+    if (!rootPath) return null;
+    const branchResult = invoker(rootPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    let branch = null;
+    if (branchResult.exitCode === 0) {
+      const raw = branchResult.stdout.trim();
+      branch = raw && raw !== "HEAD" ? raw : null;
+    } else {
+      const unbornRef = invoker(rootPath, ["symbolic-ref", "--quiet", "HEAD"]);
+      if (unbornRef.exitCode === 0) {
+        const raw = unbornRef.stdout.trim();
+        const prefix = "refs/heads/";
+        if (raw.startsWith(prefix)) {
+          const candidate = raw.slice(prefix.length);
+          if (candidate) branch = candidate;
+        }
+      }
+    }
+    const originResult = invoker(rootPath, ["remote", "get-url", "origin"]);
+    let projectId;
+    if (originResult.exitCode === 0) {
+      const normalized = normalizeOriginUrl(originResult.stdout);
+      projectId = normalized ? `origin:${stableHash(normalized)}` : `root:${stableHash(rootPath)}`;
+    } else {
+      projectId = `root:${stableHash(rootPath)}`;
+    }
+    const headRef = invoker(rootPath, ["symbolic-ref", "--quiet", "refs/remotes/origin/HEAD"]);
+    let defaultBranch = null;
+    if (headRef.exitCode === 0) {
+      const raw = headRef.stdout.trim();
+      const prefix = "refs/remotes/origin/";
+      if (raw.startsWith(prefix)) {
+        const candidate = raw.slice(prefix.length);
+        if (candidate) defaultBranch = candidate;
+      }
+    }
+    return {
+      projectId,
+      branch,
+      rootPath,
+      defaultBranch
+    };
+  } catch {
+    return null;
+  }
+}
+
+// src/coding/coding-namespace.ts
+function sanitizeFragment(input) {
+  if (typeof input !== "string") return "";
+  const trimmed = input.trim().toLowerCase();
+  let out = "";
+  let prevIsDash = true;
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const c = trimmed[i];
+    const cc = trimmed.charCodeAt(i);
+    const isSafe = cc >= 48 && cc <= 57 || cc >= 97 && cc <= 122 || cc === 46 || cc === 95;
+    if (isSafe) {
+      out += c;
+      prevIsDash = false;
+    } else if (!prevIsDash) {
+      out += "-";
+      prevIsDash = true;
+    }
+  }
+  if (out.endsWith("-")) out = out.slice(0, -1);
+  return out;
+}
+var MAX_NAMESPACE_LEN = 64;
+var HASH_SUFFIX_LEN = 9;
+function capLength(value) {
+  if (value.length <= MAX_NAMESPACE_LEN) return value;
+  const hash = stableHash(value);
+  let end = MAX_NAMESPACE_LEN - HASH_SUFFIX_LEN;
+  while (end > 0 && value.charCodeAt(end - 1) === 45) end -= 1;
+  return `${value.slice(0, end)}-${hash}`;
+}
+function projectNamespaceName(projectId) {
+  const frag = sanitizeFragment(projectId);
+  return capLength(`project-${frag || "unknown"}`);
+}
+function projectTagProjectId(projectTag) {
+  const trimmed = projectTag.trim();
+  const frag = sanitizeFragment(trimmed);
+  const disambig = trimmed.length > 0 && frag !== trimmed;
+  const suffix = disambig ? `-${stableHash(trimmed)}` : "";
+  return `tag:${frag || "unknown"}${suffix}`;
+}
+function sanitizeBaseFragment(input) {
+  if (typeof input !== "string") return "";
+  const trimmed = input.trim();
+  let out = "";
+  let prevIsDash = true;
+  for (let i = 0; i < trimmed.length; i += 1) {
+    const c = trimmed[i];
+    const cc = trimmed.charCodeAt(i);
+    const isSafe = cc >= 48 && cc <= 57 || cc >= 65 && cc <= 90 || cc >= 97 && cc <= 122 || cc === 46 || cc === 95;
+    if (isSafe) {
+      out += c;
+      prevIsDash = false;
+    } else if (!prevIsDash) {
+      out += "-";
+      prevIsDash = true;
+    }
+  }
+  if (out.endsWith("-")) out = out.slice(0, -1);
+  return out;
+}
+function combineNamespaces(base, overlay) {
+  const baseFrag = sanitizeBaseFragment(base);
+  const overlayFrag = sanitizeFragment(overlay);
+  if (!baseFrag) return capLength(overlayFrag || "unknown");
+  if (!overlayFrag) return capLength(baseFrag);
+  return capLength(`${baseFrag}-${overlayFrag}`);
+}
+function branchNamespaceName(projectId, branch) {
+  const projectFrag = sanitizeFragment(projectId);
+  const trimmedBranch = branch.trim();
+  const branchFrag = sanitizeFragment(trimmedBranch);
+  const disambig = trimmedBranch.length > 0 && branchFrag !== trimmedBranch;
+  const base = `project-${projectFrag || "unknown"}-branch-${branchFrag || "unknown"}`;
+  const suffixed = disambig ? `${base}-${stableHash(trimmedBranch)}` : base;
+  return capLength(suffixed);
+}
+function resolveCodingNamespaceOverlay(codingContext, config, defaultNamespace) {
+  if (!codingContext) return null;
+  if (!config.projectScope) return null;
+  const projectId = typeof codingContext.projectId === "string" ? codingContext.projectId.trim() : "";
+  if (!projectId) return null;
+  const projectNs = projectNamespaceName(projectId);
+  const includeRoot = config.globalFallback === true;
+  if (config.branchScope && typeof codingContext.branch === "string" && codingContext.branch.length > 0) {
+    const branchNs = branchNamespaceName(projectId, codingContext.branch);
+    const fallbacks = [projectNs];
+    if (includeRoot) fallbacks.push("");
+    return {
+      namespace: branchNs,
+      readFallbacks: fallbacks,
+      scope: "branch"
+    };
+  }
+  return {
+    namespace: projectNs,
+    readFallbacks: includeRoot ? [""] : [],
+    scope: "project"
+  };
+}
+function describeCodingScope(codingContext, config, defaultNamespace) {
+  const projectId = codingContext?.projectId ?? null;
+  const branch = codingContext?.branch ?? null;
+  if (!codingContext) {
+    return {
+      scope: "none",
+      projectId: null,
+      branch: null,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "no-context"
+    };
+  }
+  if (!config.projectScope) {
+    return {
+      scope: "none",
+      projectId,
+      branch,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "disabled"
+    };
+  }
+  const trimmedId = typeof projectId === "string" ? projectId.trim() : "";
+  if (!trimmedId) {
+    return {
+      scope: "none",
+      projectId,
+      branch,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "empty-project"
+    };
+  }
+  const overlay = resolveCodingNamespaceOverlay(codingContext, config, defaultNamespace);
+  if (!overlay) {
+    return {
+      scope: "none",
+      projectId,
+      branch,
+      effectiveNamespace: null,
+      readFallbacks: [],
+      disabledReason: "disabled"
+    };
+  }
+  return {
+    scope: overlay.scope,
+    projectId,
+    branch,
+    effectiveNamespace: overlay.namespace,
+    readFallbacks: overlay.readFallbacks,
+    disabledReason: null
+  };
+}
+
+// src/procedural/reinforcement-core.ts
+function clusterByKey(items, keyFn) {
+  const clusters = /* @__PURE__ */ new Map();
+  for (const item of items) {
+    const key = keyFn(item);
+    if (typeof key !== "string") {
+      throw new TypeError(
+        `clusterByKey: keyFn must return a string, got ${key === null ? "null" : typeof key}`
+      );
+    }
+    const existing = clusters.get(key);
+    if (existing) {
+      existing.push(item);
+    } else {
+      clusters.set(key, [item]);
+    }
+  }
+  return clusters;
+}
+
+export {
+  clusterByKey,
+  stableHash,
+  normalizeOriginUrl,
+  resolveGitContext,
+  projectNamespaceName,
+  projectTagProjectId,
+  combineNamespaces,
+  branchNamespaceName,
+  resolveCodingNamespaceOverlay,
+  describeCodingScope
+};
+//# sourceMappingURL=chunk-EDQVAMQI.js.map