@titan-design/memory 0.1.0

package/dist/index.js

@@ -0,0 +1,661 @@
+// src/types.ts
+import { z } from "zod";
+var BULLET_SCOPES = ["global", "workspace", "language", "framework", "task"];
+var BULLET_TYPES = ["rule", "anti-pattern"];
+var BULLET_KINDS = ["project_convention", "stack_pattern", "workflow_rule", "anti_pattern"];
+var BULLET_SOURCES = ["learned", "community", "manual", "custom"];
+var BULLET_STATES = ["draft", "active", "retired"];
+var MATURITIES = ["candidate", "established", "proven", "deprecated"];
+var addDelta = z.object({
+  type: z.literal("add"),
+  content: z.string().min(1),
+  category: z.string().min(1).default("general"),
+  tags: z.array(z.string()).default([]),
+  scope: z.enum(BULLET_SCOPES).default("workspace"),
+  kind: z.enum(BULLET_KINDS).default("workflow_rule"),
+  isNegative: z.boolean().default(false),
+  reasoning: z.string().optional()
+});
+var feedbackDelta = (type) => z.object({ type: z.literal(type), bulletId: z.string().min(1), reason: z.string().optional() });
+var replaceDelta = z.object({ type: z.literal("replace"), bulletId: z.string().min(1), content: z.string().min(1), reasoning: z.string().optional() });
+var deprecateDelta = z.object({ type: z.literal("deprecate"), bulletId: z.string().min(1), reason: z.string().min(1) });
+var mergeDelta = z.object({ type: z.literal("merge"), bulletIds: z.array(z.string().min(1)).min(2), content: z.string().min(1), reasoning: z.string().optional() });
+var PlaybookDeltaSchema = z.discriminatedUnion("type", [
+  addDelta,
+  feedbackDelta("helpful"),
+  feedbackDelta("harmful"),
+  replaceDelta,
+  deprecateDelta,
+  mergeDelta
+]);
+
+// src/schema.ts
+import { SQL_NOW, kitDdl, quoteIdent } from "@titan-design/store-sqlite";
+var DEFAULT_MEMORY_TABLES = {
+  entity: "memory_entity",
+  edge: "memory_edge",
+  cacheBlob: "memory_cache",
+  watermark: "memory_watermark",
+  feedback: "memory_feedback"
+};
+var BULLET_KIND = "bullet";
+var BLOCKED_KIND = "blocked";
+var SUPERSEDES = "supersedes";
+function feedbackTableDdl(name = DEFAULT_MEMORY_TABLES.feedback) {
+  const t = quoteIdent(name);
+  return `
+    CREATE TABLE IF NOT EXISTS ${t} (
+      id          INTEGER PRIMARY KEY,
+      bullet_ref  TEXT NOT NULL,
+      type        TEXT NOT NULL,
+      at          TEXT NOT NULL DEFAULT (${SQL_NOW}),
+      session_ref TEXT,
+      reason      TEXT
+    );
+    CREATE INDEX IF NOT EXISTS ${quoteIdent(`idx_${name}_bullet`)} ON ${t}(bullet_ref, at);
+  `;
+}
+function memoryDdl(tables = DEFAULT_MEMORY_TABLES) {
+  const kit = kitDdl({ entity: tables.entity, edge: tables.edge, cacheBlob: tables.cacheBlob, watermark: tables.watermark });
+  return `${kit}
+${feedbackTableDdl(tables.feedback)}`;
+}
+function memoryMigration(version, tables = DEFAULT_MEMORY_TABLES) {
+  return { version, name: `memory:${tables.entity}`, up: (db) => db.exec(memoryDdl(tables)) };
+}
+
+// src/scoring.ts
+var DEFAULT_HALF_LIFE_DAYS = 90;
+var HARMFUL_WEIGHT = 4;
+var HARD_DEPRECATE_SCORE = -3;
+var MATURITY_MULTIPLIER = { candidate: 0.5, established: 1, proven: 1.5, deprecated: 0 };
+var RANK = { deprecated: 0, candidate: 1, established: 2, proven: 3 };
+var BY_RANK = ["deprecated", "candidate", "established", "proven"];
+var DAY_MS = 864e5;
+function decayedValue(at, now, halfLifeDays = DEFAULT_HALF_LIFE_DAYS) {
+  const ageDays = Math.max(0, now.getTime() - Date.parse(at)) / DAY_MS;
+  return 0.5 ** (ageDays / halfLifeDays);
+}
+function decayedCounts(events, now, halfLifeDays = DEFAULT_HALF_LIFE_DAYS) {
+  const counts = { helpful: 0, harmful: 0 };
+  for (const event of events) counts[event.type] += decayedValue(event.at, now, halfLifeDays);
+  return counts;
+}
+function effectiveScore(counts, maturity) {
+  return (counts.helpful - HARMFUL_WEIGHT * counts.harmful) * MATURITY_MULTIPLIER[maturity];
+}
+function maturityFor(counts) {
+  const total = counts.helpful + counts.harmful;
+  const harmfulRatio = total === 0 ? 0 : counts.harmful / total;
+  if (total < 3) return "candidate";
+  if (harmfulRatio > 0.3) return "deprecated";
+  if (counts.helpful >= 10 && harmfulRatio < 0.1) return "proven";
+  return "established";
+}
+function nextMaturity(current, counts, pinned) {
+  if (pinned || current === "deprecated") return current;
+  if (effectiveScore(counts, current) < HARD_DEPRECATE_SCORE) return "deprecated";
+  const target = maturityFor(counts);
+  if (RANK[target] > RANK[current]) return target;
+  if (RANK[target] < RANK[current]) return BY_RANK[RANK[current] - 1];
+  return current;
+}
+function isStale(lastEvidenceAt, now, { staleAfterDays = 180 } = {}) {
+  return now.getTime() - Date.parse(lastEvidenceAt) > staleAfterDays * DAY_MS;
+}
+
+// src/text.ts
+import { contentHashOf } from "@titan-design/store-sqlite";
+var TOKEN = /[a-z0-9_]+/g;
+var NEGATION = /\b(never|don'?t|do not|avoid|not|no|stop|without)\b/i;
+function tokenize(text) {
+  const out = /* @__PURE__ */ new Set();
+  for (const match of text.toLowerCase().matchAll(TOKEN)) if (match[0].length >= 2) out.add(match[0]);
+  return out;
+}
+function normalizeContent(text) {
+  return text.toLowerCase().replace(/\s+/g, " ").trim();
+}
+function contentKey(text) {
+  return contentHashOf(normalizeContent(text));
+}
+function jaccard(a, b) {
+  const ta = tokenize(a);
+  const tb = tokenize(b);
+  if (ta.size === 0 && tb.size === 0) return 1;
+  let shared = 0;
+  for (const token of ta) if (tb.has(token)) shared++;
+  return shared / (ta.size + tb.size - shared);
+}
+function isNegated(text) {
+  return NEGATION.test(text);
+}
+
+// src/store.ts
+import { EdgeTable, EntityTable, quoteIdent as quoteIdent2, refKind } from "@titan-design/store-sqlite";
+import { randomUUID } from "crypto";
+var bulletRef = refKind("memory");
+var blockedRef = refKind("memory-blocked");
+var BulletNotFound = class extends Error {
+  constructor(id) {
+    super(`bullet not found: ${id}`);
+    this.name = "BulletNotFound";
+  }
+};
+var PlaybookStore = class {
+  tables;
+  entities;
+  edges;
+  now;
+  insertFeedback;
+  feedbackByBullet;
+  allFeedback;
+  constructor(db, options = {}) {
+    this.tables = options.tables ?? DEFAULT_MEMORY_TABLES;
+    this.now = options.now ?? (() => /* @__PURE__ */ new Date());
+    this.entities = new EntityTable(db, { name: this.tables.entity });
+    this.edges = new EdgeTable(db, { name: this.tables.edge });
+    const f = quoteIdent2(this.tables.feedback);
+    this.insertFeedback = db.prepare(`INSERT INTO ${f} (bullet_ref, type, at, session_ref, reason) VALUES (?, ?, ?, ?, ?)`);
+    this.feedbackByBullet = db.prepare(`SELECT * FROM ${f} WHERE bullet_ref = ? ORDER BY at, id`);
+    this.allFeedback = db.prepare(`SELECT * FROM ${f} ORDER BY at, id`);
+  }
+  add(input) {
+    const at = this.now().toISOString();
+    const bullet = materialize(input, at);
+    this.write(bullet);
+    return bullet;
+  }
+  get(id) {
+    const row = this.entities.get(bulletRef(id));
+    return row === void 0 || row.kind !== BULLET_KIND ? void 0 : toBullet(row);
+  }
+  require(id) {
+    const bullet = this.get(id);
+    if (bullet === void 0) throw new BulletNotFound(id);
+    return bullet;
+  }
+  /** Live bullets only, unless `includeRetired`; ordered by id for determinism. */
+  list({ includeRetired = false } = {}) {
+    const all = this.entities.listByKind(BULLET_KIND).map(toBullet);
+    return includeRetired ? all : all.filter((b) => b.state !== "retired");
+  }
+  update(id, patch) {
+    const next = { ...this.require(id), ...patch, updatedAt: this.now().toISOString() };
+    this.write(next);
+    return next;
+  }
+  /** Retire a bullet. With `replacedBy`, also assert `replacedBy -supersedes-> id`. */
+  deprecate(id, reason, replacedBy = null) {
+    const at = this.now().toISOString();
+    const bullet = this.update(id, { state: "retired", maturity: "deprecated", replacedBy, deprecatedAt: at, deprecationReason: reason });
+    if (replacedBy !== null) this.edges.assert({ sourceRef: bulletRef(replacedBy), relation: SUPERSEDES, targetRef: bulletRef(id), tValid: at });
+    return bullet;
+  }
+  /** Ids of the bullets this one replaced, following live `supersedes` edges. */
+  supersededBy(id) {
+    return this.edges.from(bulletRef(id)).filter((e) => e.relation === SUPERSEDES).map((e) => e.targetRef.slice("memory:".length));
+  }
+  recordFeedback(id, type, input = {}) {
+    this.require(id);
+    const at = input.at ?? this.now().toISOString();
+    const info = this.insertFeedback.run(bulletRef(id), type, at, input.sessionRef ?? null, input.reason ?? null);
+    return { id: Number(info.lastInsertRowid), bulletId: id, type, at, sessionRef: input.sessionRef ?? null, reason: input.reason ?? null };
+  }
+  feedbackFor(id) {
+    return this.feedbackByBullet.all(bulletRef(id)).map(toEvent);
+  }
+  /** Every event grouped by bullet id, one query, for scoring the whole playbook. */
+  feedbackByBulletId() {
+    const grouped = /* @__PURE__ */ new Map();
+    for (const event of this.allFeedback.all().map(toEvent)) {
+      const list = grouped.get(event.bulletId) ?? [];
+      list.push(event);
+      grouped.set(event.bulletId, list);
+    }
+    return grouped;
+  }
+  /** A content pattern a human has banned; the curator refuses to re-learn anything near it. */
+  block(pattern, reason) {
+    const blockedAt = this.now().toISOString();
+    this.entities.upsert({ ref: blockedRef(randomUUID()), kind: BLOCKED_KIND, name: pattern, attrs: { reason, blockedAt }, tValid: blockedAt });
+    return { pattern, reason, blockedAt };
+  }
+  blockedPatterns() {
+    return this.entities.listByKind(BLOCKED_KIND).map((row) => ({
+      pattern: row.name ?? "",
+      reason: String(row.attrs?.reason ?? ""),
+      blockedAt: String(row.attrs?.blockedAt ?? row.tValid)
+    }));
+  }
+  write(bullet) {
+    const { id, content, category, ...attrs } = bullet;
+    this.entities.upsert({ ref: bulletRef(id), kind: BULLET_KIND, name: category, attrs: { ...attrs, content }, tValid: bullet.createdAt });
+  }
+};
+function newBulletId(now = /* @__PURE__ */ new Date()) {
+  return `b-${now.getTime().toString(36)}-${randomUUID().slice(0, 6)}`;
+}
+function materialize(input, at) {
+  return {
+    id: input.id ?? newBulletId(new Date(at)),
+    content: input.content,
+    category: input.category ?? "general",
+    tags: [...input.tags ?? []],
+    scope: input.scope ?? "workspace",
+    type: input.type ?? (input.isNegative ? "anti-pattern" : "rule"),
+    kind: input.kind ?? (input.isNegative ? "anti_pattern" : "workflow_rule"),
+    isNegative: input.isNegative ?? false,
+    source: input.source ?? "learned",
+    state: input.state ?? "active",
+    maturity: "candidate",
+    pinned: input.pinned ?? false,
+    pinnedReason: input.pinnedReason ?? null,
+    replacedBy: null,
+    deprecatedAt: null,
+    deprecationReason: null,
+    halfLifeDays: input.halfLifeDays ?? DEFAULT_HALF_LIFE_DAYS,
+    sourceSessions: [...input.sourceSessions ?? []],
+    reasoning: input.reasoning ?? null,
+    createdAt: at,
+    updatedAt: at
+  };
+}
+function toBullet(row) {
+  const attrs = row.attrs ?? {};
+  const { content, ...rest } = attrs;
+  return { id: row.ref.slice("memory:".length), content, category: row.name ?? "general", ...rest };
+}
+function toEvent(raw) {
+  return { id: raw.id, bulletId: raw.bullet_ref.slice("memory:".length), type: raw.type, at: raw.at, sessionRef: raw.session_ref, reason: raw.reason };
+}
+
+// src/playbook.ts
+function scoreBullet(bullet, events, now) {
+  const counts = decayedCounts(events, now, bullet.halfLifeDays);
+  const last = events[events.length - 1];
+  return {
+    ...bullet,
+    helpfulCount: events.filter((e) => e.type === "helpful").length,
+    harmfulCount: events.filter((e) => e.type === "harmful").length,
+    decayedHelpful: counts.helpful,
+    decayedHarmful: counts.harmful,
+    effectiveScore: effectiveScore(counts, bullet.maturity),
+    lastEvidenceAt: last?.at ?? bullet.createdAt
+  };
+}
+function scorePlaybook(store, now, options = {}) {
+  const feedback = store.feedbackByBulletId();
+  return store.list(options).map((bullet) => scoreBullet(bullet, feedback.get(bullet.id) ?? [], now));
+}
+function applyMaturity(store, now) {
+  const changes = [];
+  for (const bullet of scorePlaybook(store, now)) {
+    const to = nextMaturity(bullet.maturity, { helpful: bullet.decayedHelpful, harmful: bullet.decayedHarmful }, bullet.pinned);
+    if (to === bullet.maturity) continue;
+    if (to === "deprecated") store.deprecate(bullet.id, "auto-demoted below the confidence floor");
+    else store.update(bullet.id, { maturity: to });
+    changes.push({ bulletId: bullet.id, from: bullet.maturity, to });
+  }
+  return changes;
+}
+function staleBullets(store, now, options = {}) {
+  return scorePlaybook(store, now).filter((b) => !b.pinned && isStale(b.lastEvidenceAt, now, options));
+}
+
+// src/curate.ts
+function curate(store, deltas, options = {}) {
+  const ctx = makeContext(store, options);
+  const parsed = deltas.map((delta) => PlaybookDeltaSchema.parse(delta));
+  for (const delta of dedupeDeltas(parsed, ctx.report)) applyDelta(ctx, delta);
+  invertHarmfulRules(ctx);
+  ctx.report.maturityChanges = applyMaturity(store, ctx.now());
+  return ctx.report;
+}
+function makeContext(store, options) {
+  return {
+    store,
+    report: { added: [], reinforced: [], penalized: [], deprecated: [], inverted: [], blocked: [], skipped: [], conflicts: [], maturityChanges: [] },
+    now: options.now ?? (() => /* @__PURE__ */ new Date()),
+    provenance: options.provenance ? [options.provenance] : [],
+    nearDup: options.nearDupThreshold ?? 0.85,
+    conflict: options.conflictThreshold ?? 0.5,
+    inversion: { minHarmful: options.inversion?.minHarmful ?? 3, harmfulToHelpfulRatio: options.inversion?.harmfulToHelpfulRatio ?? 2 },
+    blocked: store.blockedPatterns()
+  };
+}
+function dedupeDeltas(deltas, report) {
+  const seen = /* @__PURE__ */ new Set();
+  const kept = [];
+  for (const delta of deltas) {
+    const key = delta.type === "add" ? contentKey(delta.content) : JSON.stringify(delta);
+    if (seen.has(key)) report.skipped.push({ delta, reason: "duplicate delta" });
+    else {
+      seen.add(key);
+      kept.push(delta);
+    }
+  }
+  return kept;
+}
+function applyDelta(ctx, delta) {
+  switch (delta.type) {
+    case "add":
+      return applyAdd(ctx, delta);
+    case "helpful":
+    case "harmful":
+      return applyFeedback(ctx, delta);
+    case "replace":
+      return applyReplace(ctx, delta);
+    case "deprecate":
+      return applyDeprecate(ctx, delta);
+    case "merge":
+      return applyMerge(ctx, delta);
+  }
+}
+function applyAdd(ctx, delta) {
+  if (isBlocked(ctx, delta.content)) {
+    ctx.report.blocked.push(delta.content);
+    return;
+  }
+  const live = ctx.store.list();
+  const duplicate = findDuplicate(live, delta.content, ctx.nearDup);
+  if (duplicate) {
+    reinforce(ctx, duplicate.id, "restated by a new add");
+    return;
+  }
+  const bullet = ctx.store.add({ ...addFields(delta), sourceSessions: ctx.provenance });
+  ctx.report.added.push(bullet.id);
+  detectConflicts(ctx, bullet, live);
+}
+function applyFeedback(ctx, delta) {
+  if (!ctx.store.get(delta.bulletId)) {
+    ctx.report.skipped.push({ delta, reason: "unknown bullet" });
+    return;
+  }
+  ctx.store.recordFeedback(delta.bulletId, delta.type, { sessionRef: ctx.provenance[0]?.sessionRef, reason: delta.reason });
+  (delta.type === "helpful" ? ctx.report.reinforced : ctx.report.penalized).push(delta.bulletId);
+}
+function applyReplace(ctx, delta) {
+  const old = ctx.store.get(delta.bulletId);
+  if (!old) {
+    ctx.report.skipped.push({ delta, reason: "unknown bullet" });
+    return;
+  }
+  const next = ctx.store.add({ ...inherit(old), content: delta.content, reasoning: delta.reasoning ?? old.reasoning, sourceSessions: [...old.sourceSessions, ...ctx.provenance] });
+  ctx.store.deprecate(old.id, "replaced", next.id);
+  ctx.report.added.push(next.id);
+  ctx.report.deprecated.push(old.id);
+}
+function applyDeprecate(ctx, delta) {
+  if (!ctx.store.get(delta.bulletId)) {
+    ctx.report.skipped.push({ delta, reason: "unknown bullet" });
+    return;
+  }
+  ctx.store.deprecate(delta.bulletId, delta.reason);
+  ctx.report.deprecated.push(delta.bulletId);
+}
+function applyMerge(ctx, delta) {
+  const olds = delta.bulletIds.map((id) => ctx.store.get(id));
+  const first = olds[0];
+  if (!first || olds.some((b) => b === void 0)) {
+    ctx.report.skipped.push({ delta, reason: "unknown bullet" });
+    return;
+  }
+  const present = olds;
+  const next = ctx.store.add({
+    ...inherit(first),
+    content: delta.content,
+    tags: [...new Set(present.flatMap((b) => b.tags))],
+    reasoning: delta.reasoning ?? first.reasoning,
+    sourceSessions: [...present.flatMap((b) => b.sourceSessions), ...ctx.provenance]
+  });
+  ctx.report.added.push(next.id);
+  for (const old of present) {
+    ctx.store.deprecate(old.id, "merged", next.id);
+    ctx.report.deprecated.push(old.id);
+  }
+}
+function addFields(delta) {
+  const { content, category, tags, scope, kind, isNegative, reasoning } = delta;
+  return { content, category, tags, scope, kind, isNegative, reasoning };
+}
+function inherit(bullet) {
+  const { category, tags, scope, type, kind, isNegative, source, halfLifeDays } = bullet;
+  return { category, tags, scope, type, kind, isNegative, source, halfLifeDays };
+}
+function reinforce(ctx, id, reason) {
+  ctx.store.recordFeedback(id, "helpful", { sessionRef: ctx.provenance[0]?.sessionRef, reason });
+  ctx.report.reinforced.push(id);
+}
+function isBlocked(ctx, content) {
+  const normalized = normalizeContent(content);
+  return ctx.blocked.some((b) => normalizeContent(b.pattern) === normalized || jaccard(b.pattern, content) >= ctx.nearDup);
+}
+function findDuplicate(live, content, threshold) {
+  const key = contentKey(content);
+  const negated = isNegated(content);
+  return live.find((b) => contentKey(b.content) === key) ?? live.find((b) => isNegated(b.content) === negated && jaccard(b.content, content) >= threshold);
+}
+function detectConflicts(ctx, bullet, others) {
+  const negated = isNegated(bullet.content);
+  for (const other of others) {
+    if (isNegated(other.content) === negated || jaccard(bullet.content, other.content) < ctx.conflict) continue;
+    ctx.report.conflicts.push({ bulletId: bullet.id, otherId: other.id, reason: "similar wording with opposite polarity" });
+  }
+}
+function shouldInvert(ctx, bullet) {
+  if (bullet.type !== "rule" || bullet.pinned || bullet.state !== "active") return false;
+  return bullet.decayedHarmful >= ctx.inversion.minHarmful && bullet.decayedHarmful > ctx.inversion.harmfulToHelpfulRatio * bullet.decayedHelpful;
+}
+function invertHarmfulRules(ctx) {
+  for (const bullet of scorePlaybook(ctx.store, ctx.now())) {
+    if (!shouldInvert(ctx, bullet)) continue;
+    const avoid = ctx.store.add({
+      ...inherit(bullet),
+      content: `AVOID: ${bullet.content}`,
+      type: "anti-pattern",
+      kind: "anti_pattern",
+      isNegative: true,
+      reasoning: "inverted after repeated harmful feedback",
+      sourceSessions: [...bullet.sourceSessions, ...ctx.provenance]
+    });
+    ctx.store.deprecate(bullet.id, "inverted to an anti-pattern", avoid.id);
+    ctx.report.inverted.push({ from: bullet.id, to: avoid.id });
+  }
+}
+
+// src/recall.ts
+import { gatherFailOpen, vectorRetriever } from "@titan-design/retrieval";
+var EXACT_TOKEN = 3;
+var SUBSTRING = 1;
+var TAG_MATCH = 5;
+var SCORE_FLOOR = 0.1;
+async function recall(store, query, options = {}) {
+  const now = options.now ?? /* @__PURE__ */ new Date();
+  const limit = options.limit ?? 10;
+  const minRelevance = options.minRelevance ?? 0.1;
+  const candidates = scorePlaybook(store, now, { includeRetired: true }).filter((b) => inScope(b, options.scope));
+  const semantic = await semanticScores(query, candidates.length, options.semantic);
+  const ranked = candidates.map((b) => rank(b, query, options, semantic)).filter((b) => b.relevanceScore >= minRelevance).sort(byScore);
+  const live = ranked.filter((b) => b.state !== "retired");
+  return {
+    bullets: live.filter((b) => !b.isNegative).slice(0, limit),
+    antiPatterns: live.filter((b) => b.isNegative).slice(0, limit),
+    deprecatedWarnings: ranked.filter((b) => b.state === "retired").slice(0, limit),
+    degraded: semantic.degraded
+  };
+}
+function inScope(bullet, scope) {
+  return scope === void 0 || bullet.scope === "global" || bullet.scope === scope;
+}
+function keywordScore(content, tags, query, extraTags = []) {
+  const contentTokens = tokenize(content);
+  const lower = content.toLowerCase();
+  const tagSet = new Set(tags.map((t) => t.toLowerCase()));
+  let score = 0;
+  for (const token of tokenize(query)) {
+    if (contentTokens.has(token)) score += EXACT_TOKEN;
+    else if (lower.includes(token)) score += SUBSTRING;
+    if (tagSet.has(token)) score += TAG_MATCH;
+  }
+  for (const tag of extraTags) if (tagSet.has(tag.toLowerCase())) score += TAG_MATCH;
+  return score;
+}
+async function semanticScores(query, count, options) {
+  if (!options || count === 0) return { similarity: /* @__PURE__ */ new Map(), weight: 0, degraded: [] };
+  const retriever = vectorRetriever(options.embedder, options.index, { name: "memory-vector" });
+  const { lists, degraded } = await gatherFailOpen([retriever], query, { limit: count, timeoutMs: options.timeoutMs });
+  const similarity = /* @__PURE__ */ new Map();
+  for (const hit of lists[0]?.hits ?? []) similarity.set(hit.id, hit.score ?? 0);
+  return { similarity, weight: degraded.length === 0 ? options.weight ?? 0.6 : 0, degraded };
+}
+function rank(bullet, query, options, semantic) {
+  const keyword = keywordScore(bullet.content, bullet.tags, query, options.tags);
+  const similarity = semantic.similarity.get(bullet.id);
+  const semanticScore = semantic.weight === 0 ? null : similarity ?? 0;
+  const relevanceScore = keyword * (1 - semantic.weight) + (semanticScore ?? 0) * semantic.weight;
+  return { ...bullet, keywordScore: keyword, semanticScore, relevanceScore, finalScore: relevanceScore * Math.max(SCORE_FLOOR, bullet.effectiveScore) };
+}
+function byScore(a, b) {
+  return b.finalScore - a.finalScore || b.relevanceScore - a.relevanceScore || a.id.localeCompare(b.id);
+}
+
+// src/vectors.ts
+import { fromFloat32Buffer, toFloat32Buffer } from "@titan-design/embed";
+import { BruteForceVectorIndex } from "@titan-design/retrieval";
+import { CacheBlobTable } from "@titan-design/store-sqlite";
+var MemoryVectors = class {
+  constructor(db, embedder, options = {}) {
+    this.embedder = embedder;
+    this.cache = new CacheBlobTable(db, { name: (options.tables ?? DEFAULT_MEMORY_TABLES).cacheBlob });
+    this.namespace = options.namespace ?? "memory:bullet";
+  }
+  embedder;
+  cache;
+  namespace;
+  /** Embed every bullet the cache does not have, in one call. Returns how many were computed. */
+  async ensure(bullets) {
+    const missing = bullets.filter((b) => this.cache.get(this.keyFor(b)) === void 0);
+    if (missing.length === 0) return 0;
+    const vectors = await this.embedder.embed(missing.map((b) => normalizeContent(b.content)));
+    missing.forEach((bullet, i) => {
+      const vector = vectors[i];
+      if (vector) this.cache.put(this.keyFor(bullet), toFloat32Buffer(vector), { bulletId: bullet.id });
+    });
+    return missing.length;
+  }
+  /** A searchable index over these bullets, embedding any misses first. */
+  async index(bullets) {
+    await this.ensure(bullets);
+    const index = new BruteForceVectorIndex();
+    for (const bullet of bullets) {
+      const hit = this.cache.get(this.keyFor(bullet));
+      if (hit) index.add(bullet.id, fromFloat32Buffer(hit.value));
+    }
+    return index;
+  }
+  keyFor(bullet) {
+    return { namespace: this.namespace, model: this.embedder.model, text: normalizeContent(bullet.content) };
+  }
+};
+
+// src/reflect.ts
+async function reflectSession(deps, input, reflector, options = {}) {
+  const maxIterations = options.maxIterations ?? 3;
+  const maxDeltas = options.maxDeltas ?? 50;
+  const deltas = [];
+  const rejected = [];
+  const seen = /* @__PURE__ */ new Set();
+  let iterations = 0;
+  while (iterations < maxIterations && deltas.length < maxDeltas) {
+    iterations++;
+    const raw = await reflector({ sessionRef: input.sessionRef, diary: input.diary, iteration: iterations, bullets: deps.store.list(), priorDeltas: [...deltas] });
+    const fresh = parseDeltas(raw, seen, iterations, rejected);
+    if (fresh.length === 0) break;
+    deltas.push(...fresh.slice(0, maxDeltas - deltas.length));
+  }
+  const report = curate(deps.store, deltas, { ...curateOptions(options), provenance: { sessionRef: input.sessionRef, byteOffset: input.byteOffset } });
+  advanceWatermark(deps.watermark, input);
+  return { deltas, rejected, iterations, report };
+}
+function curateOptions(options) {
+  const { now, nearDupThreshold, conflictThreshold, inversion } = options;
+  return { now, nearDupThreshold, conflictThreshold, inversion };
+}
+function parseDeltas(raw, seen, iteration, rejected) {
+  if (!Array.isArray(raw)) {
+    rejected.push({ iteration, index: -1, reason: "reflector did not return an array" });
+    return [];
+  }
+  const fresh = [];
+  raw.forEach((item, index) => {
+    const parsed = PlaybookDeltaSchema.safeParse(item);
+    if (!parsed.success) {
+      rejected.push({ iteration, index, reason: parsed.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ") });
+      return;
+    }
+    const key = deltaKey(parsed.data);
+    if (seen.has(key)) return;
+    seen.add(key);
+    fresh.push(parsed.data);
+  });
+  return fresh;
+}
+function deltaKey(delta) {
+  switch (delta.type) {
+    case "add":
+    case "replace":
+    case "merge":
+      return `${delta.type}:${normalizeContent(delta.content)}`;
+    default:
+      return `${delta.type}:${delta.bulletId}`;
+  }
+}
+function advanceWatermark(watermark, input) {
+  if (!watermark) return;
+  watermark.ensure(input.sessionRef);
+  watermark.advance(input.sessionRef, { lastOffset: input.byteOffset ?? 0 });
+}
+export {
+  BULLET_KINDS,
+  BULLET_SCOPES,
+  BULLET_SOURCES,
+  BULLET_STATES,
+  BULLET_TYPES,
+  BulletNotFound,
+  DEFAULT_HALF_LIFE_DAYS,
+  DEFAULT_MEMORY_TABLES,
+  HARD_DEPRECATE_SCORE,
+  HARMFUL_WEIGHT,
+  MATURITIES,
+  MATURITY_MULTIPLIER,
+  MemoryVectors,
+  PlaybookDeltaSchema,
+  PlaybookStore,
+  SUPERSEDES,
+  applyMaturity,
+  bulletRef,
+  contentKey,
+  curate,
+  decayedCounts,
+  decayedValue,
+  effectiveScore,
+  feedbackTableDdl,
+  isStale,
+  jaccard,
+  keywordScore,
+  maturityFor,
+  memoryDdl,
+  memoryMigration,
+  newBulletId,
+  nextMaturity,
+  normalizeContent,
+  parseDeltas,
+  recall,
+  reflectSession,
+  scoreBullet,
+  scorePlaybook,
+  staleBullets,
+  tokenize
+};
+//# sourceMappingURL=index.js.map