@remnic/core 1.0.0

package/dist/chunk-NTTLPF7F.js

@@ -0,0 +1,283 @@
+import {
+  topicOverlapScore
+} from "./chunk-M5KEYE5E.js";
+import {
+  countRecallTokenOverlap,
+  normalizeRecallTokens
+} from "./chunk-DT5TVLJE.js";
+import {
+  log
+} from "./chunk-KWBU5S5U.js";
+import {
+  assertIsoRecordedAt,
+  assertString,
+  isRecord,
+  recordStoreDay
+} from "./chunk-DGXUHMOV.js";
+import {
+  listJsonFiles,
+  readJsonFile
+} from "./chunk-LPSF4OQH.js";
+
+// src/causal-chain.ts
+import path from "path";
+import { mkdir, readFile, writeFile } from "fs/promises";
+import { createHash } from "crypto";
+var STITCH_WEIGHTS = {
+  followUpToGoal: 4,
+  outcomeToGoal: 2,
+  entityOverlap: 3,
+  tagOverlap: 1.5,
+  temporalProximity: 1
+};
+function validateCausalEdge(raw) {
+  if (!isRecord(raw)) throw new Error("CausalEdge must be an object");
+  if (raw.schemaVersion !== 1) throw new Error("CausalEdge.schemaVersion must be 1");
+  const edgeType = assertString(raw.edgeType, "edgeType");
+  const validEdgeTypes = ["follow_up_to_goal", "retry", "continuation", "correction"];
+  if (!validEdgeTypes.includes(edgeType)) {
+    throw new Error(`CausalEdge.edgeType must be one of ${validEdgeTypes.join(", ")}`);
+  }
+  const stitchMethod = assertString(raw.stitchMethod, "stitchMethod");
+  const validMethods = ["lexical", "entity", "temporal", "explicit"];
+  if (!validMethods.includes(stitchMethod)) {
+    throw new Error(`CausalEdge.stitchMethod must be one of ${validMethods.join(", ")}`);
+  }
+  const confidence = typeof raw.confidence === "number" ? raw.confidence : 0;
+  if (confidence < 0 || confidence > 1) throw new Error("CausalEdge.confidence must be in [0, 1]");
+  return {
+    schemaVersion: 1,
+    edgeId: assertString(raw.edgeId, "edgeId"),
+    fromTrajectoryId: assertString(raw.fromTrajectoryId, "fromTrajectoryId"),
+    toTrajectoryId: assertString(raw.toTrajectoryId, "toTrajectoryId"),
+    edgeType,
+    confidence,
+    stitchMethod,
+    createdAt: assertIsoRecordedAt(assertString(raw.createdAt, "createdAt")),
+    metadata: isRecord(raw.metadata) ? Object.fromEntries(
+      Object.entries(raw.metadata).filter(
+        (entry) => typeof entry[1] === "string"
+      )
+    ) : void 0
+  };
+}
+function makeEdgeId(fromId, toId) {
+  const digest = createHash("sha256").update(`${fromId}\0${toId}`).digest("hex").slice(0, 12);
+  return `edge-${digest}`;
+}
+function resolveChainsDir(memoryDir, causalTrajectoryStoreDir) {
+  const root = causalTrajectoryStoreDir ? path.join(memoryDir, causalTrajectoryStoreDir) : path.join(memoryDir, "state", "causal-trajectories");
+  return path.join(root, "chains");
+}
+function chainIndexPath(chainsDir) {
+  return path.join(chainsDir, "chain-index.json");
+}
+function edgeFilePath(chainsDir, edge) {
+  const day = recordStoreDay(edge.createdAt);
+  return path.join(chainsDir, "edges", day, `${edge.edgeId}.json`);
+}
+async function readChainIndex(chainsDir) {
+  try {
+    const raw = JSON.parse(await readFile(chainIndexPath(chainsDir), "utf8"));
+    return {
+      outgoing: isRecord(raw.outgoing) ? raw.outgoing : {},
+      incoming: isRecord(raw.incoming) ? raw.incoming : {},
+      edges: isRecord(raw.edges) ? raw.edges : {},
+      updatedAt: typeof raw.updatedAt === "string" ? raw.updatedAt : (/* @__PURE__ */ new Date()).toISOString()
+    };
+  } catch {
+    return { outgoing: {}, incoming: {}, edges: {}, updatedAt: (/* @__PURE__ */ new Date()).toISOString() };
+  }
+}
+async function writeChainIndex(chainsDir, index) {
+  await mkdir(chainsDir, { recursive: true });
+  index.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  await writeFile(chainIndexPath(chainsDir), JSON.stringify(index, null, 2), "utf8");
+}
+async function persistEdge(chainsDir, edge) {
+  const filePath = edgeFilePath(chainsDir, edge);
+  await mkdir(path.dirname(filePath), { recursive: true });
+  await writeFile(filePath, JSON.stringify(edge, null, 2), "utf8");
+  return filePath;
+}
+function addEdgeToIndex(index, edge) {
+  if (!index.outgoing[edge.fromTrajectoryId]) {
+    index.outgoing[edge.fromTrajectoryId] = [];
+  }
+  if (!index.outgoing[edge.fromTrajectoryId].includes(edge.edgeId)) {
+    index.outgoing[edge.fromTrajectoryId].push(edge.edgeId);
+  }
+  if (!index.incoming[edge.toTrajectoryId]) {
+    index.incoming[edge.toTrajectoryId] = [];
+  }
+  if (!index.incoming[edge.toTrajectoryId].includes(edge.edgeId)) {
+    index.incoming[edge.toTrajectoryId].push(edge.edgeId);
+  }
+  index.edges[edge.edgeId] = edge;
+}
+function scoreStitchCandidate(newTrajectory, candidate) {
+  let score = 0;
+  let dominantMethod = "lexical";
+  let maxComponent = 0;
+  const newFollowUpTokens = new Set(
+    normalizeRecallTokens(newTrajectory.followUpSummary ?? "", [])
+  );
+  const candidateGoalTokens = normalizeRecallTokens(candidate.goal, []);
+  if (newFollowUpTokens.size > 0 && candidateGoalTokens.length > 0) {
+    const overlap = countRecallTokenOverlap(newFollowUpTokens, candidate.goal, []);
+    const normalized = overlap / Math.max(newFollowUpTokens.size, candidateGoalTokens.length);
+    const component = normalized * STITCH_WEIGHTS.followUpToGoal;
+    score += component;
+    if (component > maxComponent) {
+      maxComponent = component;
+      dominantMethod = "lexical";
+    }
+  }
+  const candidateFollowUpTokens = new Set(
+    normalizeRecallTokens(candidate.followUpSummary ?? "", [])
+  );
+  const newGoalTokens = normalizeRecallTokens(newTrajectory.goal, []);
+  if (candidateFollowUpTokens.size > 0 && newGoalTokens.length > 0) {
+    const overlap = countRecallTokenOverlap(candidateFollowUpTokens, newTrajectory.goal, []);
+    const normalized = overlap / Math.max(candidateFollowUpTokens.size, newGoalTokens.length);
+    const component = normalized * 3;
+    score += component;
+    if (component > maxComponent) {
+      maxComponent = component;
+      dominantMethod = "lexical";
+    }
+  }
+  const newOutcomeTokens = new Set(
+    normalizeRecallTokens(newTrajectory.outcomeSummary, [])
+  );
+  if (newOutcomeTokens.size > 0) {
+    const overlap = countRecallTokenOverlap(newOutcomeTokens, candidate.goal, []);
+    const normalized = overlap / Math.max(newOutcomeTokens.size, candidateGoalTokens.length || 1);
+    const component = normalized * STITCH_WEIGHTS.outcomeToGoal;
+    score += component;
+    if (component > maxComponent) {
+      maxComponent = component;
+      dominantMethod = "lexical";
+    }
+  }
+  const newEntities = newTrajectory.entityRefs ?? [];
+  const candidateEntities = candidate.entityRefs ?? [];
+  if (newEntities.length > 0 && candidateEntities.length > 0) {
+    const entityJaccard = topicOverlapScore(newEntities, candidateEntities);
+    const component = entityJaccard * STITCH_WEIGHTS.entityOverlap;
+    score += component;
+    if (component > maxComponent) {
+      maxComponent = component;
+      dominantMethod = "entity";
+    }
+  }
+  const newTags = newTrajectory.tags ?? [];
+  const candidateTags = candidate.tags ?? [];
+  if (newTags.length > 0 && candidateTags.length > 0) {
+    const tagJaccard = topicOverlapScore(newTags, candidateTags);
+    const component = tagJaccard * STITCH_WEIGHTS.tagOverlap;
+    score += component;
+    if (component > maxComponent) {
+      maxComponent = component;
+      dominantMethod = "lexical";
+    }
+  }
+  const newMs = Date.parse(newTrajectory.recordedAt);
+  const candidateMs = Date.parse(candidate.recordedAt);
+  if (Number.isFinite(newMs) && Number.isFinite(candidateMs)) {
+    const gapHours = Math.abs(newMs - candidateMs) / 36e5;
+    const proximity = 1 / (1 + gapHours / 24);
+    const component = proximity * STITCH_WEIGHTS.temporalProximity;
+    score += component;
+    if (component > maxComponent) {
+      maxComponent = component;
+      dominantMethod = "temporal";
+    }
+  }
+  let edgeType = "continuation";
+  const goalTokens = new Set(normalizeRecallTokens(newTrajectory.goal, []));
+  const candidateGoalSet = new Set(candidateGoalTokens);
+  const goalOverlap = [...goalTokens].filter((t) => candidateGoalSet.has(t)).length;
+  const goalSimilarity = goalTokens.size > 0 ? goalOverlap / goalTokens.size : 0;
+  if (goalSimilarity > 0.7 && candidate.outcomeKind === "failure") {
+    edgeType = "retry";
+  } else if (goalSimilarity > 0.7 && newTrajectory.outcomeKind !== candidate.outcomeKind) {
+    edgeType = "correction";
+  } else if (newFollowUpTokens.size > 0 && candidateGoalTokens.length > 0) {
+    const followUpGoalOverlap = countRecallTokenOverlap(newFollowUpTokens, candidate.goal, []);
+    if (followUpGoalOverlap > 0) {
+      edgeType = "follow_up_to_goal";
+    }
+  }
+  return { trajectory: candidate, score, edgeType, stitchMethod: dominantMethod };
+}
+async function readRecentTrajectories(memoryDir, causalTrajectoryStoreDir, currentSessionKey, lookbackDays) {
+  const root = causalTrajectoryStoreDir ? path.join(memoryDir, causalTrajectoryStoreDir) : path.join(memoryDir, "state", "causal-trajectories");
+  const trajectoriesDir = path.join(root, "trajectories");
+  const files = await listJsonFiles(trajectoriesDir).catch(() => []);
+  if (files.length === 0) return [];
+  const cutoff = Date.now() - lookbackDays * 864e5;
+  const results = [];
+  for (const filePath of files) {
+    try {
+      const raw = await readJsonFile(filePath);
+      if (!isRecord(raw)) continue;
+      const sessionKey = typeof raw.sessionKey === "string" ? raw.sessionKey : "";
+      if (sessionKey === currentSessionKey) continue;
+      const recordedAt = typeof raw.recordedAt === "string" ? raw.recordedAt : "";
+      const ms = Date.parse(recordedAt);
+      if (!Number.isFinite(ms) || ms < cutoff) continue;
+      results.push(raw);
+    } catch {
+    }
+  }
+  return results;
+}
+async function stitchCausalChain(options) {
+  const { memoryDir, causalTrajectoryStoreDir, newTrajectory, config: stitchConfig } = options;
+  const chainsDir = resolveChainsDir(memoryDir, causalTrajectoryStoreDir);
+  const candidates = await readRecentTrajectories(
+    memoryDir,
+    causalTrajectoryStoreDir,
+    newTrajectory.sessionKey,
+    stitchConfig.lookbackDays
+  );
+  if (candidates.length === 0) return [];
+  const scored = candidates.map((c) => scoreStitchCandidate(newTrajectory, c)).filter((s) => s.score >= stitchConfig.minScore).sort((a, b) => b.score - a.score).slice(0, stitchConfig.maxEdgesPerTrajectory);
+  if (scored.length === 0) return [];
+  const index = await readChainIndex(chainsDir);
+  const newEdges = [];
+  for (const candidate of scored) {
+    const edgeId = makeEdgeId(candidate.trajectory.trajectoryId, newTrajectory.trajectoryId);
+    if (index.edges[edgeId]) continue;
+    const edge = {
+      schemaVersion: 1,
+      edgeId,
+      fromTrajectoryId: candidate.trajectory.trajectoryId,
+      toTrajectoryId: newTrajectory.trajectoryId,
+      edgeType: candidate.edgeType,
+      confidence: Math.min(1, candidate.score / 10),
+      stitchMethod: candidate.stitchMethod,
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    addEdgeToIndex(index, edge);
+    await persistEdge(chainsDir, edge);
+    newEdges.push(edge);
+  }
+  if (newEdges.length > 0) {
+    await writeChainIndex(chainsDir, index);
+    log.debug(`[cmc] stitched ${newEdges.length} causal edge(s) for trajectory ${newTrajectory.trajectoryId}`);
+  }
+  return newEdges;
+}
+
+export {
+  validateCausalEdge,
+  makeEdgeId,
+  resolveChainsDir,
+  readChainIndex,
+  writeChainIndex,
+  scoreStitchCandidate,
+  stitchCausalChain
+};
+//# sourceMappingURL=chunk-NTTLPF7F.js.map

package/dist/chunk-NTTLPF7F.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/causal-chain.ts"],"sourcesContent":["/**\n * causal-chain.ts — Cross-session causal chain persistence for CMC.\n *\n * Stitches causal trajectories across session boundaries by detecting\n * when a trajectory in one session follows up on a trajectory from\n * another session. Persists edges in a graph index for later retrieval.\n */\n\nimport path from \"node:path\";\nimport { mkdir, readFile, writeFile } from \"node:fs/promises\";\nimport { createHash } from \"node:crypto\";\nimport { listJsonFiles, readJsonFile } from \"./json-store.js\";\nimport type { CausalTrajectoryRecord } from \"./causal-trajectory.js\";\nimport { topicOverlapScore } from \"./boxes.js\";\nimport { countRecallTokenOverlap, normalizeRecallTokens } from \"./recall-tokenization.js\";\nimport {\n  assertIsoRecordedAt,\n  assertString,\n  isRecord,\n  recordStoreDay,\n} from \"./store-contract.js\";\nimport { log } from \"./logger.js\";\n\n// ─── Types ───────────────────────────────────────────────────────────────────\n\nexport interface CausalEdge {\n  schemaVersion: 1;\n  edgeId: string;\n  fromTrajectoryId: string;\n  toTrajectoryId: string;\n  edgeType: \"follow_up_to_goal\" | \"retry\" | \"continuation\" | \"correction\";\n  confidence: number;\n  stitchMethod: \"lexical\" | \"entity\" | \"temporal\" | \"explicit\";\n  createdAt: string;\n  metadata?: Record<string, string>;\n}\n\nexport interface CausalChainIndex {\n  outgoing: Record<string, string[]>;\n  incoming: Record<string, string[]>;\n  edges: Record<string, CausalEdge>;\n  updatedAt: string;\n}\n\nexport interface StitchConfig {\n  lookbackDays: number;\n  minScore: number;\n  maxEdgesPerTrajectory: number;\n}\n\nexport interface StitchCandidate {\n  trajectory: CausalTrajectoryRecord;\n  score: number;\n  edgeType: CausalEdge[\"edgeType\"];\n  stitchMethod: CausalEdge[\"stitchMethod\"];\n}\n\n// ─── Scoring Weights ─────────────────────────────────────────────────────────\n\nconst STITCH_WEIGHTS = {\n  followUpToGoal: 4.0,\n  outcomeToGoal: 2.0,\n  entityOverlap: 3.0,\n  tagOverlap: 1.5,\n  temporalProximity: 1.0,\n} as const;\n\n// ─── Validation ──────────────────────────────────────────────────────────────\n\nexport function validateCausalEdge(raw: unknown): CausalEdge {\n  if (!isRecord(raw)) throw new Error(\"CausalEdge must be an object\");\n  if (raw.schemaVersion !== 1) throw new Error(\"CausalEdge.schemaVersion must be 1\");\n\n  const edgeType = assertString(raw.edgeType, \"edgeType\");\n  const validEdgeTypes = [\"follow_up_to_goal\", \"retry\", \"continuation\", \"correction\"];\n  if (!validEdgeTypes.includes(edgeType)) {\n    throw new Error(`CausalEdge.edgeType must be one of ${validEdgeTypes.join(\", \")}`);\n  }\n\n  const stitchMethod = assertString(raw.stitchMethod, \"stitchMethod\");\n  const validMethods = [\"lexical\", \"entity\", \"temporal\", \"explicit\"];\n  if (!validMethods.includes(stitchMethod)) {\n    throw new Error(`CausalEdge.stitchMethod must be one of ${validMethods.join(\", \")}`);\n  }\n\n  const confidence = typeof raw.confidence === \"number\" ? raw.confidence : 0;\n  if (confidence < 0 || confidence > 1) throw new Error(\"CausalEdge.confidence must be in [0, 1]\");\n\n  return {\n    schemaVersion: 1,\n    edgeId: assertString(raw.edgeId, \"edgeId\"),\n    fromTrajectoryId: assertString(raw.fromTrajectoryId, \"fromTrajectoryId\"),\n    toTrajectoryId: assertString(raw.toTrajectoryId, \"toTrajectoryId\"),\n    edgeType: edgeType as CausalEdge[\"edgeType\"],\n    confidence: confidence,\n    stitchMethod: stitchMethod as CausalEdge[\"stitchMethod\"],\n    createdAt: assertIsoRecordedAt(assertString(raw.createdAt, \"createdAt\")),\n    metadata: isRecord(raw.metadata)\n      ? Object.fromEntries(\n          Object.entries(raw.metadata).filter(\n            (entry): entry is [string, string] => typeof entry[1] === \"string\",\n          ),\n        )\n      : undefined,\n  };\n}\n\n// ─── Stable Edge ID ──────────────────────────────────────────────────────────\n\nexport function makeEdgeId(fromId: string, toId: string): string {\n  const digest = createHash(\"sha256\")\n    .update(`${fromId}\\0${toId}`)\n    .digest(\"hex\")\n    .slice(0, 12);\n  return `edge-${digest}`;\n}\n\n// ─── Storage Paths ───────────────────────────────────────────────────────────\n\nexport function resolveChainsDir(memoryDir: string, causalTrajectoryStoreDir?: string): string {\n  const root = causalTrajectoryStoreDir\n    ? path.join(memoryDir, causalTrajectoryStoreDir)\n    : path.join(memoryDir, \"state\", \"causal-trajectories\");\n  return path.join(root, \"chains\");\n}\n\nfunction chainIndexPath(chainsDir: string): string {\n  return path.join(chainsDir, \"chain-index.json\");\n}\n\nfunction edgeFilePath(chainsDir: string, edge: CausalEdge): string {\n  const day = recordStoreDay(edge.createdAt);\n  return path.join(chainsDir, \"edges\", day, `${edge.edgeId}.json`);\n}\n\n// ─── Chain Index CRUD ────────────────────────────────────────────────────────\n\nexport async function readChainIndex(chainsDir: string): Promise<CausalChainIndex> {\n  try {\n    const raw = JSON.parse(await readFile(chainIndexPath(chainsDir), \"utf8\"));\n    return {\n      outgoing: isRecord(raw.outgoing) ? raw.outgoing as Record<string, string[]> : {},\n      incoming: isRecord(raw.incoming) ? raw.incoming as Record<string, string[]> : {},\n      edges: isRecord(raw.edges) ? raw.edges as Record<string, CausalEdge> : {},\n      updatedAt: typeof raw.updatedAt === \"string\" ? raw.updatedAt : new Date().toISOString(),\n    };\n  } catch {\n    return { outgoing: {}, incoming: {}, edges: {}, updatedAt: new Date().toISOString() };\n  }\n}\n\nexport async function writeChainIndex(chainsDir: string, index: CausalChainIndex): Promise<void> {\n  await mkdir(chainsDir, { recursive: true });\n  index.updatedAt = new Date().toISOString();\n  await writeFile(chainIndexPath(chainsDir), JSON.stringify(index, null, 2), \"utf8\");\n}\n\nasync function persistEdge(chainsDir: string, edge: CausalEdge): Promise<string> {\n  const filePath = edgeFilePath(chainsDir, edge);\n  await mkdir(path.dirname(filePath), { recursive: true });\n  await writeFile(filePath, JSON.stringify(edge, null, 2), \"utf8\");\n  return filePath;\n}\n\nfunction addEdgeToIndex(index: CausalChainIndex, edge: CausalEdge): void {\n  if (!index.outgoing[edge.fromTrajectoryId]) {\n    index.outgoing[edge.fromTrajectoryId] = [];\n  }\n  if (!index.outgoing[edge.fromTrajectoryId].includes(edge.edgeId)) {\n    index.outgoing[edge.fromTrajectoryId].push(edge.edgeId);\n  }\n\n  if (!index.incoming[edge.toTrajectoryId]) {\n    index.incoming[edge.toTrajectoryId] = [];\n  }\n  if (!index.incoming[edge.toTrajectoryId].includes(edge.edgeId)) {\n    index.incoming[edge.toTrajectoryId].push(edge.edgeId);\n  }\n\n  index.edges[edge.edgeId] = edge;\n}\n\n// ─── Stitching Algorithm ─────────────────────────────────────────────────────\n\n/**\n * Score how strongly a candidate trajectory from another session\n * relates to the new trajectory being recorded.\n */\nexport function scoreStitchCandidate(\n  newTrajectory: CausalTrajectoryRecord,\n  candidate: CausalTrajectoryRecord,\n): StitchCandidate {\n  let score = 0;\n  let dominantMethod: CausalEdge[\"stitchMethod\"] = \"lexical\";\n  let maxComponent = 0;\n\n  // 1. Follow-up → Goal match (token overlap)\n  const newFollowUpTokens = new Set(\n    normalizeRecallTokens(newTrajectory.followUpSummary ?? \"\", []),\n  );\n  const candidateGoalTokens = normalizeRecallTokens(candidate.goal, []);\n  if (newFollowUpTokens.size > 0 && candidateGoalTokens.length > 0) {\n    const overlap = countRecallTokenOverlap(newFollowUpTokens, candidate.goal, []);\n    const normalized = overlap / Math.max(newFollowUpTokens.size, candidateGoalTokens.length);\n    const component = normalized * STITCH_WEIGHTS.followUpToGoal;\n    score += component;\n    if (component > maxComponent) {\n      maxComponent = component;\n      dominantMethod = \"lexical\";\n    }\n  }\n\n  // 1b. Candidate follow-up → New goal match (reverse direction)\n  const candidateFollowUpTokens = new Set(\n    normalizeRecallTokens(candidate.followUpSummary ?? \"\", []),\n  );\n  const newGoalTokens = normalizeRecallTokens(newTrajectory.goal, []);\n  if (candidateFollowUpTokens.size > 0 && newGoalTokens.length > 0) {\n    const overlap = countRecallTokenOverlap(candidateFollowUpTokens, newTrajectory.goal, []);\n    const normalized = overlap / Math.max(candidateFollowUpTokens.size, newGoalTokens.length);\n    const component = normalized * 3.0;\n    score += component;\n    if (component > maxComponent) {\n      maxComponent = component;\n      dominantMethod = \"lexical\";\n    }\n  }\n\n  // 2. Outcome → Goal match\n  const newOutcomeTokens = new Set(\n    normalizeRecallTokens(newTrajectory.outcomeSummary, []),\n  );\n  if (newOutcomeTokens.size > 0) {\n    const overlap = countRecallTokenOverlap(newOutcomeTokens, candidate.goal, []);\n    const normalized = overlap / Math.max(newOutcomeTokens.size, candidateGoalTokens.length || 1);\n    const component = normalized * STITCH_WEIGHTS.outcomeToGoal;\n    score += component;\n    if (component > maxComponent) {\n      maxComponent = component;\n      dominantMethod = \"lexical\";\n    }\n  }\n\n  // 3. Entity overlap (Jaccard)\n  const newEntities = newTrajectory.entityRefs ?? [];\n  const candidateEntities = candidate.entityRefs ?? [];\n  if (newEntities.length > 0 && candidateEntities.length > 0) {\n    const entityJaccard = topicOverlapScore(newEntities, candidateEntities);\n    const component = entityJaccard * STITCH_WEIGHTS.entityOverlap;\n    score += component;\n    if (component > maxComponent) {\n      maxComponent = component;\n      dominantMethod = \"entity\";\n    }\n  }\n\n  // 4. Tag overlap (Jaccard)\n  const newTags = newTrajectory.tags ?? [];\n  const candidateTags = candidate.tags ?? [];\n  if (newTags.length > 0 && candidateTags.length > 0) {\n    const tagJaccard = topicOverlapScore(newTags, candidateTags);\n    const component = tagJaccard * STITCH_WEIGHTS.tagOverlap;\n    score += component;\n    if (component > maxComponent) {\n      maxComponent = component;\n      dominantMethod = \"lexical\";\n    }\n  }\n\n  // 5. Temporal proximity: 1/(1 + gapHours/24)\n  const newMs = Date.parse(newTrajectory.recordedAt);\n  const candidateMs = Date.parse(candidate.recordedAt);\n  if (Number.isFinite(newMs) && Number.isFinite(candidateMs)) {\n    const gapHours = Math.abs(newMs - candidateMs) / 3_600_000;\n    const proximity = 1 / (1 + gapHours / 24);\n    const component = proximity * STITCH_WEIGHTS.temporalProximity;\n    score += component;\n    if (component > maxComponent) {\n      maxComponent = component;\n      dominantMethod = \"temporal\";\n    }\n  }\n\n  // Determine edge type by heuristic\n  let edgeType: CausalEdge[\"edgeType\"] = \"continuation\";\n  const goalTokens = new Set(normalizeRecallTokens(newTrajectory.goal, []));\n  const candidateGoalSet = new Set(candidateGoalTokens);\n  const goalOverlap = [...goalTokens].filter((t) => candidateGoalSet.has(t)).length;\n  const goalSimilarity = goalTokens.size > 0 ? goalOverlap / goalTokens.size : 0;\n\n  if (goalSimilarity > 0.7 && candidate.outcomeKind === \"failure\") {\n    edgeType = \"retry\";\n  } else if (goalSimilarity > 0.7 && newTrajectory.outcomeKind !== candidate.outcomeKind) {\n    edgeType = \"correction\";\n  } else if (newFollowUpTokens.size > 0 && candidateGoalTokens.length > 0) {\n    const followUpGoalOverlap = countRecallTokenOverlap(newFollowUpTokens, candidate.goal, []);\n    if (followUpGoalOverlap > 0) {\n      edgeType = \"follow_up_to_goal\";\n    }\n  }\n\n  return { trajectory: candidate, score, edgeType, stitchMethod: dominantMethod };\n}\n\n/**\n * Read trajectory records from the causal-trajectories store within\n * the lookback window, excluding the current session.\n */\nasync function readRecentTrajectories(\n  memoryDir: string,\n  causalTrajectoryStoreDir: string | undefined,\n  currentSessionKey: string,\n  lookbackDays: number,\n): Promise<CausalTrajectoryRecord[]> {\n  const root = causalTrajectoryStoreDir\n    ? path.join(memoryDir, causalTrajectoryStoreDir)\n    : path.join(memoryDir, \"state\", \"causal-trajectories\");\n  const trajectoriesDir = path.join(root, \"trajectories\");\n\n  const files = await listJsonFiles(trajectoriesDir).catch(() => [] as string[]);\n  if (files.length === 0) return [];\n\n  const cutoff = Date.now() - lookbackDays * 86_400_000;\n  const results: CausalTrajectoryRecord[] = [];\n\n  for (const filePath of files) {\n    try {\n      const raw = await readJsonFile(filePath);\n      if (!isRecord(raw)) continue;\n      const sessionKey = typeof raw.sessionKey === \"string\" ? raw.sessionKey : \"\";\n      if (sessionKey === currentSessionKey) continue;\n      const recordedAt = typeof raw.recordedAt === \"string\" ? raw.recordedAt : \"\";\n      const ms = Date.parse(recordedAt);\n      if (!Number.isFinite(ms) || ms < cutoff) continue;\n      results.push(raw as unknown as CausalTrajectoryRecord);\n    } catch {\n      // skip invalid files\n    }\n  }\n\n  return results;\n}\n\n/**\n * After a new trajectory is recorded, attempt to stitch it to\n * existing trajectories from other sessions.\n */\nexport async function stitchCausalChain(options: {\n  memoryDir: string;\n  causalTrajectoryStoreDir?: string;\n  newTrajectory: CausalTrajectoryRecord;\n  config: StitchConfig;\n}): Promise<CausalEdge[]> {\n  const { memoryDir, causalTrajectoryStoreDir, newTrajectory, config: stitchConfig } = options;\n  const chainsDir = resolveChainsDir(memoryDir, causalTrajectoryStoreDir);\n\n  const candidates = await readRecentTrajectories(\n    memoryDir,\n    causalTrajectoryStoreDir,\n    newTrajectory.sessionKey,\n    stitchConfig.lookbackDays,\n  );\n\n  if (candidates.length === 0) return [];\n\n  const scored = candidates\n    .map((c) => scoreStitchCandidate(newTrajectory, c))\n    .filter((s) => s.score >= stitchConfig.minScore)\n    .sort((a, b) => b.score - a.score)\n    .slice(0, stitchConfig.maxEdgesPerTrajectory);\n\n  if (scored.length === 0) return [];\n\n  const index = await readChainIndex(chainsDir);\n  const newEdges: CausalEdge[] = [];\n\n  for (const candidate of scored) {\n    const edgeId = makeEdgeId(candidate.trajectory.trajectoryId, newTrajectory.trajectoryId);\n\n    // Skip if edge already exists\n    if (index.edges[edgeId]) continue;\n\n    const edge: CausalEdge = {\n      schemaVersion: 1,\n      edgeId,\n      fromTrajectoryId: candidate.trajectory.trajectoryId,\n      toTrajectoryId: newTrajectory.trajectoryId,\n      edgeType: candidate.edgeType,\n      confidence: Math.min(1, candidate.score / 10),\n      stitchMethod: candidate.stitchMethod,\n      createdAt: new Date().toISOString(),\n    };\n\n    addEdgeToIndex(index, edge);\n    await persistEdge(chainsDir, edge);\n    newEdges.push(edge);\n  }\n\n  if (newEdges.length > 0) {\n    await writeChainIndex(chainsDir, index);\n    log.debug(`[cmc] stitched ${newEdges.length} causal edge(s) for trajectory ${newTrajectory.trajectoryId}`);\n  }\n\n  return newEdges;\n}\n"],"mappings":"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","names":[]}

package/dist/chunk-ONRU4L2N.js

@@ -0,0 +1,240 @@
+import {
+  log
+} from "./chunk-KWBU5S5U.js";
+
+// src/model-registry.ts
+import { readFileSync, writeFileSync, existsSync, mkdirSync } from "fs";
+import { join } from "path";
+var DEFAULT_CAPABILITIES = {
+  modelId: "default",
+  maxPositionEmbeddings: 32768,
+  contextWindow: 32768,
+  supportsExtendedContext: false,
+  typicalOutputTokens: 8192,
+  source: "default",
+  fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+};
+var KNOWN_MODELS = {
+  "qwen3-30b-a3b-instruct": {
+    maxPositionEmbeddings: 40960,
+    contextWindow: 131072,
+    // 128K with YaRN - but LM Studio defaults to ~32K
+    supportsExtendedContext: true,
+    ropeScaling: {
+      type: "yarn",
+      factor: 4,
+      originalMaxPositionEmbeddings: 32768
+    },
+    typicalOutputTokens: 8192
+  },
+  "qwen3-coder-30b-a3b-instruct": {
+    maxPositionEmbeddings: 40960,
+    contextWindow: 131072,
+    // 128K with YaRN - but LM Studio defaults to ~32K
+    supportsExtendedContext: true,
+    ropeScaling: {
+      type: "yarn",
+      factor: 4,
+      originalMaxPositionEmbeddings: 32768
+    },
+    typicalOutputTokens: 8192
+  },
+  "qwen3-8b": {
+    maxPositionEmbeddings: 40960,
+    contextWindow: 131072,
+    supportsExtendedContext: true,
+    typicalOutputTokens: 4096
+  },
+  "qwen3-14b": {
+    maxPositionEmbeddings: 40960,
+    contextWindow: 131072,
+    supportsExtendedContext: true,
+    typicalOutputTokens: 4096
+  },
+  "qwen3-32b": {
+    maxPositionEmbeddings: 40960,
+    contextWindow: 131072,
+    supportsExtendedContext: true,
+    typicalOutputTokens: 4096
+  },
+  "llama-3.1": {
+    maxPositionEmbeddings: 131072,
+    contextWindow: 131072,
+    supportsExtendedContext: false,
+    typicalOutputTokens: 8192
+  },
+  "llama-3.2": {
+    maxPositionEmbeddings: 131072,
+    contextWindow: 131072,
+    supportsExtendedContext: false,
+    typicalOutputTokens: 8192
+  },
+  "mistral-nemo": {
+    maxPositionEmbeddings: 131072,
+    contextWindow: 131072,
+    supportsExtendedContext: false,
+    typicalOutputTokens: 8192
+  },
+  "gemma-2": {
+    maxPositionEmbeddings: 8192,
+    contextWindow: 8192,
+    supportsExtendedContext: false,
+    typicalOutputTokens: 4096
+  }
+};
+var ModelRegistry = class {
+  registryPath;
+  data;
+  CACHE_TTL_DAYS = 7;
+  constructor(memoryDir) {
+    const registryDir = join(memoryDir, ".registry");
+    if (!existsSync(registryDir)) {
+      mkdirSync(registryDir, { recursive: true });
+    }
+    this.registryPath = join(registryDir, "model-capabilities.json");
+    this.data = this.loadRegistry();
+  }
+  loadRegistry() {
+    try {
+      if (existsSync(this.registryPath)) {
+        const content = readFileSync(this.registryPath, "utf-8");
+        const data = JSON.parse(content);
+        log.info(`ModelRegistry: loaded ${Object.keys(data.models).length} cached models`);
+        return data;
+      }
+    } catch (err) {
+      log.warn(`ModelRegistry: failed to load registry: ${err}`);
+    }
+    return { models: {}, version: 1 };
+  }
+  saveRegistry() {
+    try {
+      writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));
+    } catch (err) {
+      log.warn(`ModelRegistry: failed to save registry: ${err}`);
+    }
+  }
+  isCacheExpired(model) {
+    const fetched = new Date(model.fetchedAt);
+    const now = /* @__PURE__ */ new Date();
+    const daysDiff = (now.getTime() - fetched.getTime()) / (1e3 * 60 * 60 * 24);
+    return daysDiff > this.CACHE_TTL_DAYS;
+  }
+  normalizeModelId(modelId) {
+    return modelId.toLowerCase().replace(/@\d+bit$/, "").replace(/-mlx$/, "").replace(/-awq$/, "").replace(/-gptq$/, "").replace(/-gguf$/, "").replace(/^mlx-community\//, "").replace(/^models\//, "").trim();
+  }
+  /**
+   * Get capabilities for a model, using cache if available
+   */
+  getCapabilities(modelId) {
+    const normalizedId = this.normalizeModelId(modelId);
+    if (this.data.models[normalizedId]) {
+      const cached = this.data.models[normalizedId];
+      if (!this.isCacheExpired(cached)) {
+        log.info(`ModelRegistry: using cached capabilities for ${modelId}`);
+        return cached;
+      }
+      log.info(`ModelRegistry: cache expired for ${modelId}, will refresh`);
+    }
+    for (const [knownId, capabilities] of Object.entries(KNOWN_MODELS)) {
+      if (normalizedId.includes(knownId)) {
+        log.info(`ModelRegistry: using known capabilities for ${modelId}`);
+        const caps = {
+          ...DEFAULT_CAPABILITIES,
+          ...capabilities,
+          modelId: normalizedId,
+          source: "default",
+          fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+        };
+        this.data.models[normalizedId] = caps;
+        this.saveRegistry();
+        return caps;
+      }
+    }
+    log.info(`ModelRegistry: using default capabilities for ${modelId}`);
+    return {
+      ...DEFAULT_CAPABILITIES,
+      modelId: normalizedId
+    };
+  }
+  /**
+   * Store capabilities for a model
+   */
+  setCapabilities(modelId, capabilities) {
+    const normalizedId = this.normalizeModelId(modelId);
+    const caps = {
+      ...capabilities,
+      modelId: normalizedId,
+      fetchedAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+    this.data.models[normalizedId] = caps;
+    this.saveRegistry();
+    log.info(`ModelRegistry: stored capabilities for ${modelId}`);
+  }
+  /**
+   * Calculate optimal input/output sizes for a model
+   * @param maxContextOverride - Optional override for max context (e.g., if LLM server defaults to smaller window)
+   */
+  calculateContextSizes(modelId, maxContextOverride) {
+    const caps = this.getCapabilities(modelId);
+    const effectiveContextWindow = maxContextOverride ?? caps.contextWindow;
+    const overheadTokens = Math.min(1e3, Math.floor(effectiveContextWindow / 10));
+    const minInputTokens = Math.min(512, Math.floor(effectiveContextWindow / 4));
+    const minOutputTokens = 256;
+    let outputTokens = caps.typicalOutputTokens;
+    if (effectiveContextWindow > 65536) {
+      outputTokens = Math.min(Math.floor(effectiveContextWindow / 8), 16384);
+    }
+    outputTokens = Math.min(outputTokens, Math.floor(effectiveContextWindow / 4));
+    outputTokens = Math.max(
+      minOutputTokens,
+      Math.min(outputTokens, effectiveContextWindow - overheadTokens - minInputTokens)
+    );
+    const availableForInput = Math.max(
+      0,
+      effectiveContextWindow - outputTokens - overheadTokens
+    );
+    const maxInputChars = Math.max(0, Math.floor(availableForInput * 3.5));
+    const source = maxContextOverride ? "user override" : caps.source;
+    return {
+      maxInputChars,
+      maxOutputTokens: outputTokens,
+      description: `${caps.modelId}: ${effectiveContextWindow.toLocaleString()} context (${source}), using ${maxInputChars.toLocaleString()} chars input / ${outputTokens} tokens output`
+    };
+  }
+  /**
+   * Fetch capabilities from Hugging Face (if available)
+   * Returns true if successful
+   */
+  async fetchFromHuggingFace(modelId) {
+    log.info(`ModelRegistry: fetchFromHuggingFace not yet implemented for ${modelId}`);
+    return false;
+  }
+  /**
+   * List all cached models
+   */
+  listCached() {
+    return Object.keys(this.data.models);
+  }
+  /**
+   * Clear expired cache entries
+   */
+  cleanExpired() {
+    const before = Object.keys(this.data.models).length;
+    this.data.models = Object.fromEntries(
+      Object.entries(this.data.models).filter(([_, caps]) => !this.isCacheExpired(caps))
+    );
+    const after = Object.keys(this.data.models).length;
+    const removed = before - after;
+    if (removed > 0) {
+      this.saveRegistry();
+      log.info(`ModelRegistry: cleaned ${removed} expired entries`);
+    }
+    return removed;
+  }
+};
+
+export {
+  ModelRegistry
+};
+//# sourceMappingURL=chunk-ONRU4L2N.js.map

package/dist/chunk-ONRU4L2N.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/model-registry.ts"],"sourcesContent":["/**\n * Model Registry - Stores and retrieves model capabilities\n * Avoids repeated external lookups by caching model info locally\n */\n\nimport { log } from \"./logger.js\";\nimport { readFileSync, writeFileSync, existsSync, mkdirSync } from \"node:fs\";\nimport { join } from \"node:path\";\n\nexport interface ModelCapabilities {\n  modelId: string;\n  maxPositionEmbeddings: number;\n  contextWindow: number;\n  supportsExtendedContext: boolean;\n  ropeScaling?: {\n    type: string;\n    factor: number;\n    originalMaxPositionEmbeddings: number;\n  };\n  typicalOutputTokens: number;\n  source: \"huggingface\" | \"lmstudio\" | \"manual\" | \"default\";\n  fetchedAt: string;\n}\n\ninterface ModelRegistryData {\n  models: Record<string, ModelCapabilities>;\n  version: number;\n}\n\nconst DEFAULT_CAPABILITIES: ModelCapabilities = {\n  modelId: \"default\",\n  maxPositionEmbeddings: 32768,\n  contextWindow: 32768,\n  supportsExtendedContext: false,\n  typicalOutputTokens: 8192,\n  source: \"default\",\n  fetchedAt: new Date().toISOString(),\n};\n\n// Known model capabilities (fallback when offline)\n// NOTE: Context windows here are the MODEL's theoretical maximum. Local LLM servers\n// (LM Studio, Ollama, etc.) often load models with smaller default context windows.\n// If you get \"context length exceeded\" errors, either:\n// 1. Increase the context window in your LLM server UI (recommended)\n// 2. Set localLlmMaxContext in openclaw.json to limit prompts (fallback)\nconst KNOWN_MODELS: Record<string, Partial<ModelCapabilities>> = {\n  \"qwen3-30b-a3b-instruct\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072, // 128K with YaRN - but LM Studio defaults to ~32K\n    supportsExtendedContext: true,\n    ropeScaling: {\n      type: \"yarn\",\n      factor: 4.0,\n      originalMaxPositionEmbeddings: 32768,\n    },\n    typicalOutputTokens: 8192,\n  },\n  \"qwen3-coder-30b-a3b-instruct\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072, // 128K with YaRN - but LM Studio defaults to ~32K\n    supportsExtendedContext: true,\n    ropeScaling: {\n      type: \"yarn\",\n      factor: 4.0,\n      originalMaxPositionEmbeddings: 32768,\n    },\n    typicalOutputTokens: 8192,\n  },\n  \"qwen3-8b\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072,\n    supportsExtendedContext: true,\n    typicalOutputTokens: 4096,\n  },\n  \"qwen3-14b\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072,\n    supportsExtendedContext: true,\n    typicalOutputTokens: 4096,\n  },\n  \"qwen3-32b\": {\n    maxPositionEmbeddings: 40960,\n    contextWindow: 131072,\n    supportsExtendedContext: true,\n    typicalOutputTokens: 4096,\n  },\n  \"llama-3.1\": {\n    maxPositionEmbeddings: 131072,\n    contextWindow: 131072,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 8192,\n  },\n  \"llama-3.2\": {\n    maxPositionEmbeddings: 131072,\n    contextWindow: 131072,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 8192,\n  },\n  \"mistral-nemo\": {\n    maxPositionEmbeddings: 131072,\n    contextWindow: 131072,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 8192,\n  },\n  \"gemma-2\": {\n    maxPositionEmbeddings: 8192,\n    contextWindow: 8192,\n    supportsExtendedContext: false,\n    typicalOutputTokens: 4096,\n  },\n};\n\nexport class ModelRegistry {\n  private registryPath: string;\n  private data: ModelRegistryData;\n  private readonly CACHE_TTL_DAYS = 7;\n\n  constructor(memoryDir: string) {\n    const registryDir = join(memoryDir, \".registry\");\n    if (!existsSync(registryDir)) {\n      mkdirSync(registryDir, { recursive: true });\n    }\n    this.registryPath = join(registryDir, \"model-capabilities.json\");\n    this.data = this.loadRegistry();\n  }\n\n  private loadRegistry(): ModelRegistryData {\n    try {\n      if (existsSync(this.registryPath)) {\n        const content = readFileSync(this.registryPath, \"utf-8\");\n        const data = JSON.parse(content) as ModelRegistryData;\n        log.info(`ModelRegistry: loaded ${Object.keys(data.models).length} cached models`);\n        return data;\n      }\n    } catch (err) {\n      log.warn(`ModelRegistry: failed to load registry: ${err}`);\n    }\n    return { models: {}, version: 1 };\n  }\n\n  private saveRegistry(): void {\n    try {\n      writeFileSync(this.registryPath, JSON.stringify(this.data, null, 2));\n    } catch (err) {\n      log.warn(`ModelRegistry: failed to save registry: ${err}`);\n    }\n  }\n\n  private isCacheExpired(model: ModelCapabilities): boolean {\n    const fetched = new Date(model.fetchedAt);\n    const now = new Date();\n    const daysDiff = (now.getTime() - fetched.getTime()) / (1000 * 60 * 60 * 24);\n    return daysDiff > this.CACHE_TTL_DAYS;\n  }\n\n  private normalizeModelId(modelId: string): string {\n    // Remove common suffixes and prefixes for matching\n    return modelId\n      .toLowerCase()\n      .replace(/@\\d+bit$/, \"\") // Remove @4bit, @8bit\n      .replace(/-mlx$/, \"\")\n      .replace(/-awq$/, \"\")\n      .replace(/-gptq$/, \"\")\n      .replace(/-gguf$/, \"\")\n      .replace(/^mlx-community\\//, \"\")\n      .replace(/^models\\//, \"\")\n      .trim();\n  }\n\n  /**\n   * Get capabilities for a model, using cache if available\n   */\n  getCapabilities(modelId: string): ModelCapabilities {\n    const normalizedId = this.normalizeModelId(modelId);\n\n    // Check cache first\n    if (this.data.models[normalizedId]) {\n      const cached = this.data.models[normalizedId];\n      if (!this.isCacheExpired(cached)) {\n        log.info(`ModelRegistry: using cached capabilities for ${modelId}`);\n        return cached;\n      }\n      log.info(`ModelRegistry: cache expired for ${modelId}, will refresh`);\n    }\n\n    // Check known models\n    for (const [knownId, capabilities] of Object.entries(KNOWN_MODELS)) {\n      if (normalizedId.includes(knownId)) {\n        log.info(`ModelRegistry: using known capabilities for ${modelId}`);\n        const caps: ModelCapabilities = {\n          ...DEFAULT_CAPABILITIES,\n          ...capabilities,\n          modelId: normalizedId,\n          source: \"default\",\n          fetchedAt: new Date().toISOString(),\n        };\n        this.data.models[normalizedId] = caps;\n        this.saveRegistry();\n        return caps;\n      }\n    }\n\n    // Return defaults\n    log.info(`ModelRegistry: using default capabilities for ${modelId}`);\n    return {\n      ...DEFAULT_CAPABILITIES,\n      modelId: normalizedId,\n    };\n  }\n\n  /**\n   * Store capabilities for a model\n   */\n  setCapabilities(modelId: string, capabilities: Omit<ModelCapabilities, \"modelId\" | \"fetchedAt\">): void {\n    const normalizedId = this.normalizeModelId(modelId);\n    const caps: ModelCapabilities = {\n      ...capabilities,\n      modelId: normalizedId,\n      fetchedAt: new Date().toISOString(),\n    };\n    this.data.models[normalizedId] = caps;\n    this.saveRegistry();\n    log.info(`ModelRegistry: stored capabilities for ${modelId}`);\n  }\n\n  /**\n   * Calculate optimal input/output sizes for a model\n   * @param maxContextOverride - Optional override for max context (e.g., if LLM server defaults to smaller window)\n   */\n  calculateContextSizes(modelId: string, maxContextOverride?: number): {\n    maxInputChars: number;\n    maxOutputTokens: number;\n    description: string;\n  } {\n    const caps = this.getCapabilities(modelId);\n\n    // Use override if provided (e.g., user knows their LLM server limits), otherwise use detected caps\n    const effectiveContextWindow = maxContextOverride ?? caps.contextWindow;\n\n    // Guardrails: never allow output budget to exceed the model/server context window.\n    // If we do, input budget goes negative and we end up generating huge, invalid prompts.\n    const overheadTokens = Math.min(1000, Math.floor(effectiveContextWindow / 10)); // <=10% overhead, max 1k\n    const minInputTokens = Math.min(512, Math.floor(effectiveContextWindow / 4)); // keep some room even on small contexts\n    const minOutputTokens = 256;\n\n    // Base output budget: typical output, but scaled down for small contexts.\n    let outputTokens = caps.typicalOutputTokens;\n\n    // For very large contexts, default to ~12.5% output (capped), which tends to be plenty for JSON extraction.\n    if (effectiveContextWindow > 65536) {\n      outputTokens = Math.min(Math.floor(effectiveContextWindow / 8), 16384);\n    }\n\n    // Never let output exceed 25% of context.\n    outputTokens = Math.min(outputTokens, Math.floor(effectiveContextWindow / 4));\n\n    // Clamp output so we always have positive input headroom.\n    outputTokens = Math.max(\n      minOutputTokens,\n      Math.min(outputTokens, effectiveContextWindow - overheadTokens - minInputTokens),\n    );\n\n    const availableForInput = Math.max(\n      0,\n      effectiveContextWindow - outputTokens - overheadTokens,\n    );\n\n    // Convert to characters (rough estimate: 1 token ≈ 4 chars)\n    const maxInputChars = Math.max(0, Math.floor(availableForInput * 3.5)); // Conservative: 3.5 chars/token\n\n    const source = maxContextOverride ? \"user override\" : caps.source;\n    return {\n      maxInputChars,\n      maxOutputTokens: outputTokens,\n      description: `${caps.modelId}: ${effectiveContextWindow.toLocaleString()} context (${source}), using ${maxInputChars.toLocaleString()} chars input / ${outputTokens} tokens output`,\n    };\n  }\n\n  /**\n   * Fetch capabilities from Hugging Face (if available)\n   * Returns true if successful\n   */\n  async fetchFromHuggingFace(modelId: string): Promise<boolean> {\n    // This would be implemented to fetch from HF Hub API\n    // For now, we rely on the known models and manual updates\n    log.info(`ModelRegistry: fetchFromHuggingFace not yet implemented for ${modelId}`);\n    return false;\n  }\n\n  /**\n   * List all cached models\n   */\n  listCached(): string[] {\n    return Object.keys(this.data.models);\n  }\n\n  /**\n   * Clear expired cache entries\n   */\n  cleanExpired(): number {\n    const before = Object.keys(this.data.models).length;\n    this.data.models = Object.fromEntries(\n      Object.entries(this.data.models).filter(([_, caps]) => !this.isCacheExpired(caps))\n    );\n    const after = Object.keys(this.data.models).length;\n    const removed = before - after;\n    if (removed > 0) {\n      this.saveRegistry();\n      log.info(`ModelRegistry: cleaned ${removed} expired entries`);\n    }\n    return removed;\n  }\n}\n"],"mappings":"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","names":[]}