cogmemory 0.0.1-beta.2

package/dist/cognitive-memory.js

@@ -0,0 +1,1068 @@
+import { ofetch as x, FetchError as E } from "ofetch";
+class T extends Error {
+  /**
+   * Set as a real value, because a minifier renames the class and that silently
+   * changes what monitoring groups on. `error.name` is correct either way — the
+   * constructor assigns it — but `SomeError.name` and `error.constructor.name`
+   * are how a reporter identifies a class, and a minified `"h"` breaks that.
+   */
+  static name = "CognitiveMemoryError";
+  /** The service's own tag: `Unauthorized`, `Forbidden`, `InvalidRequest`, … */
+  code;
+  status;
+  /** Present on a 403: the scope the key would have needed. */
+  requiredScope;
+  /** Present on a 400: which field, and why. */
+  issues;
+  body;
+  constructor(e, t) {
+    super(e), this.name = "CognitiveMemoryError", this.status = t.status, this.code = t.code, this.body = t.body, this.requiredScope = t.requiredScope, this.issues = t.issues, Error.captureStackTrace && Error.captureStackTrace(this, T);
+  }
+  /** The key is missing, malformed, expired or revoked. */
+  isAuthError() {
+    return this.status === 401;
+  }
+  /** The key is valid but lacks a scope. `requiredScope` says which. */
+  isScopeError() {
+    return this.status === 403;
+  }
+  /** The request body did not match the schema. `issues` says where. */
+  isValidationError() {
+    return this.status === 400;
+  }
+  /** Nothing exists at that id — or it belongs to another organisation. */
+  isNotFoundError() {
+    return this.status === 404;
+  }
+  isRateLimitError() {
+    return this.status === 429;
+  }
+  /** A dependency of ours failed, not the request. Safe to retry. */
+  isServerError() {
+    return this.status >= 500;
+  }
+}
+function L(i) {
+  const {
+    apiKey: e,
+    baseUrl: t = D(),
+    timeout: s = 3e4,
+    retry: o = 2,
+    debug: n = !1,
+    headers: r = {}
+  } = i;
+  if (typeof e != "string" || e.trim() === "")
+    throw new Error(
+      "cognitive-memory: apiKey is required. Issue one in the dashboard — the secret is shown only once."
+    );
+  const a = x.create({
+    baseURL: `${t.replace(/\/$/, "")}/api/v1`,
+    timeout: s,
+    // Retries are for transport hiccups, not for a 400. ofetch already limits
+    // this to idempotent-looking methods, and the service is idempotent for the
+    // reads that matter.
+    retry: o,
+    headers: {
+      accept: "application/json",
+      ...r
+    },
+    onRequest({ options: h, request: u }) {
+      h.headers.set("authorization", `Bearer ${e}`), h.headers.set("content-type", "application/json"), n && console.log("[cognitive-memory]", h.method ?? "GET", `${h.baseURL ?? ""}${u ?? ""}`);
+    },
+    onResponse({ response: h, options: u, request: c }) {
+      n && console.log("[cognitive-memory]", h.status, u.method ?? "GET", c ?? "");
+    }
+  });
+  return async (h, u) => {
+    try {
+      return await a(h, u);
+    } catch (c) {
+      if (!(c instanceof E) || !c.response) throw c;
+      const d = c.response, m = d._data ?? void 0;
+      throw new T(m?.message ?? `cognitive-memory: request failed with ${d.status}`, {
+        status: d.status,
+        code: m?.error ?? "UnknownError",
+        ...m === void 0 ? {} : { body: m },
+        ...m?.requiredScope === void 0 ? {} : { requiredScope: m.requiredScope },
+        ...m?.issues === void 0 ? {} : { issues: m.issues }
+      });
+    }
+  };
+}
+function D() {
+  return typeof window < "u" ? window.location.origin : "http://localhost:3000";
+}
+class R {
+  constructor(e) {
+    this.client = e;
+  }
+  build(e = {}) {
+    return this.client("/context", { method: "POST", body: e });
+  }
+}
+class I {
+  constructor(e) {
+    this.client = e;
+  }
+  /**
+   * The envelope is unwrapped here rather than passed on.
+   *
+   * The service replies with `{ memories, stats }` so a dashboard can get both in
+   * one call, but an SDK caller who asked for a list wants a list. Deciding that
+   * in one place here is better than making every integration know the shape.
+   */
+  async list(e = {}) {
+    return (await this.client("/memories", {
+      method: "GET",
+      query: e
+    })).memories;
+  }
+  async get(e) {
+    return (await this.client(`/memories/${encodeURIComponent(e)}`, {
+      method: "GET"
+    })).memory;
+  }
+  /**
+   * State facts outright.
+   *
+   * Restatements of something already held are folded in rather than stored
+   * twice, and the result says which ones were folded and into what — a write
+   * that silently did nothing is indistinguishable from a bug.
+   */
+  create(e) {
+    return this.client("/memories", { method: "POST", body: e });
+  }
+  /** Move a memory between tiers. L1 is pre-staged into every context build. */
+  async promote(e, t) {
+    return (await this.client(`/memories/${encodeURIComponent(e)}`, {
+      method: "PATCH",
+      body: { tier: t }
+    })).memory;
+  }
+  remove(e) {
+    return this.client(`/memories/${encodeURIComponent(e)}`, { method: "DELETE" });
+  }
+}
+class O {
+  constructor(e) {
+    this.client = e;
+  }
+  search(e) {
+    return this.client("/recall", { method: "POST", body: e });
+  }
+}
+class j {
+  constructor(e) {
+    this.client = e;
+  }
+  get() {
+    return this.client("/self-model", { method: "GET" });
+  }
+  record(e) {
+    return this.client("/self-model/outcome", { method: "POST", body: e });
+  }
+}
+class H {
+  constructor(e) {
+    this.client = e;
+  }
+  /** Needs only `stats:read`, so monitoring can watch without reading memories. */
+  get() {
+    return this.client("/stats", { method: "GET" });
+  }
+}
+const P = async (i) => {
+  const e = i.replace(/\/$/, ""), t = await fetch(`${e}/api/v1/health`, { headers: { accept: "application/json" } });
+  if (!t.ok)
+    throw new Error(`cognitive-memory: health check failed with ${t.status}`);
+  return await t.json();
+};
+class z {
+  constructor(e) {
+    this.client = e;
+  }
+  async list(e) {
+    return (await this.client("/tensions", {
+      method: "GET",
+      query: e === void 0 ? {} : { status: e }
+    })).tensions;
+  }
+  async create(e) {
+    return (await this.client("/tensions", {
+      method: "POST",
+      body: e
+    })).tension;
+  }
+  async resolve(e, t) {
+    return (await this.client(`/tensions/${encodeURIComponent(e)}`, {
+      method: "POST",
+      body: t
+    })).tension;
+  }
+}
+class N {
+  constructor(e) {
+    this.client = e;
+  }
+  learn(e) {
+    return this.client("/turns", { method: "POST", body: e });
+  }
+}
+class U {
+  client;
+  baseUrl;
+  memories;
+  context;
+  recall;
+  turns;
+  tensions;
+  selfModel;
+  stats;
+  constructor(e) {
+    this.baseUrl = (e.baseUrl ?? "http://localhost:3000").replace(/\/$/, ""), this.client = L(e), this.memories = new I(this.client), this.context = new R(this.client), this.recall = new O(this.client), this.turns = new N(this.client), this.tensions = new z(this.client), this.selfModel = new j(this.client), this.stats = new H(this.client);
+  }
+  /**
+   * Liveness and limits, without spending a request on the configured key.
+   *
+   * Useful in a readiness probe: if `extractor` is `rules-only` the service is up
+   * but is not doing model-backed extraction, and `problems` is non-empty when a
+   * setting is present but unusable.
+   */
+  health() {
+    return P(this.baseUrl);
+  }
+}
+function he(i) {
+  return new U(i);
+}
+async function de(i, e, t = {}) {
+  const s = await i.context.build({
+    userMessage: e.userMessage,
+    ...t.sessionId === void 0 ? {} : { sessionId: t.sessionId }
+  }), o = await e.run(s.text);
+  if (t.learn === !1)
+    return { context: s, learning: null, learningSkipped: "learning disabled for this turn" };
+  let n = null;
+  try {
+    n = await i.turns.learn({
+      userMessage: e.userMessage,
+      assistantResponse: o,
+      ...t.sessionId === void 0 ? {} : { sessionId: t.sessionId }
+    }), t.onLearn?.(n);
+  } catch (r) {
+    return console.warn("[cognitive-memory] could not learn from this turn", r), { context: s, learning: null, learningSkipped: String(r) };
+  }
+  if (t.domain !== void 0)
+    try {
+      await i.selfModel.record({
+        domain: t.domain,
+        success: t.failurePattern === void 0,
+        ...t.failurePattern === void 0 ? {} : { failurePattern: t.failurePattern },
+        ...t.strategy === void 0 ? {} : { strategy: t.strategy }
+      });
+    } catch (r) {
+      console.warn("[cognitive-memory] could not record the domain outcome", r);
+    }
+  return { context: s, learning: n };
+}
+async function me(i, e, t = {}) {
+  const s = await i.recall.search({
+    query: e,
+    ...t.limit === void 0 ? {} : { limit: t.limit }
+  });
+  if (s.empty)
+    return t.emptyMessage ?? `Nothing in memory matches "${e}". If you were not told, say so rather than guessing.`;
+  const o = s.results.map((n) => {
+    const r = n.memory.domains.length > 0 ? ` (${n.memory.domains.join(", ")})` : "";
+    return `- ${n.memory.content}${r} [${n.memory.tier}, relevance ${n.score.toFixed(2)}]`;
+  });
+  return `Remembered (${s.results.length} match${s.results.length === 1 ? "" : "es"}):
+${o.join(`
+`)}`;
+}
+async function ue(i, e) {
+  const t = await i.memories.create({
+    items: e.facts.map((s) => ({ content: s })),
+    ...e.sessionId === void 0 ? {} : { sessionId: e.sessionId }
+  });
+  return { stored: t.stored, merged: t.mergedInto, rejected: t.rejected };
+}
+const B = [
+  /actually,?\s+(?:we|i)\s+(?:switched|changed|moved|migrated|replaced|use|want|have)/i,
+  /that(?:'s|\s+is)\s+(?:wrong|incorrect|outdated|false|not\s+right|no\s+longer)/i,
+  /no,?\s+(?:it(?:'s|\s+is)|we\s+use|we\s+switched|it\s+should\s+be|don(?:'t|\s+not)\s+use)/i,
+  /stop\s+using\s+/i,
+  /instead\s+of\s+/i,
+  /disregard\s+(?:prior|previous|what\s+i\s+said)/i
+], W = {
+  auth: [/auth/i, /login/i, /session/i, /jwt/i, /oauth/i, /token/i, /password/i, /permission/i],
+  database: [/postgres/i, /sqlite/i, /sql/i, /schema/i, /migration/i, /prisma/i, /drizzle/i, /mongo/i, /redis/i],
+  frontend: [/css/i, /tailwind/i, /component/i, /jsx/i, /tsx/i, /layout/i, /ui/i, /render/i, /html/i],
+  build: [/vite/i, /webpack/i, /turbo/i, /tsconfig/i, /pnpm/i, /package\.json/i, /bundle/i],
+  api: [/rest/i, /graphql/i, /endpoint/i, /route/i, /fetch/i, /request/i, /response/i],
+  git: [/branch/i, /commit/i, /merge/i, /rebase/i, /worktree/i, /conflict/i]
+}, F = (i) => {
+  if (!i || i.trim().length === 0)
+    return { action: "proceed" };
+  for (const e of B)
+    if (e.test(i))
+      return {
+        action: "inject_caution",
+        cautionNote: "User appears to be explicitly correcting a prior premise or configuration. Verify current facts before proceeding with assumptions.",
+        detectedDomains: k(i)
+      };
+  return {
+    action: "proceed",
+    detectedDomains: k(i)
+  };
+}, k = (i) => {
+  const e = [];
+  for (const [t, s] of Object.entries(W))
+    s.some((o) => o.test(i)) && e.push(t);
+  return e;
+}, _ = /* @__PURE__ */ new Set([
+  "the",
+  "and",
+  "for",
+  "this",
+  "that",
+  "with",
+  "from",
+  "you",
+  "are",
+  "was",
+  "has",
+  "have",
+  "what",
+  "which",
+  "when",
+  "were",
+  "will",
+  "your",
+  "our",
+  "its",
+  "not",
+  "but",
+  "all",
+  "any",
+  "can",
+  "did",
+  "does",
+  "how",
+  "into",
+  "out",
+  "use",
+  "used",
+  "using",
+  "one",
+  "two",
+  "get",
+  "new",
+  "now",
+  "then",
+  "than",
+  "them",
+  "they",
+  "his",
+  "her",
+  "she",
+  "him",
+  "been",
+  "being",
+  "there",
+  "here",
+  "also",
+  "just",
+  "like",
+  "make",
+  "made",
+  "need",
+  "want",
+  "about",
+  "after",
+  "tell",
+  "know",
+  "give",
+  "show",
+  "please",
+  "would",
+  "could",
+  "should",
+  "shall"
+]), q = /* @__PURE__ */ new Set([
+  "this",
+  "that",
+  "these",
+  "those",
+  "there",
+  "here",
+  "with",
+  "from",
+  "into",
+  "must",
+  "should",
+  "always",
+  "never",
+  "under",
+  "over",
+  "about",
+  "after",
+  "before",
+  "when",
+  "where",
+  "which",
+  "what",
+  "your",
+  "their",
+  "them",
+  "they",
+  "then",
+  "than",
+  "also",
+  "just",
+  "only",
+  "each",
+  "every",
+  "some",
+  "such",
+  "very",
+  "more",
+  "most",
+  "same",
+  "file",
+  "files",
+  "name",
+  "names",
+  "project",
+  "repository",
+  "repo",
+  "note"
+]), g = (i) => new Set(
+  i.toLowerCase().split(/[^a-z0-9]+/).filter((e) => e.length >= 3 && !_.has(e))
+), v = (i, e) => {
+  if (i.size === 0 || e.size === 0) return 0;
+  let t = 0;
+  for (const s of i) e.has(s) && (t += 1);
+  return t / Math.min(i.size, e.size);
+}, G = 0.3, Z = 0.12, Q = 8, K = 0.8, p = (i) => new Set(
+  i.toLowerCase().replace(/['']/g, "").split(/[^a-z0-9]+/).filter(Boolean).filter((e) => /\d/.test(e) || e.length >= 4).filter((e) => !q.has(e))
+), b = (i, e) => {
+  const t = (o) => new Set([...o].map((n) => n.length >= 4 && n.endsWith("s") ? n.slice(0, -1) : n)), s = t(p(e));
+  for (const o of t(p(i)))
+    if (!s.has(o)) return !0;
+  return !1;
+}, V = /\b[a-z0-9][a-z0-9-]{1,}(?:\.[a-z0-9-]+)*\.[a-z]{2,}\b/gi, J = /* @__PURE__ */ new Set([
+  "eg",
+  "ie",
+  "etc",
+  "vs",
+  "approx",
+  "inc",
+  "ltd",
+  "corp",
+  "dept",
+  "est",
+  "fig",
+  "no",
+  "al"
+]), fe = (i) => {
+  const e = /* @__PURE__ */ new Set();
+  for (const t of i.match(/\bhttps?:\/\/[^\s<>()[\]"'`]+/g) ?? []) e.add(t);
+  for (const t of i.match(V) ?? [])
+    J.has(t.toLowerCase()) || e.add(t);
+  for (const t of i.match(/\b(?:\.{0,2}\/)?[\w-]+(?:\/[\w.-]+)+\/?/g) ?? [])
+    t.length > 3 && e.add(t);
+  for (const t of i.match(/\b[A-Z][A-Z0-9]*(?:_[A-Z0-9]+)+\b/g) ?? []) e.add(t);
+  for (const t of i.match(/\b[A-Z]{2,}[0-9][A-Z0-9-]*\b/g) ?? []) e.add(t);
+  for (const t of i.match(/\b[a-z]+(?:[A-Z][a-z0-9]+){1,}\b/g) ?? []) e.add(t);
+  for (const t of i.match(/\b[a-z]+(?:-[a-z0-9]+){2,}\b/g) ?? []) e.add(t);
+  for (const t of i.match(/\b[0-9a-f]{6,}\b/gi) ?? []) e.add(t);
+  return [...e];
+}, Y = [
+  /\b(?:do not|don'?t|never|no need to)\s+(?:verify|check|confirm|look\s?up|search|investigate|browse|resolve)\b/i,
+  /\bjust\s+(?:remember|note|acknowledge|retain|treat)\b/i,
+  /\b(?:held|noted|stored|remembered)\s+(?:in|for)\s+(?:this|the)\s+conversation\b/i,
+  /\bnot\s+verified\b/i,
+  /\bwithout\s+verifying\b/i,
+  /\bfor\s+this\s+(?:conversation|session|turn|reply|response)\s+only\b/i,
+  /^(?:ok|okay|noted|got it|sure|thanks)\b[.!]?$/i
+], A = (i) => Y.some((e) => e.test(i)), X = (i, e) => {
+  const t = p(i), s = p(e);
+  if (t.size === 0 || s.size === 0) return 0;
+  let o = 0;
+  for (const n of t) s.has(n) && (o += 1);
+  return o / Math.min(t.size, s.size);
+}, pe = (i) => i.trim().toLowerCase(), ee = (i) => Math.ceil(i.length / 4), $ = (i) => {
+  if (i.gist && i.gist.trim().length > 0) return i.gist.trim();
+  const t = (i.content.split(/(?<=[.!?])\s/)[0] ?? i.content).trim();
+  return t.length > 90 ? `${t.slice(0, 90)}…` : t;
+}, te = 5;
+class ge {
+  // L0: Pinned core state (identity, self-model, active tensions)
+  activeTensions = /* @__PURE__ */ new Map();
+  selfModel;
+  activeTaskTrace = "";
+  // L1: Hot Cache (pre-staged for upcoming turn)
+  l1HotCache = /* @__PURE__ */ new Map();
+  // L2: Warm Storage (indexed candidates ready for promotion)
+  l2WarmStore = /* @__PURE__ */ new Map();
+  // L3: Cold Archive (historical, loaded on demand)
+  l3ColdArchive = /* @__PURE__ */ new Map();
+  maxL0Tokens;
+  maxL1Tokens;
+  /** Ceiling on everything injected into one prompt, index and bodies together. */
+  maxTotalTokens;
+  arbiter = null;
+  autoExtractMemories;
+  /** Model-backed turn extractor; the regex fallback runs when this is absent. */
+  reconcile;
+  extract;
+  onPersist;
+  stats = {
+    totalTurnsProcessed: 0,
+    predictionsHit: 0,
+    predictionsTotal: 0,
+    tensionsDetected: 0
+  };
+  constructor(e = {}) {
+    this.maxL0Tokens = e.maxL0Tokens ?? 2e3, this.maxL1Tokens = e.maxL1Tokens ?? 8e3, this.maxTotalTokens = e.maxTotalTokens ?? 2e3, this.arbiter = e.arbiter ?? null, this.autoExtractMemories = e.autoExtractMemories ?? !0, this.extract = e.extract, this.reconcile = e.reconcile, this.onPersist = e.onPersist, this.selfModel = {
+      domains: e.initialSelfModel?.domains ?? {},
+      calibrationFactor: e.initialSelfModel?.calibrationFactor ?? 1,
+      activeDomains: e.initialSelfModel?.activeDomains ?? []
+    };
+  }
+  /**
+   * Sub-1ms synchronous call to produce the prompt context block.
+   * Concatenates L0 (active tensions + self-model) and pre-staged L1.
+   * Adds zero latency to TTFT.
+   */
+  /**
+   * Decide what goes into this turn's prompt, and record why.
+   *
+   * Follows the index/body split that Claude Code's `MEMORY.md` and Letta's
+   * progressive disclosure both converged on: a short index of every memory is
+   * always present, and a body is only spent where a deterministic signal earned
+   * it. Always injecting bodies costs an order of magnitude more tokens and, per
+   * Chroma's context-rot work, injects distractors by construction.
+   *
+   * @param forceFull memory ids whose body should be included regardless of tier.
+   */
+  planInjection(e = {}) {
+    const t = new Set(e.forceFull ?? []), s = [], o = [];
+    let n = 0, r = !1;
+    const a = (c, d, m) => {
+      const f = $(c), S = m ? c.content : void 0, C = c.metadata.domains.slice(0, 3), M = C.length > 0 ? ` (${C.join(", ")})` : "", y = ee(`${f}${M}${S ?? ""}`);
+      if (n + y > this.maxTotalTokens) {
+        r = !0;
+        return;
+      }
+      n += y, o.push({ id: c.id, tier: c.tier, reason: d, gist: f, body: S, tokens: y });
+    };
+    if (e.userMessage) {
+      const c = F(e.userMessage);
+      c.action === "inject_caution" && c.cautionNote && s.push(`### ⚠️ Correction Detected In This Message
+${c.cautionNote}`);
+    }
+    const l = this.selfModel.activeDomains.map((c) => ({ d: c, capability: this.selfModel.domains[c] })).filter((c) => c.capability && c.capability.reliabilityScore < 0.75);
+    if (l.length > 0) {
+      const c = l.map(({ d, capability: m }) => {
+        const f = m;
+        return a(
+          {
+            id: `guardrail-${d}`,
+            content: `${d}: reliability ${Math.round(f.reliabilityScore * 100)}% over ${f.sampleCount} tasks.${f.knownFailurePatterns.length > 0 ? ` Known pitfalls: ${f.knownFailurePatterns.join("; ")}` : ""}${f.recommendedStrategies.length > 0 ? ` Approach: ${f.recommendedStrategies.join("; ")}` : ""}`,
+            tier: "L0",
+            metadata: { domains: [d], createdAt: Date.now(), lastAccessedAt: Date.now(), accessCount: 0 }
+          },
+          "guardrail",
+          !0
+        ), `- ${d} (${Math.round(f.reliabilityScore * 100)}% reliable): ${f.knownFailurePatterns.join("; ") || "be careful"}`;
+      });
+      s.push(`### Weak Domains — Under 75% Reliability
+${c.join(`
+`)}`);
+    }
+    const h = [];
+    for (const c of this.l1HotCache.values()) {
+      const d = c.metadata.domains.slice(0, 3), m = d.length > 0 ? ` (${d.join(", ")})` : "";
+      t.has(c.id) ? (a(c, "trigger", !0), h.push(`- ${c.content}${m}`)) : (a(c, "index", !1), h.push(`- ${$(c)}${m}`));
+    }
+    h.length > 0 && s.push(
+      [
+        "### Memory index — established earlier in this project",
+        "One line per remembered item. Use `recall` to pull a full item, then treat it as true.",
+        ...h
+      ].join(`
+`)
+    );
+    const u = [...this.activeTensions.values()].filter((c) => c.status === "active");
+    if (u.length > 0) {
+      const c = u.map((d) => (a(
+        {
+          id: d.id,
+          content: `${d.claimA.statement} vs ${d.claimB.statement} — ${d.actionableQuestion}`,
+          bookmark: d.claimA.statement,
+          tier: "L0",
+          metadata: { domains: [], createdAt: d.claimA.timestamp, lastAccessedAt: Date.now(), accessCount: 0 }
+        },
+        "tension",
+        !0
+      ), `- [${d.impact.toUpperCase()}] "${d.claimA.statement}" conflicts with "${d.claimB.statement}". Ask: ${d.actionableQuestion}`));
+      s.push(`### Unresolved Contradictions
+${c.join(`
+`)}`);
+    }
+    return {
+      text: s.length > 0 ? `
+## Cognitive Memory State
+${s.join(`
+
+`)}
+` : "",
+      entries: o,
+      totalTokens: n,
+      truncated: r
+    };
+  }
+  /** Prompt text only. Prefer `planInjection` when you want to log what went in. */
+  getPromptContext(e) {
+    return this.planInjection({ userMessage: e }).text;
+  }
+  /**
+   * Search every tier for memories relevant to `query`.
+   *
+   * This is the on-demand path, exposed to the agent as a tool. Pre-staging into
+   * the prompt is a best-effort optimisation; a model that does not read the
+   * block, or whose question shares no words with it, can still ask. Ranking is
+   * deterministic — no model involved — so recall does not depend on model
+   * quality.
+   */
+  search(e, t = 8) {
+    const s = g(e);
+    if (s.size === 0) return [];
+    const n = [
+      ...this.l1HotCache.values(),
+      ...this.l2WarmStore.values(),
+      ...this.l3ColdArchive.values()
+    ].map((l) => ({
+      item: l,
+      score: v(s, g(`${l.content} ${l.metadata.domains.join(" ")}`))
+    })).filter((l) => l.score > 0).sort((l, h) => h.score - l.score || l.item.content.length - h.item.content.length), r = [], a = [];
+    for (const l of n)
+      if (!r.some((h) => X(h, l.item.content) >= K) && (r.push(l.item.content), a.push(l), a.length >= Math.max(1, t)))
+        break;
+    return a;
+  }
+  /**
+   * Post-turn asynchronous execution.
+   * Fired when the agent finishes streaming its response to the user.
+   * Evaluates turn, manages L1 cache, detects tensions, updates self-model.
+   */
+  async postTurnAsync(e) {
+    this.stats.totalTurnsProcessed += 1, e.detectedDomains && e.detectedDomains.length > 0 && (this.selfModel.activeDomains = Array.from(
+      /* @__PURE__ */ new Set([...this.selfModel.activeDomains, ...e.detectedDomains])
+    ));
+    const t = Array.from(this.l2WarmStore.values()).slice(0, 20).map((n) => ({
+      id: n.id,
+      bookmark: n.bookmark,
+      domains: n.metadata.domains,
+      hasTension: !1
+    })), s = Array.from(this.l1HotCache.values()).map((n) => ({
+      id: n.id,
+      bookmark: n.bookmark,
+      domains: n.metadata.domains
+    })), o = this.arbiter ? await this.arbiter({
+      turnText: e.userMessage,
+      assistantReply: e.assistantResponse,
+      l0Prompt: this.activeTaskTrace,
+      l1Summaries: s,
+      candidates: t
+    }) : this.runHeuristicArbiter(e, t);
+    if (this.applyArbiterDecision(o), this.autoExtractMemories)
+      if (this.extract)
+        try {
+          await this.applyExtraction(
+            await this.extract({ userMessage: e.userMessage, assistantResponse: e.assistantResponse })
+          );
+        } catch {
+          this.autoExtractTurnMemory(e.userMessage, e.assistantResponse);
+        }
+      else e.assistantResponse.length > 50 && this.autoExtractTurnMemory(e.userMessage, e.assistantResponse);
+    if (this.enforceBudgets(), this.onPersist)
+      try {
+        await this.onPersist(this.getSnapshot());
+      } catch {
+      }
+  }
+  /**
+   * Fold extracted memories and tensions in, skipping anything already known.
+   *
+   * Extracted items land in L2 rather than L1: they are candidates, and the
+   * arbiter decides what is worth pre-staging. That is what gives the tiering
+   * something to actually do — previously nothing ever wrote to L2, so every
+   * arbiter run evaluated an empty candidate set.
+   */
+  async applyExtraction(e) {
+    const t = [];
+    for (const s of e.memories ?? []) {
+      const o = s.content.trim();
+      if (o.length < 8 || o.length > 600 || A(o)) continue;
+      let n = o;
+      const r = this.recallSimilar(o);
+      if (r.length > 0) {
+        let h = { action: "add" };
+        if (this.reconcile ? t.push({ content: o, candidates: r }) : r.some((u) => u.content.trim().toLowerCase() === o.trim().toLowerCase()) && (h = { action: "merge" }), h.action === "reject" || h.action === "merge" && r[0] && this.mergeInto(r[0], h.content, { text: o, stored: !1 }))
+          continue;
+        h.action === "replace" && this.supersede(r.map((u) => u.content)), n = h.content?.trim() || o;
+      }
+      const a = Date.now(), l = `mem-${a}-${Math.random().toString(36).slice(2, 7)}`;
+      this.addMemory(
+        {
+          id: l,
+          content: n,
+          bookmark: n.slice(0, 80),
+          tier: "L1",
+          metadata: {
+            domains: s.domains ?? [],
+            createdAt: a,
+            lastAccessedAt: a,
+            accessCount: 1
+          }
+        },
+        "L1"
+      );
+    }
+    if (t.length > 0 && this.reconcile) {
+      let s = [];
+      try {
+        s = await this.reconcile({
+          items: t.map((o) => ({ candidate: o.content, remember: o.candidates.map((n) => n.content) }))
+        });
+      } catch {
+        s = [];
+      }
+      for (const [o, n] of t.entries()) {
+        const r = s[o];
+        if (r)
+          if (r.action === "reject") this.removeByContent(n.content);
+          else if (r.action === "merge") {
+            const a = n.candidates[0];
+            if (a && this.mergeInto(a, r.content, { text: n.content, stored: !0 }))
+              continue;
+          } else r.action === "replace" && (this.supersede(n.candidates.map((a) => a.content)), r.content && this.replaceByContent(n.content, r.content));
+      }
+    }
+    for (const s of e.tensions ?? []) {
+      const o = `${s.claimA}::${s.claimB}`.toLowerCase();
+      this.activeTensions.has(o) || this.addTension({
+        id: o,
+        status: "active",
+        claimA: { source: "user", statement: s.claimA, timestamp: Date.now() },
+        claimB: { source: "conversation", statement: s.claimB, timestamp: Date.now() },
+        impact: s.impact,
+        taskRelevance: 1,
+        actionableQuestion: s.actionableQuestion
+      });
+    }
+  }
+  /** Drop an entry by its exact content. */
+  removeByContent(e) {
+    const t = e.trim().toLowerCase();
+    for (const s of [this.l1HotCache, this.l2WarmStore, this.l3ColdArchive])
+      for (const [o, n] of s)
+        n.content.trim().toLowerCase() === t && s.delete(o);
+  }
+  /** Rewrite one entry's text in place, matched on its old value. */
+  replaceByContent(e, t) {
+    const s = e.trim().toLowerCase();
+    for (const o of [this.l1HotCache, this.l2WarmStore, this.l3ColdArchive])
+      for (const n of o.values())
+        n.content.trim().toLowerCase() === s && !b(n.content, t) && this.enrich(n, t);
+  }
+  /** Replace an entry's content, keeping its identity and tags. */
+  enrich(e, t) {
+    e.content = t, e.bookmark = t.slice(0, 80), e.metadata.lastAccessedAt = Date.now();
+  }
+  /**
+   * Fold a duplicate into its survivor, refusing rewrites that drop anything.
+   *
+   * `merge` returns the model's idea of the fuller statement, and overwriting
+   * with it deletes whatever the model happened to leave out. The under-merge
+   * bias covers merging the *wrong* pair, but nothing covered a lossy rewrite
+   * of the right pair, so containment is checked first.
+   *
+   * @returns false when the rewrite would lose information, in which case the
+   * caller keeps both entries.
+   */
+  mergeInto(e, t, s) {
+    const o = t?.trim();
+    return o && (b(e.content, o) || b(s.text, o)) ? !1 : (s.stored && this.removeByContent(s.text), o && this.enrich(e, o), !0);
+  }
+  /** Retire the entries a replacement supersedes, keeping them out of retrieval. */
+  supersede(e) {
+    const t = new Set(e.map((s) => s.trim().toLowerCase()));
+    for (const s of [this.l1HotCache, this.l2WarmStore, this.l3ColdArchive])
+      for (const [o, n] of s)
+        t.has(n.content.trim().toLowerCase()) && s.delete(o);
+  }
+  /**
+   * Existing memories worth adjudicating a candidate against.
+   *
+   * Cheap and deliberately over-inclusive. An identical string short-circuits
+   * because it is never worth a model call; anything else above the recall floor
+   * is offered to the adjudicator, which decides.
+   */
+  recallSimilar(e) {
+    const t = p(e);
+    return t.size === 0 ? [] : [
+      ...this.l1HotCache.values(),
+      ...this.l2WarmStore.values(),
+      ...this.l3ColdArchive.values()
+    ].map((n) => {
+      const r = p(n.content);
+      let a = 0;
+      for (const l of t) r.has(l) && (a += 1);
+      return { item: n, exact: n.content.trim().toLowerCase() === e.trim().toLowerCase(), score: r.size ? a / Math.min(t.size, r.size) : 0 };
+    }).filter((n) => n.exact || n.score >= G).sort((n, r) => Number(r.exact) - Number(n.exact) || r.score - n.score).slice(0, Q).map((n) => n.item);
+  }
+  /**
+   * Keep the pinned tiers within budget.
+   *
+   * `maxL0Tokens`/`maxL1Tokens` were stored but never read, so L1 grew for the
+   * lifetime of the process. Evict least-recently-accessed first, and demote to
+   * L2 rather than dropping, so nothing is lost.
+   */
+  enforceBudgets() {
+    ((t, s) => {
+      if (s <= 0) return;
+      let o = 0;
+      for (const r of t.values()) o += r.content.length / 4;
+      if (o <= s) return;
+      const n = [...t.values()].sort(
+        (r, a) => r.metadata.lastAccessedAt - a.metadata.lastAccessedAt
+      );
+      for (const r of n) {
+        if (o <= s) break;
+        t.delete(r.id), o -= r.content.length / 4, this.l2WarmStore.set(r.id, { ...r, tier: "L2" });
+      }
+    })(this.l1HotCache, this.maxL1Tokens);
+  }
+  /**
+   * Add a known tension manually or from an external source.
+   */
+  addTension(e) {
+    this.activeTensions.set(e.id, e), this.stats.tensionsDetected += 1;
+  }
+  /**
+   * Mark a tension resolved with an optional reusable pattern.
+   */
+  resolveTension(e, t) {
+    const s = this.activeTensions.get(e);
+    return s ? (s.status = "resolved", s.resolution = {
+      resolvedAt: Date.now(),
+      resolvedBy: t.resolvedBy,
+      pattern: t.pattern
+    }, !0) : !1;
+  }
+  /**
+   * Add a memory directly to L2 warm storage or promote to L1.
+   */
+  addMemory(e, t = "L2") {
+    e.tier = t, t === "L1" ? this.l1HotCache.set(e.id, e) : t === "L2" ? this.l2WarmStore.set(e.id, e) : t === "L3" && this.l3ColdArchive.set(e.id, e);
+  }
+  /**
+   * Drop one memory by id, from whichever tier holds it.
+   *
+   * The counterpart to `addMemory`, and the only way to retire a fact that has
+   * turned out to be wrong. One map is not enough to look in: a promotion or a
+   * demotion moves an id between them, so an id that is absent from the hot
+   * cache may still be in the warm store or the archive. Short-circuiting on the
+   * first hit is therefore safe — an id lives in exactly one of the three.
+   */
+  removeMemory(e) {
+    return this.l1HotCache.delete(e) || this.l2WarmStore.delete(e) || this.l3ColdArchive.delete(e);
+  }
+  /**
+   * Update the proprioceptive capability record for a domain.
+   */
+  recordDomainOutcome(e, t, s) {
+    const o = this.selfModel.domains[e] ?? {
+      reliabilityScore: 0.8,
+      sampleCount: 0,
+      knownFailurePatterns: [],
+      recommendedStrategies: []
+    }, n = o.sampleCount + 1, r = 1 / Math.min(n, 10), a = t ? 1 : 0, l = o.reliabilityScore * (1 - r) + a * r;
+    !t && s && !o.knownFailurePatterns.includes(s) && o.knownFailurePatterns.push(s), this.selfModel.domains[e] = {
+      reliabilityScore: Number(l.toFixed(3)),
+      sampleCount: n,
+      knownFailurePatterns: o.knownFailurePatterns,
+      recommendedStrategies: o.recommendedStrategies
+    };
+  }
+  getSnapshot() {
+    return {
+      l0: {
+        tensions: Array.from(this.activeTensions.values()),
+        selfModel: JSON.parse(JSON.stringify(this.selfModel)),
+        activeTaskTrace: this.activeTaskTrace
+      },
+      l1: Array.from(this.l1HotCache.values()),
+      l2: Array.from(this.l2WarmStore.values()),
+      l3: Array.from(this.l3ColdArchive.values()),
+      stats: { ...this.stats }
+    };
+  }
+  loadSnapshot(e) {
+    this.activeTensions.clear();
+    for (const t of e.l0.tensions)
+      this.activeTensions.set(t.id, t);
+    this.selfModel = e.l0.selfModel, this.activeTaskTrace = e.l0.activeTaskTrace, this.l1HotCache.clear();
+    for (const t of e.l1)
+      this.l1HotCache.set(t.id, t);
+    this.l2WarmStore.clear();
+    for (const t of e.l2)
+      this.l2WarmStore.set(t.id, t);
+    this.l3ColdArchive.clear();
+    for (const t of e.l3)
+      this.l3ColdArchive.set(t.id, t);
+    this.stats = { ...e.stats };
+  }
+  applyArbiterDecision(e) {
+    for (const t of e.promotions) {
+      const s = this.l2WarmStore.get(t.memoryId) ?? this.l3ColdArchive.get(t.memoryId);
+      s && (s.tier = "L1", s.metadata.lastAccessedAt = Date.now(), s.metadata.accessCount += 1, this.l1HotCache.set(s.id, s), this.l2WarmStore.delete(s.id), this.l3ColdArchive.delete(s.id));
+    }
+    for (const t of e.demotions) {
+      const s = this.l1HotCache.get(t.memoryId);
+      s && (s.tier = "L2", this.l2WarmStore.set(s.id, s), this.l1HotCache.delete(s.id));
+    }
+    for (const t of e.detectedTensions) {
+      const s = `tension-${Date.now()}-${Math.random().toString(36).slice(2, 6)}`;
+      this.addTension({
+        id: s,
+        status: "active",
+        claimA: { source: "current conversation", statement: t.claimA, timestamp: Date.now() },
+        claimB: { source: "known state / files", statement: t.claimB, timestamp: Date.now() },
+        impact: t.impact,
+        taskRelevance: 1,
+        actionableQuestion: t.actionableQuestion
+      });
+    }
+    if (e.selfModelUpdate) {
+      const { domain: t, success: s, failurePatternObserved: o } = e.selfModelUpdate;
+      s !== void 0 && this.recordDomainOutcome(t, s, o);
+    }
+  }
+  /**
+   * Fast default heuristic arbiter when an LLM arbiter model is not supplied.
+   */
+  runHeuristicArbiter(e, t) {
+    const s = [], o = [], n = g(`${e.userMessage} ${e.assistantResponse}`), r = t.map((a) => ({
+      candidate: a,
+      score: v(
+        n,
+        g(`${a.bookmark} ${a.domains.join(" ")}`)
+      )
+    })).filter((a) => a.score > Z).sort((a, l) => l.score - a.score).slice(0, 3);
+    for (const { candidate: a, score: l } of r)
+      s.push({
+        memoryId: a.id,
+        targetTier: "L1",
+        signalType: "anticipatory",
+        urgency: Math.min(1, l)
+      });
+    for (const a of this.l1HotCache.values())
+      !(v(n, g(`${a.bookmark} ${a.metadata.domains.join(" ")}`)) > 0) && this.l1HotCache.size > te && o.push({
+        memoryId: a.id,
+        targetTier: "L2",
+        reason: "Not referenced in recent turns"
+      });
+    return process.env.NAH_MEMORY_DEBUG && console.log(
+      `    [arbiter] scored=${JSON.stringify(r.map((a) => ({ id: a.candidate.id, score: Number(a.score.toFixed(2)) })))} promotions=${s.length} demotions=${o.length}`
+    ), { promotions: s, demotions: o, pins: [], detectedTensions: [] };
+  }
+  autoExtractTurnMemory(e, t) {
+    const s = e.match(/(?:always|never|make sure to|remember to|use)\s+([^\.\n]+)/i);
+    if (s && s[1]) {
+      const o = `mem-pref-${Date.now()}`, n = s[1].trim();
+      if (A(`User preference: ${n}`)) return;
+      this.addMemory({
+        id: o,
+        content: `User preference: ${n}`,
+        bookmark: `User preference: ${n.slice(0, 80)}`,
+        tier: "L1",
+        // Pre-stage directly into hot cache
+        metadata: {
+          domains: this.selfModel.activeDomains,
+          createdAt: Date.now(),
+          lastAccessedAt: Date.now(),
+          accessCount: 1
+        }
+      }, "L1");
+    }
+  }
+}
+const se = /\bhttps?:\/\/[^\s<>()[\]"'`]+/g, oe = /\b(always|never|must|should|make sure to|remember to)\b[\s:]+([^.?!\n]{4,160})/gi, ne = /\b([A-Za-z][\w ()-]{2,60}?)\s+(?:is|are)\s+([^\n?!]{3,200})/g, ie = /[A-Z0-9_./:-]/, re = (i) => {
+  const e = i.trim();
+  return e.length < 3 || e.length > 200 || /^(not|nothing|unclear|unknown|the same|that|this|it)\b/i.test(e) ? !1 : ie.test(e);
+}, ae = (i) => {
+  const e = /\.(?=\s+[A-Z(])/.exec(i);
+  return e ? i.slice(0, e.index) : i;
+}, w = (i) => ae(i).replace(/\s+/g, " ").replace(/^(?:that|the|a|an|it|this)\s+/i, "").replace(/[,;:\s.。]+$/, "").trim(), we = (i) => {
+  const e = [], t = (o) => {
+    const n = w(o);
+    n.length < 8 || n.length > 300 || /^(yes|no|ok|okay|sure|thanks|thank you|got it|noted)\b/i.test(n) || e.some((r) => r.content.toLowerCase() === n.toLowerCase()) || e.push({ content: n, domains: [] });
+  };
+  for (const o of i.match(se) ?? [])
+    t(`User-provided URL: ${o}`);
+  for (const o of i.matchAll(oe)) {
+    const n = (o[1] ?? "").toLowerCase(), r = w(o[2] ?? "");
+    r && t(`User requirement (${n}): ${r}`);
+  }
+  for (const o of i.matchAll(ne)) {
+    const n = w(o[1] ?? ""), r = w(o[2] ?? "");
+    !n || !re(r) || t(`${n} is ${r}`);
+  }
+  return e.filter(
+    (o, n) => !e.some((r, a) => a === n || r.content.length <= o.content.length ? !1 : ce(o.content, r.content))
+  ).slice(0, 6);
+}, ce = (i, e) => {
+  const t = new Set(e.toLowerCase().split(/[^a-z0-9]+/).filter((o) => o.length >= 4)), s = i.toLowerCase().split(/[^a-z0-9]+/).filter((o) => o.length >= 4);
+  return s.length > 0 && s.every((o) => t.has(o));
+};
+export {
+  G as CANDIDATE_FLOOR,
+  K as COLLAPSE_THRESHOLD,
+  U as Cogmem,
+  ge as CognitiveMemory,
+  T as CognitiveMemoryError,
+  R as ContextResource,
+  Q as MAX_CANDIDATES,
+  I as MemoriesResource,
+  Z as PROMOTE_THRESHOLD,
+  O as RecallResource,
+  j as SelfModelResource,
+  H as StatsResource,
+  z as TensionsResource,
+  N as TurnsResource,
+  he as createClient,
+  L as createHttpClient,
+  p as distinctiveTokens,
+  ee as estimateTokens,
+  we as extractDeterministic,
+  k as extractDomains,
+  fe as extractIdentifiers,
+  P as fetchHealth,
+  $ as gistOf,
+  A as isInteractionScoped,
+  b as isLossyRewrite,
+  pe as normalise,
+  v as overlapScore,
+  me as recallOrExplain,
+  g as relevanceTokens,
+  F as runFastGate,
+  de as runTurn,
+  ue as seedMemories,
+  X as similarity
+};
+//# sourceMappingURL=cognitive-memory.js.map