@ghostpaw/affinity 0.5.0 → 0.6.0

package/dist/mcp.js

@@ -1,9 +1,9 @@
-import { mkdirSync } from 'node:fs';
+import { mkdirSync, existsSync, closeSync, openSync } from 'node:fs';
 import { dirname, join, resolve } from 'node:path';
 import { homedir } from 'node:os';
 
 // src/version.ts
-var affinityVersion = "0.5.0";
+var affinityVersion = "0.6.0";
 
 // src/surface/affinity_mcp_instructions.ts
 var affinityMcpInstructions = "Affinity is a local relationship model and social CRM. Search before creating contacts. Inspect before revising or merging. Record direct evidence honestly, keep identities and structural ties distinct from social links, and ask for clarification when a target is ambiguous. Review commitments and recurring dates regularly. Derived scores guide attention and do not prove relationship quality.";
@@ -76,6 +76,158 @@ var AffinityNotFoundError = class extends AffinityError {
   code = "NOT_FOUND";
 };
 
+// src/lib/normalize_mutation_receipt.ts
+function uniqueEntityRefs(refs) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const ref of refs ?? []) {
+    const key = `${ref.kind}:${ref.id}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(ref);
+  }
+  return out;
+}
+function uniqueDerivedEffects(effects) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const effect of effects ?? []) {
+    const key = `${effect.eventId}:${effect.linkId}`;
+    if (seen.has(key)) {
+      continue;
+    }
+    seen.add(key);
+    out.push(effect);
+  }
+  return out;
+}
+function uniqueAffectedLinks(affectedLinks, derivedEffects) {
+  const out = [];
+  const seen = /* @__PURE__ */ new Set();
+  for (const linkId of affectedLinks ?? []) {
+    if (seen.has(linkId)) {
+      continue;
+    }
+    seen.add(linkId);
+    out.push(linkId);
+  }
+  for (const effect of derivedEffects) {
+    if (seen.has(effect.linkId)) {
+      continue;
+    }
+    seen.add(effect.linkId);
+    out.push(effect.linkId);
+  }
+  return out;
+}
+function normalizeMutationReceiptPartial(partial) {
+  const derivedEffects = uniqueDerivedEffects(partial?.derivedEffects);
+  return {
+    created: uniqueEntityRefs(partial?.created),
+    updated: uniqueEntityRefs(partial?.updated),
+    archived: uniqueEntityRefs(partial?.archived),
+    removed: uniqueEntityRefs(partial?.removed),
+    affectedLinks: uniqueAffectedLinks(partial?.affectedLinks, derivedEffects),
+    derivedEffects
+  };
+}
+
+// src/events/receipts.ts
+function buildEventMutationReceipt(primary, partial) {
+  const normalized = normalizeMutationReceiptPartial(partial);
+  return {
+    primary,
+    ...partial?.warnings ? { warnings: partial.warnings } : {},
+    created: normalized.created,
+    updated: normalized.updated,
+    archived: normalized.archived,
+    removed: normalized.removed,
+    affectedLinks: normalized.affectedLinks,
+    derivedEffects: normalized.derivedEffects
+  };
+}
+
+// src/events/event_metadata.ts
+function normalizeExternalRef(ref) {
+  if (!ref || typeof ref.source !== "string" || typeof ref.id !== "string" || !ref.source.trim() || !ref.id.trim())
+    throw new AffinityValidationError(
+      "external reference source and id must be non-empty strings"
+    );
+  return { source: ref.source.trim().toLowerCase(), id: ref.id.trim() };
+}
+function deriveEventSummary(content) {
+  const line = content.split(/\r?\n/).find((line2) => line2.trim())?.replace(/\s+/g, " ").trim() ?? "(no text)";
+  return line.length > 140 ? `${line.slice(0, 139)}\u2026` : line;
+}
+function validateEventMetadata(input) {
+  if (input.affectsBond !== void 0 && typeof input.affectsBond !== "boolean")
+    throw new AffinityValidationError("affectsBond must be boolean");
+  if (input.content !== void 0 && (typeof input.content !== "string" || Buffer.byteLength(input.content, "utf8") > 1048576))
+    throw new AffinityValidationError(
+      "content must be a string of at most 1 MB (1048576 UTF-8 bytes)"
+    );
+  for (const key of ["externalRef", "parentRef", "threadRef"])
+    if (input[key] !== void 0) input[key] = normalizeExternalRef(input[key]);
+  if (input.channel !== void 0) {
+    if (typeof input.channel !== "string" || !input.channel.trim() || input.channel.trim().length > 40)
+      throw new AffinityValidationError(
+        "channel must be non-empty and at most 40 characters"
+      );
+    input.channel = input.channel.trim().toLowerCase();
+  }
+  if (input.parentEventId !== void 0 && (!Number.isSafeInteger(input.parentEventId) || input.parentEventId <= 0))
+    throw new AffinityValidationError(
+      "parentEventId must be a positive integer"
+    );
+  const moments = [
+    "breakthrough",
+    "rupture",
+    "reconciliation",
+    "milestone",
+    "turning_point"
+  ];
+  if (input.momentKind !== void 0 && !moments.includes(input.momentKind))
+    throw new AffinityValidationError(
+      `momentKind must be one of: ${moments.join(", ")}`
+    );
+}
+function getEventById(db, eventId) {
+  return db.prepare("SELECT 1 FROM events WHERE id=? AND deleted_at IS NULL").get(eventId) ? loadEventRecord(db, eventId) : null;
+}
+function getEventByExternalRef(db, source, id) {
+  const ref = normalizeExternalRef({ source, id });
+  const row = db.prepare(
+    "SELECT id FROM events WHERE external_source=? AND external_id=? AND deleted_at IS NULL"
+  ).get(ref.source, ref.id);
+  return row ? loadEventRecord(db, row.id) : null;
+}
+function existingEventReceipt(db, ref) {
+  const event = ref && getEventByExternalRef(db, ref.source, ref.id);
+  return event ? { ...buildEventMutationReceipt(event, {}), outcome: "no_op" } : null;
+}
+function enrichEventMetadata(db, record) {
+  const bond = db.prepare("SELECT affects_bond FROM events WHERE id=?").get(record.id);
+  record.affectsBond = bond?.affects_bond == null ? !(record.type === "observation" && record.significance <= 2) : Boolean(bond.affects_bond);
+  if (record.parentEventId === void 0 && record.parentRef) {
+    const row = db.prepare(
+      "SELECT id FROM events WHERE external_source=? AND external_id=? AND deleted_at IS NULL"
+    ).get(record.parentRef.source, record.parentRef.id);
+    if (row) record.parentEventId = row.id;
+  }
+  const attrs = db.prepare(
+    "SELECT id, name, value FROM attributes WHERE event_id=? AND deleted_at IS NULL ORDER BY id"
+  ).all(record.id);
+  if (attrs.length)
+    record.attributes = attrs.map((a) => ({
+      ...a,
+      contactId: null,
+      linkId: null,
+      eventId: record.id
+    }));
+}
+
 // src/contacts/queries.ts
 function getContactRowById(db, id) {
   const row = db.prepare(
@@ -154,8 +306,11 @@ function assertParticipantContactsLive(db, contactIds) {
 }
 function validateSocialEventInput(input) {
   assertFiniteTimestamp(input.occurredAt, "occurredAt");
-  const summary = input.summary.trim();
-  if (summary.length === 0) {
+  validateEventMetadata(input);
+  if (input.summary !== void 0 && typeof input.summary !== "string")
+    throw new AffinityValidationError("summary must be a string");
+  const summary = input.summary?.trim();
+  if (summary === "" || summary === void 0 && input.content === void 0) {
     throw new AffinityValidationError("summary must be non-empty");
   }
   const sig = input.significance;
@@ -219,11 +374,25 @@ function mapEventRowToEventRecord(row, participants) {
     id: row.id,
     type: row.type,
     occurredAt: row.occurred_at,
-    summary: row.summary,
+    occurredOn: row.occurred_on ?? new Date(row.occurred_at).toISOString().slice(0, 10),
+    summary: decodeEventText(row.summary),
     significance: row.significance,
     momentKind: row.moment_kind,
     participants
   };
+  if (row.content != null) base.content = decodeEventText(row.content);
+  if (row.channel != null) base.channel = row.channel;
+  if (row.external_source != null && row.external_id != null)
+    base.externalRef = { source: row.external_source, id: row.external_id };
+  if (row.parent_source != null && row.parent_ref_id != null)
+    base.parentRef = { source: row.parent_source, id: row.parent_ref_id };
+  if (row.thread_source != null && row.thread_id != null)
+    base.threadRef = { source: row.thread_source, id: row.thread_id };
+  if (row.parent_event_id != null) base.parentEventId = row.parent_event_id;
+  if (row.type === "promise" || row.type === "agreement") {
+    base.dueAt = row.due_at ?? null;
+    base.dueOn = row.due_on ?? (row.due_at == null ? null : new Date(row.due_at).toISOString().slice(0, 10));
+  }
   if (row.recurrence_kind !== null) {
     base.recurrenceKind = row.recurrence_kind;
     base.anchorMonth = row.anchor_month;
@@ -253,25 +422,29 @@ function mapUpcomingRowToUpcomingDateRecord(row) {
     targetRef,
     recurrenceKind,
     occursOn: row.occurs_on,
-    summary: row.summary,
+    occursOnDate: new Date(row.occurs_on).toISOString().slice(0, 10),
+    summary: decodeEventText(row.summary),
     significance: row.significance
   };
 }
+function decodeEventText(value) {
+  return typeof value === "string" ? value : Buffer.from(value).toString("utf8");
+}
 
 // src/events/queries.ts
 function getEventRowById(db, id) {
   const row = db.prepare(
-    `SELECT id, type, occurred_at, summary, significance, moment_kind,
-              recurrence_kind, anchor_month, anchor_day,
-              anchor_contact_id, anchor_link_id,
-              created_at, updated_at, deleted_at
+    `SELECT *, CAST(content AS BLOB) AS content, CAST(summary AS BLOB) AS summary
        FROM events
        WHERE id = ? AND deleted_at IS NULL`
   ).get(id);
   if (row === void 0) {
     return null;
   }
-  return row;
+  const event = row;
+  event.summary = decodeEventText(event.summary);
+  if (event.content != null) event.content = decodeEventText(event.content);
+  return event;
 }
 function findDuplicateDateAnchor(db, params) {
   const exclude = params.excludeEventId;
@@ -339,19 +512,27 @@ function loadEventRecord(db, eventId) {
     throw new AffinityInvariantError("event not found");
   }
   const participants = loadEventParticipantViews(db, eventId);
-  return mapEventRowToEventRecord(row, participants);
+  const record = mapEventRowToEventRecord(row, participants);
+  const due = db.prepare("SELECT due_at, due_on FROM open_commitments WHERE event_id = ?").get(eventId);
+  if (due) {
+    record.dueAt = due.due_at;
+    record.dueOn = due.due_on ?? (due.due_at === null ? null : new Date(due.due_at).toISOString().slice(0, 10));
+  }
+  enrichEventMetadata(db, record);
+  return record;
 }
-function batchLoadEventRecords(db, eventIds) {
+function batchLoadEventRecords(db, eventIds, includeContent = false) {
   if (eventIds.length === 0) {
     return [];
   }
   const ph = eventIds.map(() => "?").join(", ");
   const eventRows = db.prepare(
-    `SELECT id, type, occurred_at, summary, significance, moment_kind,
+    `SELECT e.id, e.type, e.occurred_at, e.occurred_on, oc.due_at, oc.due_on, significance, moment_kind,
+              e.external_source,e.external_id,e.channel,e.parent_source,e.parent_ref_id,e.parent_event_id,e.thread_source,e.thread_id,
               recurrence_kind, anchor_month, anchor_day,
               anchor_contact_id, anchor_link_id,
-              created_at, updated_at, deleted_at
-       FROM events WHERE id IN (${ph}) AND deleted_at IS NULL`
+              e.created_at, e.updated_at, e.deleted_at, ${includeContent ? "CAST(e.content AS BLOB)" : "NULL"} AS content, CAST(e.summary AS BLOB) AS summary
+       FROM events e LEFT JOIN open_commitments oc ON oc.event_id = e.id WHERE e.id IN (${ph}) AND e.deleted_at IS NULL`
   ).all(...eventIds);
   const partRows = db.prepare(
     `SELECT event_id, contact_id, role, directionality
@@ -375,7 +556,9 @@ function batchLoadEventRecords(db, eventIds) {
   for (const id of eventIds) {
     const row = rowById.get(id);
     if (row) {
-      out.push(mapEventRowToEventRecord(row, partsByEvent.get(id) ?? []));
+      const record = mapEventRowToEventRecord(row, partsByEvent.get(id) ?? []);
+      enrichEventMetadata(db, record);
+      out.push(record);
     }
   }
   return out;
@@ -434,6 +617,10 @@ function getContactJournal(db, contactId, options) {
     clauses.push(`e.type IN (${ph})`);
     params.push(...options.eventTypes);
   }
+  if (options?.channel !== void 0) {
+    clauses.push("e.channel = ?");
+    params.push(options.channel.trim().toLowerCase());
+  }
   const where = clauses.join(" AND ");
   const rows = db.prepare(
     `SELECT e.id FROM events e
@@ -444,8 +631,75 @@ function getContactJournal(db, contactId, options) {
   ).all(...params, limit, offset);
   return batchLoadEventRecords(
     db,
-    rows.map((r) => r.id)
+    rows.map((r) => r.id),
+    options?.includeContent ?? false
+  );
+}
+
+// src/lib/parse_calendar_time.ts
+var timeInputForms = "epoch milliseconds integer, ISO 8601 date-time with Z/offset, YYYY-MM-DD, DD.MM.YYYY, today, tomorrow, yesterday, +3d or -2d";
+function isCommitmentOverdue(dueAt, dueOn, now) {
+  if (dueAt === null) return false;
+  if (dueOn && dueAt === Date.parse(`${dueOn}T23:59:59.999Z`)) {
+    return localCalendarDate(now) > dueOn;
+  }
+  return dueAt < now;
+}
+var OVERDUE_SQL = "(CASE WHEN oc.due_on IS NOT NULL AND oc.due_at = CAST(strftime('%s', oc.due_on) AS INTEGER) * 1000 + 86399999 THEN oc.due_on < ? ELSE oc.due_at < ? END)";
+function localCalendarDate(now) {
+  const d = new Date(now);
+  return `${String(d.getFullYear()).padStart(4, "0")}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function parseCalendarTime(value, field = "time", now = Date.now()) {
+  if (value == null && field.endsWith("occurredAt"))
+    throw new AffinityValidationError(
+      "occurredAt is required (ISO, YYYY-MM-DD, epoch ms, today, +3d \u2026)"
+    );
+  const fail = () => {
+    throw new AffinityValidationError(`${field}: expected ${timeInputForms}`);
+  };
+  if (typeof value === "number" || typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+    const timestamp2 = Number(value);
+    if (!Number.isSafeInteger(timestamp2) || !Number.isFinite(new Date(timestamp2).getTime()))
+      return fail();
+    return { timestamp: timestamp2, day: new Date(timestamp2).toISOString().slice(0, 10) };
+  }
+  if (typeof value !== "string") return fail();
+  let text = value.trim();
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}/.test(text)) {
+    text = text.replace(" ", "T");
+    if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(text)) text += "Z";
+  }
+  let rounding = 0;
+  text = text.replace(
+    /\.(\d{4,})(?=Z|[+-]\d{2}:\d{2}$)/,
+    (_, digits) => {
+      const ms = Math.round(Number(`0.${digits}`) * 1e3);
+      rounding = ms === 1e3 ? 1 : 0;
+      return `.${String(ms === 1e3 ? 999 : ms).padStart(3, "0")}`;
+    }
   );
+  if (/^(today|yesterday|tomorrow|[+-]\d+d)$/.test(text)) {
+    const offset = text === "today" ? 0 : text === "tomorrow" ? 1 : text === "yesterday" ? -1 : Number(text.slice(0, -1));
+    const date = /* @__PURE__ */ new Date(`${localCalendarDate(now)}T00:00:00Z`);
+    date.setUTCDate(date.getUTCDate() + offset);
+    if (!Number.isFinite(date.getTime())) return fail();
+    text = date.toISOString().slice(0, 10);
+  }
+  const european = /^(\d{2})\.(\d{2})\.(\d{4})$/.exec(text);
+  if (european) text = `${european[3]}-${european[2]}-${european[1]}`;
+  const dateOnly = /^\d{4}-\d{2}-\d{2}$/.test(text);
+  if (!dateOnly && !/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/.test(
+    text
+  ))
+    return fail();
+  const day = text.slice(0, 10);
+  const midnight = Date.parse(`${day}T00:00:00Z`);
+  if (!Number.isFinite(midnight) || new Date(midnight).toISOString().slice(0, 10) !== day)
+    return fail();
+  const timestamp = dateOnly ? midnight + (field.split(".").at(-1) === "dueAt" ? 86399999 : 0) : Date.parse(text) + rounding;
+  if (!Number.isFinite(timestamp)) return fail();
+  return { timestamp, day };
 }
 
 // src/resolve_now.ts
@@ -516,9 +770,13 @@ function listOpenCommitments(db, filters, options) {
     clauses.push("oc.due_at <= ?");
     params.push(anchor + filters.horizonDays * DAY_MS);
   }
+  if (options?.channel !== void 0) {
+    clauses.push("e.channel=?");
+    params.push(options.channel.trim().toLowerCase());
+  }
   const where = clauses.join(" AND ");
   const rows = db.prepare(
-    `SELECT oc.event_id, oc.commitment_type, oc.due_at, oc.resolved_at, oc.resolution,
+    `SELECT oc.event_id, oc.commitment_type, oc.due_at, oc.due_on, oc.resolved_at, oc.resolution,
               e.type, e.summary
        FROM open_commitments oc
        INNER JOIN events e ON e.id = oc.event_id
@@ -535,7 +793,8 @@ function listOpenCommitments(db, filters, options) {
     participants: partsByEvent.get(r.event_id) ?? [],
     dueAt: r.due_at,
     dueAtIso: r.due_at === null ? null : new Date(r.due_at).toISOString(),
-    overdue: r.due_at !== null && r.due_at < now,
+    dueOn: r.due_on ?? (r.due_at === null ? null : new Date(r.due_at).toISOString().slice(0, 10)),
+    overdue: isCommitmentOverdue(r.due_at, r.due_on, now),
     resolutionState: mapResolution(r.resolved_at, r.resolution)
   }));
 }
@@ -604,8 +863,10 @@ function utcMidnight(year, month1Based, day) {
   return Date.UTC(year, month1Based - 1, day, 0, 0, 0, 0);
 }
 function computeNextAnchorOccursOn(params) {
-  const refStart = utcStartOfDayMs(params.referenceMs);
-  const refYear = new Date(params.referenceMs).getUTCFullYear();
+  const refStart = Date.parse(
+    `${localCalendarDate(params.referenceMs)}T00:00:00Z`
+  );
+  const refYear = new Date(refStart).getUTCFullYear();
   for (let year2 = refYear; year2 <= refYear + 2; year2 += 1) {
     const day2 = effectiveAnchorDay(year2, params.anchorMonth, params.anchorDay);
     const candidate = utcMidnight(year2, params.anchorMonth, day2);
@@ -808,7 +1069,13 @@ function loadContactProfileRecord(db, contactId, topLinksLimit) {
        ORDER BY COALESCE(lr.normalized_rank, 0) DESC, l.trust DESC
        LIMIT ?`
   ).all(contactId, contactId, topLinksLimit);
-  const topLinks = linkRows.map((l) => mapLinkRowToLinkListItem(l));
+  const topLinks = linkRows.map((l) => ({
+    ...mapLinkRowToLinkListItem(l),
+    counterpartyName: getContactRowById(
+      db,
+      l.from_contact_id === contactId ? l.to_contact_id : l.from_contact_id
+    )?.name ?? ""
+  }));
   const activeDates = loadActiveDatesForContact(db, contactId);
   const contactRollup = loadContactRollup(db, contactId);
   const winner = row.merged_into_contact_id === null ? null : getContactRowById(db, row.merged_into_contact_id);
@@ -841,7 +1108,20 @@ function getContactProfile(db, contactId, options) {
   return {
     ...profile,
     recentEvents: getContactJournal(db, contactId, {
-      limit: options?.recentEventsLimit ?? 5
+      limit: options?.recentEventsLimit ?? 5,
+      eventTypes: [
+        "conversation",
+        "activity",
+        "gift",
+        "support",
+        "milestone",
+        "observation",
+        "conflict",
+        "correction",
+        "transaction",
+        "promise",
+        "agreement"
+      ]
     }).map((event) => ({
       ...event,
       occurredAtIso: new Date(event.occurredAt).toISOString()
@@ -896,6 +1176,10 @@ function listMoments(db, filters, options) {
     clauses.push("le.link_id = ?");
     params.push(filters.linkId);
   }
+  if (options?.channel !== void 0) {
+    clauses.push("e.channel=?");
+    params.push(options.channel.trim().toLowerCase());
+  }
   const where = clauses.join(" AND ");
   return db.prepare(
     `SELECT
@@ -903,6 +1187,7 @@ function listMoments(db, filters, options) {
          le.link_id,
          le.moment_kind,
          le.occurred_at,
+         e.occurred_on,
          e.summary,
          le.impact_score
        FROM link_event_effects le
@@ -915,6 +1200,7 @@ function listMoments(db, filters, options) {
     linkId: row.link_id,
     momentKind: row.moment_kind,
     occurredAt: row.occurred_at,
+    occurredOn: row.occurred_on ?? new Date(row.occurred_at).toISOString().slice(0, 10),
     summary: row.summary,
     impactScore: row.impact_score
   }));
@@ -1002,6 +1288,10 @@ function getLinkTimeline(db, linkId, options) {
     clauses.push(`e.type IN (${ph})`);
     params.push(...options.eventTypes);
   }
+  if (options?.channel !== void 0) {
+    clauses.push("e.channel = ?");
+    params.push(options.channel.trim().toLowerCase());
+  }
   const where = clauses.join(" AND ");
   const rows = db.prepare(
     `SELECT e.id
@@ -1013,7 +1303,8 @@ function getLinkTimeline(db, linkId, options) {
   ).all(...params, limit, offset);
   return batchLoadEventRecords(
     db,
-    rows.map((r) => r.id)
+    rows.map((r) => r.id),
+    options?.includeContent ?? false
   );
 }
 
@@ -1186,26 +1477,34 @@ function refreshLinkRollup(db, linkId, now) {
   const latest = db.prepare(
     `SELECT event_id, occurred_at
        FROM link_event_effects
-       WHERE link_id = ? AND counts_for_recency = 1
+       WHERE link_id = ? AND counts_for_recency = 1 AND event_id IN (SELECT id FROM events WHERE deleted_at IS NULL AND (occurred_at <= ? OR occurred_on <= ?))
        ORDER BY occurred_at DESC, event_id DESC
        LIMIT 1`
-  ).get(linkId);
+  ).get(linkId, now, localCalendarDate(now));
   const trailingWindowStart = now - 180 * DAY_MS2;
   const counts = db.prepare(
     `SELECT
          COUNT(*) AS total_meaningful_events,
          SUM(CASE WHEN counts_for_recency = 1 AND (affinity_delta > 0 OR trust_delta > 0) THEN 1 ELSE 0 END) AS positive_meaningful_events
        FROM link_event_effects
-       WHERE link_id = ? AND occurred_at >= ?`
-  ).get(linkId, trailingWindowStart);
+       WHERE link_id = ? AND occurred_at >= ? AND counts_for_recency = 1
+         AND event_id IN (SELECT id FROM events WHERE deleted_at IS NULL AND (occurred_at <= ? OR occurred_on <= ?))`
+  ).get(linkId, trailingWindowStart, now, localCalendarDate(now));
   const directionalityRows = db.prepare(
     `SELECT ep.directionality
        FROM link_event_effects le
        INNER JOIN event_participants ep ON ep.event_id = le.event_id
        WHERE le.link_id = ? AND le.counts_for_recency = 1 AND ep.contact_id = ?
          AND ep.directionality IS NOT NULL
-         AND le.occurred_at >= ?`
-  ).all(linkId, link.from_contact_id, trailingWindowStart);
+         AND le.occurred_at >= ?
+         AND le.event_id IN (SELECT id FROM events WHERE deleted_at IS NULL AND (occurred_at <= ? OR occurred_on <= ?))`
+  ).all(
+    linkId,
+    link.from_contact_id,
+    trailingWindowStart,
+    now,
+    localCalendarDate(now)
+  );
   let outboundCount = 0;
   let inboundCount = 0;
   for (const row of directionalityRows) {
@@ -1356,37 +1655,8 @@ function getLinkDetail(db, linkId, options) {
 }
 
 // src/tools/parse_time_input.ts
-var timeInputForms = "epoch milliseconds integer, ISO 8601 date-time with Z/offset, YYYY-MM-DD, today, tomorrow, yesterday, +3d or -2d";
 function parseTimeInput(value, field = "time", now = Date.now()) {
-  const fail = () => {
-    throw new AffinityValidationError(`${field}: expected ${timeInputForms}`);
-  };
-  if (typeof value === "number")
-    return Number.isSafeInteger(value) && Number.isFinite(new Date(value).getTime()) ? value : fail();
-  if (typeof value !== "string") return fail();
-  const text = value.trim();
-  const relative = /^(?:today|tomorrow|yesterday|[+-]\d+d)$/.test(text);
-  let day;
-  if (relative) {
-    const offset = text === "today" ? 0 : text === "tomorrow" ? 1 : text === "yesterday" ? -1 : Number(text.slice(0, -1));
-    day = Math.floor(now / 864e5) * 864e5 + offset * 864e5;
-  } else if (/^\d{4}-\d{2}-\d{2}$/.test(text)) {
-    day = Date.parse(`${text}T00:00:00.000Z`);
-    if (!Number.isFinite(day) || new Date(day).toISOString().slice(0, 10) !== text)
-      return fail();
-  } else {
-    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/.test(
-      text
-    ))
-      return fail();
-    const calendar = Date.parse(`${text.slice(0, 10)}T00:00:00Z`);
-    if (!Number.isFinite(calendar) || new Date(calendar).toISOString().slice(0, 10) !== text.slice(0, 10))
-      return fail();
-    const parsed = Date.parse(text);
-    return Number.isFinite(parsed) ? parsed : fail();
-  }
-  const result = day + (field.split(".").at(-1) === "dueAt" ? 86399999 : 0);
-  return Number.isSafeInteger(result) && Number.isFinite(new Date(result).getTime()) ? result : fail();
+  return parseCalendarTime(value, field, now).timestamp;
 }
 
 // src/tools/tool_metadata.ts
@@ -1457,6 +1727,39 @@ function oneOfSchema(schemas, description) {
   return schema;
 }
 
+// src/tools/event_metadata_schema.ts
+var externalRefSchema = objectSchema(
+  {
+    source: stringSchema("External source; trimmed and lowercased."),
+    id: stringSchema("Non-empty external id.")
+  },
+  ["source", "id"]
+);
+var eventMetadataSchema = {
+  affectsBond: booleanSchema(
+    "Whether evidence affects the relationship; defaults false for observations with significance <=2."
+  ),
+  content: stringSchema(
+    "Verbatim text, including empty text; at most 1 MB UTF-8. Summary may be omitted when content is supplied."
+  ),
+  externalRef: externalRefSchema,
+  channel: stringSchema(
+    "Free-text channel, trimmed and lowercased, at most 40 characters."
+  ),
+  parentRef: externalRefSchema,
+  parentEventId: integerSchema("Parent event id."),
+  threadRef: externalRefSchema,
+  momentKind: enumSchema("Optional moment kind.", [
+    "breakthrough",
+    "rupture",
+    "reconciliation",
+    "milestone",
+    "turning_point"
+  ]),
+  occurredOn: stringSchema("Calendar day."),
+  provenance: {}
+};
+
 // src/tools/tool_names.ts
 var searchAffinityToolName = "search_affinity";
 var reviewAffinityToolName = "review_affinity";
@@ -1470,6 +1773,7 @@ var recordEventToolName = "record_event";
 var manageCommitmentToolName = "manage_commitment";
 var manageDateAnchorToolName = "manage_date_anchor";
 var manageAttributeToolName = "manage_attribute";
+var manageEventToolName = "manage_event";
 
 // src/tools/tool_ref.ts
 function contactState(value) {
@@ -1514,7 +1818,7 @@ function toEventEntityRef(value) {
   return {
     kind: "event",
     id: value.id,
-    title: value.summary,
+    title: deriveEventSummary(value.summary),
     subtitle: value.type,
     state: value.type
   };
@@ -1549,14 +1853,39 @@ function toReceiptEntityRefs(receipt) {
 }
 
 // src/identities/normalize.ts
+var handleIdentityTypes = /* @__PURE__ */ new Set([
+  "handle",
+  "bluesky",
+  "x",
+  "twitter",
+  "mastodon",
+  "github",
+  "instagram",
+  "telegram",
+  "linkedin",
+  "facebook",
+  "youtube",
+  "tiktok",
+  "discord",
+  "slack"
+]);
+function normalizeIdentityValue(type, value) {
+  const v = value.trim();
+  return handleIdentityTypes.has(type.toLowerCase()) ? v.replace(/^@/, "").toLowerCase() : v;
+}
 function normalizeIdentityKey(type, value) {
-  const t = type.trim().toLowerCase();
-  const v = value.trim().toLowerCase();
+  let t = type.trim().toLowerCase();
+  if (["did", "atproto_did", "custom:atproto-did"].includes(t)) t = "did";
+  const v = normalizeIdentityValue(t, value).toLowerCase();
   if (t.length === 0 || v.length === 0) {
     throw new AffinityValidationError("type and value must be non-empty");
   }
   return `${t}:${v}`;
 }
+function legacyIdentityKey(key) {
+  const colon = key.indexOf(":");
+  return handleIdentityTypes.has(key.slice(0, colon)) ? `${key.slice(0, colon + 1)}@${key.slice(colon + 1)}` : key;
+}
 
 // src/lib/errors/is_affinity_error.ts
 function isAffinityError(value) {
@@ -1678,7 +2007,7 @@ function resolveContactLocator(db, locator, field = "contact", allowMerged = fal
       const message = `Contact #${row2.id} was merged into #${row2.merged_into_contact_id} ${winner?.name ?? ""}; use contactId ${row2.merged_into_contact_id}`;
       return {
         ok: false,
-        result: toolFailure("domain", "invalid_state", message, message)
+        result: toolFailure("domain", "conflict", message, message)
       };
     }
     return { ok: true, value: row2 };
@@ -1703,9 +2032,13 @@ function resolveContactLocator(db, locator, field = "contact", allowMerged = fal
        INNER JOIN contacts c ON c.id = i.contact_id
        WHERE i.removed_at IS NULL
          AND c.deleted_at IS NULL
-         AND i.normalized_key = ?
+         AND (i.normalized_key IN (?, ?) OR (i.type = 'custom:atproto-did' AND ? = 'did:' || lower(i.value)))
        LIMIT 2`
-  ).all(normalizedKey);
+  ).all(
+    normalizedKey,
+    legacyIdentityKey(normalizedKey),
+    normalizedKey
+  );
   if (row.length === 0) {
     return {
       ok: false,
@@ -1856,13 +2189,21 @@ function resolveLinkLocator(db, locator, field = "link") {
   return { ok: true, value: matchedLink };
 }
 function mapErrorToToolFailure(error, summary = "The tool failed.") {
+  if (error && typeof error === "object" && "ok" in error && error.ok === false && "outcome" in error && error.outcome === "error")
+    return error;
   if (isAffinityError(error)) {
-    return toolFailure(
+    const result = toolFailure(
       "domain",
       affinityErrorCodeToToolCode(error),
       summary,
       error.message
     );
+    const id = error.existingContactId;
+    if (id !== void 0) {
+      result.data = { existingContactId: id };
+      result.error.details = { existingContactId: id };
+    }
+    return result;
   }
   if (error instanceof Error) {
     return toolFailure("system", "system_error", summary, error.message);
@@ -1901,27 +2242,32 @@ function affinityErrorCodeToToolCode(error) {
 }
 
 // src/tools/validate_tool_input.ts
-function validateToolInput(schema, value, path = "input", injectedNow = Date.now()) {
+function validateToolInput(schema, value, path = "input", injectedNow = Date.now(), strict = false) {
+  if (path.endsWith(".occurredAt") && value == null)
+    return "occurredAt is required (ISO, YYYY-MM-DD, epoch ms, today, +3d \u2026)";
+  const branches = schema.oneOf ?? schema.anyOf;
+  if (path.endsWith(".value") && branches?.some((b) => b.type === "string") && branches.some((b) => b.type === "null") && value !== null && typeof value !== "string")
+    return `attribute values are strings or null; pass "${String(value)}" to store it as text`;
   if (schema.anyOf || schema.oneOf) {
     const choices = schema.anyOf ?? schema.oneOf ?? [];
     return choices.some(
-      (choice) => validateToolInput(choice, value, path, injectedNow) === null
+      (choice) => validateToolInput(choice, value, path, injectedNow, strict) === null
     ) ? null : `${path}: invalid value`;
   }
   if (schema.type === "object") {
     if (value === null || typeof value !== "object" || Array.isArray(value))
       return `${path}: missing input or expected object`;
     const object = value;
-    if (path.endsWith(".patch") && schema.additionalProperties === false) {
+    if ((strict || path.endsWith(".patch")) && schema.additionalProperties === false) {
       for (const key of Object.keys(object)) {
         if (!Object.hasOwn(schema.properties ?? {}, key))
-          return key === "kind" && "name" in (schema.properties ?? {}) ? "kind cannot be changed after creation" : `${path}.${key}: unknown patch key; allowed keys: ${Object.keys(schema.properties ?? {}).join(", ")}`;
+          return key === "kind" && "name" in (schema.properties ?? {}) ? "kind cannot be changed after creation" : `${path}.${key}: unknown ${path.endsWith(".patch") ? "patch key" : "key"}; allowed keys: ${Object.keys(schema.properties ?? {}).join(", ")}`;
       }
     }
     if (object.action === "revise" && schema.properties?.patch && object.patch === void 0)
       return `${path}.patch: missing required field`;
     if (object.patch !== void 0 && !schema.properties?.patch)
-      return `${path}.patch: unknown patch key; allowed keys: none (use the action's named fields)`;
+      return `${path}.patch: unknown key; allowed keys: none (use the action's named fields)`;
     const referenceNow = object.now === void 0 ? injectedNow : (() => {
       try {
         return parseTimeInput(
@@ -1936,11 +2282,14 @@ function validateToolInput(schema, value, path = "input", injectedNow = Date.now
     for (const [key, child] of Object.entries(schema.properties ?? {})) {
       if (object[key] !== void 0 && (key.endsWith("At") || ["now", "asOf", "since", "until"].includes(key)) && child.oneOf?.some((choice) => choice.type === "integer")) {
         try {
-          object[key] = parseTimeInput(
+          const parsed = parseCalendarTime(
             object[key],
             `${path}.${key}`,
             referenceNow
           );
+          object[key] = parsed.timestamp;
+          if (!path.endsWith(".patch") && ["occurredAt", "dueAt"].includes(key))
+            object[key.replace(/At$/, "On")] ??= parsed.day;
         } catch (error) {
           return error.message;
         }
@@ -1956,7 +2305,8 @@ function validateToolInput(schema, value, path = "input", injectedNow = Date.now
         child,
         object[key],
         `${path}.${key}`,
-        referenceNow
+        referenceNow,
+        strict
       );
       if (error) return error;
     }
@@ -1969,7 +2319,8 @@ function validateToolInput(schema, value, path = "input", injectedNow = Date.now
         schema.items ?? {},
         item,
         `${path}[${index}]`,
-        injectedNow
+        injectedNow,
+        strict
       );
       if (error) return error;
     }
@@ -2035,6 +2386,26 @@ function inspectAffinityItemToolHandler(db, rawInput) {
       inputError
     );
   return withToolHandling(() => {
+    if (input.kind === "event") {
+      if (input.eventId === void 0 === (input.ref === void 0))
+        return toolFailure(
+          "protocol",
+          "invalid_input",
+          "Invalid event target.",
+          "Provide exactly one of eventId or ref."
+        );
+      const detail2 = input.ref ? getEventByExternalRef(db, input.ref.source, input.ref.id) : getEventById(db, input.eventId);
+      return detail2 ? toolSuccess(
+        `Loaded event #${detail2.id}.`,
+        { kind: "event", detail: detail2 },
+        { entities: [{ kind: "event", id: detail2.id }] }
+      ) : toolFailure(
+        "domain",
+        "not_found",
+        "Event not found.",
+        "No event matches the target."
+      );
+    }
     if (input.kind === "owner_profile") {
       const detail2 = getOwnerProfile(
         db,
@@ -2132,10 +2503,13 @@ var inspectAffinityItemTool = defineAffinityTool({
   inputSchema: objectSchema(
     {
       kind: enumSchema("What to inspect.", [
+        "event",
         "owner_profile",
         "contact_profile",
         "link"
       ]),
+      eventId: integerSchema("Exact event id."),
+      ref: externalRefSchema,
       contact: contactLocatorSchema(
         "Target contact. Required when kind=contact_profile. Provide contactId or identity."
       ),
@@ -2154,6 +2528,7 @@ var inspectAffinityItemTool = defineAffinityTool({
 // src/attributes/helpers.ts
 function clearedAttributePrimary(target) {
   return {
+    ...target.kind === "event" ? { eventId: target.eventId } : {},
     id: 0,
     contactId: target.kind === "contact" ? target.id : null,
     linkId: target.kind === "link" ? target.id : null,
@@ -2165,6 +2540,7 @@ function clearedAttributePrimary(target) {
 // src/attributes/mappers.ts
 function mapAttributeRowToAttributeRecord(row) {
   return {
+    ...row.event_id == null ? {} : { eventId: row.event_id },
     id: row.id,
     contactId: row.contact_id,
     linkId: row.link_id,
@@ -2174,136 +2550,55 @@ function mapAttributeRowToAttributeRecord(row) {
 }
 
 // src/attributes/queries.ts
+function attributeTargetSql(target) {
+  return {
+    column: target.kind === "event" ? "event_id" : target.kind === "contact" ? "contact_id" : "link_id",
+    id: target.kind === "event" ? target.eventId : target.id
+  };
+}
 function getAttributeRowById(db, id) {
-  const row = db.prepare(
-    `SELECT id, contact_id, link_id, name, value, created_at, updated_at, deleted_at
-       FROM attributes WHERE id = ?`
-  ).get(id);
-  if (row === void 0) {
-    return null;
-  }
-  return row;
+  return db.prepare("SELECT * FROM attributes WHERE id=?").get(id) ?? null;
 }
 function getLiveAttributeRow(db, target, name) {
-  if (target.kind === "contact") {
-    const row2 = db.prepare(
-      `SELECT id, contact_id, link_id, name, value, created_at, updated_at, deleted_at
-         FROM attributes
-         WHERE contact_id = ? AND name = ? AND deleted_at IS NULL`
-    ).get(target.id, name);
-    if (row2 === void 0) {
-      return null;
-    }
-    return row2;
-  }
-  const row = db.prepare(
-    `SELECT id, contact_id, link_id, name, value, created_at, updated_at, deleted_at
-       FROM attributes
-       WHERE link_id = ? AND name = ? AND deleted_at IS NULL`
-  ).get(target.id, name);
-  if (row === void 0) {
-    return null;
-  }
-  return row;
+  const t = attributeTargetSql(target);
+  return db.prepare(
+    `SELECT * FROM attributes WHERE ${t.column}=? AND name=? AND deleted_at IS NULL`
+  ).get(t.id, name) ?? null;
 }
 function listLiveAttributeIdsForTarget(db, target) {
-  if (target.kind === "contact") {
-    const rows2 = db.prepare(
-      "SELECT id FROM attributes WHERE contact_id = ? AND deleted_at IS NULL ORDER BY id"
-    ).all(target.id);
-    return rows2.map((row) => row.id);
-  }
-  const rows = db.prepare(
-    "SELECT id FROM attributes WHERE link_id = ? AND deleted_at IS NULL ORDER BY id"
-  ).all(target.id);
-  return rows.map((row) => row.id);
+  const t = attributeTargetSql(target);
+  return db.prepare(
+    `SELECT id FROM attributes WHERE ${t.column}=? AND deleted_at IS NULL ORDER BY id`
+  ).all(t.id).map((r) => r.id);
 }
 
-// src/lib/normalize_mutation_receipt.ts
-function uniqueEntityRefs(refs) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const ref of refs ?? []) {
-    const key = `${ref.kind}:${ref.id}`;
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    out.push(ref);
-  }
-  return out;
+// src/attributes/receipts.ts
+function buildAttributeMutationReceipt(primary, partial) {
+  const normalized = normalizeMutationReceiptPartial(partial);
+  return {
+    primary,
+    created: normalized.created,
+    updated: normalized.updated,
+    archived: normalized.archived,
+    removed: normalized.removed,
+    affectedLinks: normalized.affectedLinks,
+    derivedEffects: normalized.derivedEffects
+  };
 }
-function uniqueDerivedEffects(effects) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const effect of effects ?? []) {
-    const key = `${effect.eventId}:${effect.linkId}`;
-    if (seen.has(key)) {
-      continue;
-    }
-    seen.add(key);
-    out.push(effect);
-  }
-  return out;
-}
-function uniqueAffectedLinks(affectedLinks, derivedEffects) {
-  const out = [];
-  const seen = /* @__PURE__ */ new Set();
-  for (const linkId of affectedLinks ?? []) {
-    if (seen.has(linkId)) {
-      continue;
-    }
-    seen.add(linkId);
-    out.push(linkId);
-  }
-  for (const effect of derivedEffects) {
-    if (seen.has(effect.linkId)) {
-      continue;
-    }
-    seen.add(effect.linkId);
-    out.push(effect.linkId);
-  }
-  return out;
-}
-function normalizeMutationReceiptPartial(partial) {
-  const derivedEffects = uniqueDerivedEffects(partial?.derivedEffects);
-  return {
-    created: uniqueEntityRefs(partial?.created),
-    updated: uniqueEntityRefs(partial?.updated),
-    archived: uniqueEntityRefs(partial?.archived),
-    removed: uniqueEntityRefs(partial?.removed),
-    affectedLinks: uniqueAffectedLinks(partial?.affectedLinks, derivedEffects),
-    derivedEffects
-  };
-}
-
-// src/attributes/receipts.ts
-function buildAttributeMutationReceipt(primary, partial) {
-  const normalized = normalizeMutationReceiptPartial(partial);
-  return {
-    primary,
-    created: normalized.created,
-    updated: normalized.updated,
-    archived: normalized.archived,
-    removed: normalized.removed,
-    affectedLinks: normalized.affectedLinks,
-    derivedEffects: normalized.derivedEffects
-  };
-}
-
-// src/links/validators.ts
-var STATES = /* @__PURE__ */ new Set([
-  "active",
-  "dormant",
-  "strained",
-  "broken",
-  "archived"
-]);
-function assertContactEndpointsNotMerged(db, fromContactId, toContactId) {
-  const from = getContactRowById(db, fromContactId);
-  const to = getContactRowById(db, toContactId);
-  if (!from || !to) {
-    throw new AffinityNotFoundError("contact not found");
+
+// src/links/validators.ts
+var STATES = /* @__PURE__ */ new Set([
+  "active",
+  "dormant",
+  "strained",
+  "broken",
+  "archived"
+]);
+function assertContactEndpointsNotMerged(db, fromContactId, toContactId) {
+  const from = getContactRowById(db, fromContactId);
+  const to = getContactRowById(db, toContactId);
+  if (!from || !to) {
+    throw new AffinityNotFoundError("contact not found");
   }
   if (from.lifecycle_state === "merged" || to.lifecycle_state === "merged") {
     throw new AffinityStateError("merged contact is read-only");
@@ -2339,6 +2634,8 @@ function normalizeAttributeValue(value) {
   if (value === null) {
     return null;
   }
+  if (typeof value !== "string")
+    throw new AffinityValidationError("attribute values are strings or null");
   const trimmed = value.trim();
   return trimmed.length === 0 ? null : trimmed;
 }
@@ -2367,6 +2664,11 @@ function validateAttributeEntries(entries) {
   return out;
 }
 function assertAttributeTargetWritable(db, target) {
+  if (target.kind === "event") {
+    if (!db.prepare("SELECT id FROM events WHERE id=? AND deleted_at IS NULL").get(target.eventId))
+      throw new AffinityNotFoundError("event not found");
+    return;
+  }
   if (target.kind === "contact") {
     const contact = getContactRowById(db, target.id);
     if (!contact) {
@@ -2402,26 +2704,14 @@ function replaceAttributes(db, target, entries) {
     }
     const created = [];
     let lastId = 0;
-    if (target.kind === "contact") {
-      const insert = db.prepare(
-        `INSERT INTO attributes (contact_id, link_id, name, value, created_at, updated_at)
-         VALUES (?, NULL, ?, ?, ?, ?)`
-      );
-      for (const e of normalized) {
-        const r = insert.run(target.id, e.name, e.value, now, now);
-        lastId = Number(r.lastInsertRowid);
-        created.push({ kind: "attribute", id: lastId });
-      }
-    } else {
-      const insert = db.prepare(
-        `INSERT INTO attributes (contact_id, link_id, name, value, created_at, updated_at)
-         VALUES (NULL, ?, ?, ?, ?, ?)`
-      );
-      for (const e of normalized) {
-        const r = insert.run(target.id, e.name, e.value, now, now);
-        lastId = Number(r.lastInsertRowid);
-        created.push({ kind: "attribute", id: lastId });
-      }
+    const t = attributeTargetSql(target);
+    const insert = db.prepare(
+      `INSERT INTO attributes (${t.column},name,value,created_at,updated_at) VALUES (?,?,?,?,?)`
+    );
+    for (const e of normalized) {
+      const r = insert.run(t.id, e.name, e.value, now, now);
+      lastId = Number(r.lastInsertRowid);
+      created.push({ kind: "attribute", id: lastId });
     }
     if (normalized.length === 0) {
       return buildAttributeMutationReceipt(clearedAttributePrimary(target), {
@@ -2466,27 +2756,10 @@ function setAttribute(db, target, name, value) {
         }
       );
     }
-    if (target.kind === "contact") {
-      const r2 = db.prepare(
-        `INSERT INTO attributes (contact_id, link_id, name, value, created_at, updated_at)
-           VALUES (?, NULL, ?, ?, ?, ?)`
-      ).run(target.id, key, stored, now, now);
-      const id2 = Number(r2.lastInsertRowid);
-      const row2 = getAttributeRowById(db, id2);
-      if (!row2) {
-        throw new AffinityInvariantError("attribute row missing after insert");
-      }
-      return buildAttributeMutationReceipt(
-        mapAttributeRowToAttributeRecord(row2),
-        {
-          created: [{ kind: "attribute", id: id2 }]
-        }
-      );
-    }
+    const t = attributeTargetSql(target);
     const r = db.prepare(
-      `INSERT INTO attributes (contact_id, link_id, name, value, created_at, updated_at)
-         VALUES (NULL, ?, ?, ?, ?, ?)`
-    ).run(target.id, key, stored, now, now);
+      `INSERT INTO attributes (${t.column},name,value,created_at,updated_at) VALUES (?,?,?,?,?)`
+    ).run(t.id, key, stored, now, now);
     const id = Number(r.lastInsertRowid);
     const row = getAttributeRowById(db, id);
     if (!row) {
@@ -2542,14 +2815,15 @@ function mutationToolResult(action, receipt, entitySummary, fields) {
     affectedLinks: receipt.affectedLinks,
     derivedEffects: receipt.derivedEffects
   };
-  const summary = changedCount === 0 ? `No ${entitySummary} changes were needed.` : describeChanges(receipt);
+  const summary = changedCount === 0 ? receipt.primary && typeof receipt.primary === "object" && "externalRef" in receipt.primary && "id" in receipt.primary ? `Event already recorded (#${receipt.primary.id}, ${receipt.primary.externalRef.source} ${receipt.primary.externalRef.id}).` : `No ${entitySummary} changes were needed.` : describeChanges(receipt);
   if (changedCount === 0) {
     return toolNoOp(summary, data, {
       entities: toReceiptEntityRefs(receipt)
     });
   }
   return toolSuccess(summary, data, {
-    entities: toReceiptEntityRefs(receipt)
+    entities: toReceiptEntityRefs(receipt),
+    warnings: receipt.warnings
   });
 }
 var PLURALS = { identity: "identities" };
@@ -2606,6 +2880,7 @@ function linkLocatorSchema2(description) {
   };
 }
 function resolveAttributeTarget(db, target) {
+  if (target.kind === "event") return { kind: "ok", target };
   if (target.kind === "contact") {
     const contact = resolveContactLocator(db, target.contact, "target.contact");
     if (!contact.ok) {
@@ -2665,7 +2940,7 @@ function manageAttributeToolHandler(db, rawInput) {
 }
 var manageAttributeTool = defineAffinityTool({
   name: manageAttributeToolName,
-  description: "Set, unset, or replace custom metadata attributes on contacts and links. For emails, phones, handles, and URLs use manage_identity instead \u2014 those are routing keys, not attributes.",
+  description: "Set, unset, or replace custom metadata attributes on contacts, links and events. For emails, phones, handles, and URLs use manage_identity instead \u2014 those are routing keys, not attributes.",
   whenToUse: "Use this for metadata such as tags, notes, or small labeled facts attached to a contact or link.",
   whenNotToUse: "Do not use this for core contact fields, identities, or direct relationship mechanics.",
   sideEffects: "writes_state",
@@ -2686,7 +2961,8 @@ var manageAttributeTool = defineAffinityTool({
       action: enumSchema("Operation to perform.", ["set", "unset", "replace"]),
       target: objectSchema(
         {
-          kind: enumSchema("Target kind.", ["contact", "link"]),
+          kind: enumSchema("Target kind.", ["contact", "link", "event"]),
+          eventId: integerSchema("Target event id."),
           contact: contactLocatorSchema2(
             "Contact locator. Required when kind=contact. Provide contactId or identity."
           ),
@@ -2716,7 +2992,7 @@ var manageAttributeTool = defineAffinityTool({
       removedAt: integerSchema("Removal timestamp. Optional for action=unset.")
     },
     ["action"],
-    "Set, unset, or replace attributes on contacts and links."
+    "Set, unset, or replace attributes on contacts, links and events."
   ),
   handler: manageAttributeToolHandler
 });
@@ -2724,7 +3000,7 @@ var manageAttributeTool = defineAffinityTool({
 // src/events/persistence.ts
 function insertJournalEvent(db, params) {
   const now = resolveNow(params.now);
-  const summary = params.summary.trim();
+  const summary = params.summary?.trim() ?? deriveEventSummary(params.content ?? "");
   const result = db.prepare(
     `INSERT INTO events (
          type, occurred_at, summary, significance, moment_kind,
@@ -2741,6 +3017,33 @@ function insertJournalEvent(db, params) {
     now
   );
   const eventId = Number(result.lastInsertRowid);
+  db.prepare("UPDATE events SET affects_bond=? WHERE id=?").run(
+    params.affectsBond === void 0 ? params.type === "observation" && params.significance <= 2 ? 0 : 1 : Number(params.affectsBond),
+    eventId
+  );
+  db.prepare("UPDATE events SET declared_moment_kind=? WHERE id=?").run(
+    params.momentKind,
+    eventId
+  );
+  db.prepare(
+    "UPDATE events SET content=?, external_source=?, external_id=?, channel=?, parent_source=?, parent_ref_id=?, parent_event_id=?, thread_source=?, thread_id=?, provenance_json=? WHERE id=?"
+  ).run(
+    params.content ?? null,
+    params.externalRef?.source ?? null,
+    params.externalRef?.id ?? null,
+    params.channel ?? null,
+    params.parentRef?.source ?? null,
+    params.parentRef?.id ?? null,
+    params.parentEventId ?? null,
+    params.threadRef?.source ?? null,
+    params.threadRef?.id ?? null,
+    params.provenance === void 0 ? null : JSON.stringify(params.provenance),
+    eventId
+  );
+  db.prepare("UPDATE events SET occurred_on = ? WHERE id = ?").run(
+    params.occurredOn ?? new Date(params.occurredAt).toISOString().slice(0, 10),
+    eventId
+  );
   const insertParticipant = db.prepare(
     `INSERT INTO event_participants (
        event_id, contact_id, role, directionality
@@ -2783,6 +3086,10 @@ function insertDateAnchorEvent(db, params) {
     now
   );
   const eventId = Number(result.lastInsertRowid);
+  db.prepare("UPDATE events SET occurred_on = ? WHERE id = ?").run(
+    params.occurredOn ?? new Date(params.occurredAt).toISOString().slice(0, 10),
+    eventId
+  );
   const insertParticipant = db.prepare(
     `INSERT INTO event_participants (
        event_id, contact_id, role, directionality
@@ -2803,20 +3110,6 @@ function insertDateAnchorEvent(db, params) {
   return eventId;
 }
 
-// src/events/receipts.ts
-function buildEventMutationReceipt(primary, partial) {
-  const normalized = normalizeMutationReceiptPartial(partial);
-  return {
-    primary,
-    created: normalized.created,
-    updated: normalized.updated,
-    archived: normalized.archived,
-    removed: normalized.removed,
-    affectedLinks: normalized.affectedLinks,
-    derivedEffects: normalized.derivedEffects
-  };
-}
-
 // src/graph/betweenness.ts
 function computeNodeBetweenness(adjacency) {
   const nodes = [...adjacency.keys()];
@@ -3415,6 +3708,8 @@ function deriveStateAfter(params) {
   return params.stateBefore;
 }
 function deriveMomentKind(params) {
+  if (params.eventType === "observation" || params.eventType === "milestone" && params.significance < 7)
+    return null;
   if (params.rankAfter > params.rankBefore) {
     return "breakthrough";
   }
@@ -3444,6 +3739,18 @@ function applyEventEffectToLink(db, params) {
   if (!link || link.is_structural !== 0) {
     throw new AffinityStateError("relational link not found");
   }
+  db.prepare(
+    "INSERT OR IGNORE INTO event_link_baselines(link_id,state_json) VALUES (?,?)"
+  ).run(
+    params.linkId,
+    JSON.stringify({
+      rank: link.rank ?? 0,
+      affinity: link.affinity ?? 0,
+      trust: link.trust ?? 0,
+      state: link.state ?? "active",
+      cadence_days: link.cadence_days
+    })
+  );
   const stateBefore = link.state ?? "active";
   const linkKind = link.kind;
   const rankBefore = link.rank ?? 0;
@@ -3488,7 +3795,7 @@ function applyEventEffectToLink(db, params) {
   );
   const weightedBase = base * massPenalty(
     weeklyPositiveBaseWeight(db, params.linkId, params.occurredAt)
-  ) * salienceMultiplier;
+  ) * salienceMultiplier * (params.participant.directionality === "owner_initiated" ? 0.05 : 1);
   const affinityGain = weightedBase * Math.max(eventValence, 0) * (0.55 + 0.45 * eventIntimacyDepth) * (0.7 + 0.3 * participantReciprocity) * (1 / (1 + 0.22 * rankBefore));
   const affinityLoss = weightedBase * Math.max(-eventValence, 0) * 0.35;
   const affinityMass = clamp3(
@@ -3529,15 +3836,16 @@ function applyEventEffectToLink(db, params) {
   const latest = db.prepare(
     `SELECT occurred_at
        FROM link_event_effects
-       WHERE link_id = ?
+       WHERE link_id = ? AND counts_for_recency = 1 AND event_id IN (SELECT id FROM events WHERE deleted_at IS NULL AND (occurred_at <= ? OR occurred_on <= ?))
        ORDER BY occurred_at DESC, event_id DESC
        LIMIT 1`
-  ).get(params.linkId);
+  ).get(params.linkId, params.now, localCalendarDate(params.now));
   const gapDays = latest === void 0 ? cadenceBefore : Math.max(
     1,
     Math.round((params.occurredAt - latest.occurred_at) / DAY_MS3)
   );
-  const cadenceAfter = commitmentResolution === "broken" || commitmentResolution === "cancelled" ? cadenceBefore : nextCadenceDays({
+  const eventDay = db.prepare("SELECT occurred_on FROM events WHERE id = ?").get(params.eventId)?.occurred_on;
+  const cadenceAfter = commitmentResolution != null || params.eventType === "promise" || params.eventType === "agreement" || params.occurredAt > params.now && (eventDay == null || eventDay > localCalendarDate(params.now)) ? cadenceBefore : nextCadenceDays({
     kind: linkKind,
     currentCadenceDays: cadenceBefore,
     gapDays
@@ -3557,7 +3865,11 @@ function applyEventEffectToLink(db, params) {
   }
   const affinityDelta = affinityAfter - affinityBefore;
   const trustDelta = trustAfter - trustBefore;
-  const momentKind = deriveMomentKind({
+  const eventLabel = db.prepare("SELECT summary FROM events WHERE id=?").get(params.eventId)?.summary;
+  const followLike = params.eventType === "milestone" && typeof eventLabel === "string" && /^(?:follow(?:ed|ing)?|like(?:d)?|repost(?:ed)?)(?:\b|[-_])/i.test(
+    eventLabel
+  );
+  const momentKind = followLike ? null : deriveMomentKind({
     rankBefore,
     rankAfter,
     stateBefore,
@@ -3600,7 +3912,15 @@ function applyEventEffectToLink(db, params) {
     params.now,
     params.now
   );
-  if (commitmentResolution === "broken" || commitmentResolution === "cancelled") {
+  db.prepare(
+    "UPDATE link_event_effects SET participant_json=?,provenance_json=? WHERE event_id=? AND link_id=?"
+  ).run(
+    JSON.stringify(params.participant),
+    params.provenance === void 0 ? null : JSON.stringify(params.provenance),
+    params.eventId,
+    params.linkId
+  );
+  if (commitmentResolution !== void 0 && commitmentResolution !== null || params.eventType === "promise" || params.eventType === "agreement" || params.participant.directionality === "owner_initiated") {
     db.prepare(
       "UPDATE link_event_effects SET counts_for_recency = 0 WHERE event_id = ? AND link_id = ?"
     ).run(params.eventId, params.linkId);
@@ -3631,6 +3951,7 @@ function applyEventEffectToLink(db, params) {
 
 // src/lib/errors/affinity_conflict_error.ts
 var AffinityConflictError = class extends AffinityError {
+  existingContactId;
   code = "CONFLICT";
 };
 
@@ -3685,6 +4006,8 @@ function buildLinkMutationReceipt(primary, partial) {
 // src/links/seed_social_link.ts
 function seedSocialLink(db, input) {
   return withTransaction(db, () => {
+    if (input.ifExists !== void 0 && !["error", "return"].includes(input.ifExists))
+      throw new AffinityValidationError("ifExists must be error or return");
     if (!isRelationalLinkKind(input.kind)) {
       throw new AffinityValidationError("invalid relational link kind");
     }
@@ -3692,11 +4015,14 @@ function seedSocialLink(db, input) {
       throw new AffinityValidationError("from and to contacts must differ");
     }
     assertContactEndpointsNotMerged(db, input.fromContactId, input.toContactId);
-    if (findLiveRelationalLinkAnyDirection(
+    const existing = findLiveRelationalLinkAnyDirection(
       db,
       input.fromContactId,
       input.toContactId
-    )) {
+    );
+    if (existing) {
+      if (input.ifExists === "return")
+        return buildLinkMutationReceipt(mapLinkRowToLinkListItem(existing), {});
       throw new AffinityConflictError(
         "relational link already exists between these contacts"
       );
@@ -3802,15 +4128,36 @@ function ensureRelationalLink(db, params) {
   };
 }
 function applyJournalEventMechanics(db, params) {
+  const bond = db.prepare("SELECT affects_bond, channel FROM events WHERE id=?").get(params.eventId);
+  const ambient = params.provenance && typeof params.provenance === "object" && (params.provenance.ambient === true || params.provenance.tags?.includes("ambient"));
+  if (bond?.affects_bond === 0 || bond?.affects_bond == null && params.eventType === "observation" && params.significance <= 2 || ambient)
+    return { created: [], affectedLinks: [], derivedEffects: [] };
   const ownerId = requireOwnerContactId(db);
-  const participantIds = params.participants.map(
+  const owner = params.participants.find((p) => p.contactId === ownerId);
+  const socialChannel = [
+    "bluesky",
+    "x",
+    "twitter",
+    "mastodon",
+    "github",
+    "instagram"
+  ].includes(String(bond?.channel));
+  const direction = owner?.directionality ?? (socialChannel ? owner?.role === "actor" ? "owner_initiated" : owner?.role === "recipient" ? "other_initiated" : void 0 : void 0);
+  const participants = params.participants.map(
+    (p) => direction && p.directionality === void 0 ? { ...p, directionality: direction } : p
+  );
+  if (direction)
+    db.prepare(
+      "UPDATE event_participants SET directionality=? WHERE event_id=? AND directionality IS NULL"
+    ).run(direction, params.eventId);
+  const participantIds = participants.map(
     (participant) => participant.contactId
   );
   const hasOwner = participantIds.includes(ownerId);
   const created = [];
   const effectInputs = [];
   if (hasOwner) {
-    for (const participant of params.participants) {
+    for (const participant of participants) {
       if (participant.contactId === ownerId) {
         continue;
       }
@@ -3818,13 +4165,14 @@ function applyJournalEventMechanics(db, params) {
         fromContactId: ownerId,
         toContactId: participant.contactId,
         kind: inferAutoLinkKind(db, ownerId, participant.contactId),
+        ...(participant.directionality ?? participants.find((p) => p.contactId === ownerId)?.directionality) === "owner_initiated" ? { affinity: 0.15 } : {},
         now: params.now
       });
       created.push(...ensured.created);
       effectInputs.push({ linkId: ensured.linkId, participant });
     }
-  } else if (params.eventType === "observation" && params.participants.length === 2) {
-    const [first, second] = params.participants;
+  } else if (params.eventType === "observation" && participants.length === 2) {
+    const [first, second] = participants;
     if (first !== void 0 && second !== void 0) {
       const a = Math.min(first.contactId, second.contactId);
       const b = Math.max(first.contactId, second.contactId);
@@ -3859,7 +4207,10 @@ function applyJournalEventMechanics(db, params) {
         eventType: params.eventType,
         occurredAt: params.occurredAt,
         significance: params.significance,
-        participant: input.participant,
+        participant: {
+          ...input.participant,
+          directionality: input.participant.directionality ?? participants.find((p) => p.contactId === ownerId)?.directionality
+        },
         provenance: params.provenance,
         now: params.now
       })
@@ -3883,6 +4234,8 @@ function applyJournalEventMechanics(db, params) {
 function recordCommitment(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     if (input.commitmentType !== "promise" && input.commitmentType !== "agreement") {
       throw new AffinityValidationError(
         "commitmentType must be promise or agreement"
@@ -3897,11 +4250,12 @@ function recordCommitment(db, input) {
     assertOwnerParticipates(ownerId, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: input.commitmentType,
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -3910,15 +4264,25 @@ function recordCommitment(db, input) {
          event_id, commitment_type, due_at, created_at, updated_at
        ) VALUES (?, ?, ?, ?, ?)`
     ).run(eventId, input.commitmentType, input.dueAt ?? null, now, now);
+    db.prepare("UPDATE open_commitments SET due_on = ? WHERE event_id = ?").run(
+      input.dueAt == null ? null : input.dueOn ?? new Date(input.dueAt).toISOString().slice(0, 10),
+      eventId
+    );
     const mechanics = applyJournalEventMechanics(db, {
       eventId,
       eventType: input.commitmentType,
       occurredAt: input.occurredAt,
+      occurredOn: input.occurredOn,
       significance: input.significance,
       participants: input.participants,
       provenance: input.provenance,
       now
     });
+    if (input.momentKind !== void 0)
+      db.prepare("UPDATE events SET moment_kind=? WHERE id=?").run(
+        input.momentKind,
+        eventId
+      );
     return buildEventMutationReceipt(loadEventRecord(db, eventId), {
       created: [{ kind: "event", id: eventId }, ...mechanics.created],
       affectedLinks: mechanics.affectedLinks,
@@ -3992,6 +4356,7 @@ function resolveCommitment(db, commitmentEventId, resolution, options) {
       const occurredAt = options?.resolvingEvent?.occurredAt ?? now;
       validateSocialEventInput({
         occurredAt,
+        ...options?.resolvingEvent?.occurredOn ? { occurredOn: options.resolvingEvent.occurredOn } : {},
         summary,
         significance,
         participants,
@@ -4008,6 +4373,7 @@ function resolveCommitment(db, commitmentEventId, resolution, options) {
       const resolvingEventId = insertJournalEvent(db, {
         type: eventType,
         occurredAt,
+        ...options?.resolvingEvent?.occurredOn ? { occurredOn: options.resolvingEvent.occurredOn } : {},
         summary,
         significance,
         momentKind: null,
@@ -4068,7 +4434,13 @@ function prepareParticipants(db, raw) {
 }
 function manageCommitmentToolHandler(db, rawInput) {
   const input = structuredClone(rawInput);
-  const inputError = validateToolInput(manageCommitmentTool.inputSchema, input);
+  const inputError = validateToolInput(
+    manageCommitmentTool.inputSchema,
+    input,
+    "input",
+    Date.now(),
+    true
+  );
   if (inputError)
     return toolFailure(
       "protocol",
@@ -4098,6 +4470,21 @@ function manageCommitmentToolHandler(db, rawInput) {
         "commitment"
       );
     }
+    if (!Number.isInteger(input.commitmentEventId))
+      return toolFailure(
+        "protocol",
+        "invalid_input",
+        "Missing commitment.",
+        "commitmentEventId is required for resolve."
+      );
+    const event = db.prepare("SELECT type FROM events WHERE id = ? AND deleted_at IS NULL").get(input.commitmentEventId);
+    if (event && !["promise", "agreement"].includes(event.type))
+      return toolFailure(
+        "domain",
+        "invalid_input",
+        "Invalid commitment.",
+        "not a commitment event"
+      );
     return mutationToolResult(
       "resolve",
       resolveCommitment(
@@ -4136,15 +4523,21 @@ var manageCommitmentTool = defineAffinityTool({
             "promise",
             "agreement"
           ]),
+          ...eventMetadataSchema,
           occurredAt: integerSchema(
             "When the commitment was made, Unix timestamp in milliseconds."
           ),
           summary: stringSchema("Commitment summary. Must be non-empty."),
           significance: integerSchema("Commitment significance from 1 to 10."),
           dueAt: integerSchema("Optional due timestamp."),
+          dueOn: stringSchema("Due calendar day."),
           participants: arraySchema(
             objectSchema(
               {
+                contact: objectSchema(
+                  { contactId: integerSchema("Contact id.") },
+                  ["contactId"]
+                ),
                 contactId: integerSchema(
                   "Participant contact id. The owner contact MUST be included."
                 ),
@@ -4157,13 +4550,7 @@ var manageCommitmentTool = defineAffinityTool({
           ),
           now: integerSchema("Optional timestamp override.")
         },
-        [
-          "commitmentType",
-          "occurredAt",
-          "summary",
-          "significance",
-          "participants"
-        ],
+        ["commitmentType", "occurredAt", "significance", "participants"],
         "Commitment payload. Required when action=record."
       ),
       commitmentEventId: integerSchema(
@@ -4178,6 +4565,19 @@ var manageCommitmentTool = defineAffinityTool({
           now: integerSchema("Optional timestamp."),
           resolvingEvent: objectSchema(
             {
+              occurredOn: stringSchema("Calendar day."),
+              provenance: {},
+              participants: arraySchema(
+                objectSchema(
+                  {
+                    contactId: integerSchema("Contact id."),
+                    role: stringSchema("Role."),
+                    directionality: stringSchema("Directionality.")
+                  },
+                  ["contactId", "role"]
+                ),
+                "Resolving participants."
+              ),
               type: stringSchema("Optional resolving event type."),
               occurredAt: integerSchema("Optional resolving event timestamp."),
               summary: stringSchema("Optional resolving event summary."),
@@ -4258,30 +4658,46 @@ function deleteContact(db, locatorId, options) {
   });
 }
 
-// src/contacts/export_contact.ts
-function exportContact(db, id) {
-  const query = (sql, ...params) => db.prepare(sql).all(...params).map((row) => {
+// src/contacts/export_rows.ts
+function exportRows(db, sql, ...params) {
+  return db.prepare(sql).all(...params).map((row) => {
     const result = {};
     for (const [key, value] of Object.entries(row)) {
       const name = key.replace(
         /_([a-z])/g,
         (_, letter) => letter.toUpperCase()
       );
-      result[name] = value;
-      if ((name.endsWith("At") || name === "dueAt") && typeof value === "number")
+      result[name] = [
+        "affects_bond",
+        "is_owner",
+        "is_structural",
+        "verified",
+        "counts_for_recency",
+        "manual"
+      ].includes(key) ? Boolean(value) : value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : value;
+      if (name.endsWith("At") && typeof value === "number")
         result[`${name}Iso`] = new Date(value).toISOString();
       if (key.endsWith("_json") && typeof value === "string")
         result[name] = JSON.parse(value);
     }
     return result;
   });
+}
+
+// src/contacts/export_contact.ts
+function exportContact(db, id) {
+  const query = (sql, ...params) => exportRows(db, sql, ...params);
   const contact = query("SELECT * FROM contacts WHERE id = ?", id)[0];
   if (!contact) throw new AffinityNotFoundError("contact not found");
   const events = query(
-    "SELECT DISTINCT e.* FROM events e JOIN event_participants p ON p.event_id = e.id WHERE p.contact_id = ? ORDER BY e.id",
+    "SELECT DISTINCT e.*, CAST(e.content AS BLOB) AS content, CAST(e.summary AS BLOB) AS summary FROM events e JOIN event_participants p ON p.event_id = e.id WHERE p.contact_id = ? AND e.type != 'date_anchor' ORDER BY e.id",
     id
   ).map((event) => ({
     ...event,
+    attributes: query(
+      "SELECT * FROM attributes WHERE event_id=? ORDER BY id",
+      event.id
+    ),
     participants: query(
       "SELECT p.*, c.name AS contact_name FROM event_participants p JOIN contacts c ON c.id = p.contact_id WHERE event_id = ? ORDER BY p.contact_id",
       event.id
@@ -4326,11 +4742,33 @@ function exportContact(db, id) {
 // src/contacts/export_affinity.ts
 function exportAffinity(db) {
   const now = Date.now();
+  const records = db.prepare("SELECT id FROM contacts ORDER BY id").all().map((row) => exportContact(db, row.id));
+  const events = exportRows(
+    db,
+    "SELECT *, CAST(content AS BLOB) AS content, CAST(summary AS BLOB) AS summary FROM events ORDER BY id"
+  ).map((event) => ({
+    ...event,
+    attributes: exportRows(
+      db,
+      "SELECT * FROM attributes WHERE event_id=? ORDER BY id",
+      event.id
+    ),
+    participants: exportRows(
+      db,
+      "SELECT p.contact_id, p.role, c.name AS contact_name FROM event_participants p JOIN contacts c ON c.id = p.contact_id WHERE p.event_id = ? ORDER BY p.contact_id",
+      event.id
+    )
+  }));
   return {
     version: 1,
     exportedAt: now,
     exportedAtIso: new Date(now).toISOString(),
-    contacts: db.prepare("SELECT id FROM contacts ORDER BY id").all().map((row) => exportContact(db, row.id))
+    events,
+    contacts: records.map(({ events: events2, dates, ...record }) => ({
+      ...record,
+      eventIds: events2.map((event) => event.id),
+      dateIds: dates.map((date) => date.id)
+    }))
   };
 }
 
@@ -4403,7 +4841,7 @@ function assertValidLifecycleTransition(from, to) {
   }
   if (to === "merged") {
     throw new AffinityInvariantError(
-      "use manage_contact merge (CLI: contact merge) to reach merged state"
+      "use merge_contacts (CLI: contact merge) to reach merged state"
     );
   }
   if (from === to) {
@@ -4455,67 +4893,6 @@ function setContactLifecycle(db, contactId, lifecycleState, options) {
   });
 }
 
-// src/contacts/create_contact.ts
-var KINDS = /* @__PURE__ */ new Set([
-  "human",
-  "group",
-  "company",
-  "team",
-  "pet",
-  "service",
-  "other"
-]);
-function createContact(db, input) {
-  return withTransaction(db, () => {
-    const name = input.name.trim();
-    if (name.length === 0) {
-      throw new AffinityValidationError("name must be non-empty");
-    }
-    if (!KINDS.has(input.kind)) {
-      throw new AffinityValidationError("invalid contact kind");
-    }
-    if (input.isOwner !== void 0) {
-      throw new AffinityValidationError(
-        "isOwner is read-only; pass bootstrapOwner: true to create the owner contact"
-      );
-    }
-    const now = resolveNow(input.now);
-    if (input.bootstrapOwner) {
-      const existing = db.prepare(
-        "SELECT id, name FROM contacts WHERE is_owner = 1 AND deleted_at IS NULL"
-      ).get();
-      if (existing !== void 0) {
-        throw new AffinityConflictError(
-          `owner already exists: contact ${existing.id} (${existing.name}); bootstrapOwner can only be used once`
-        );
-      }
-    }
-    const isOwner = input.bootstrapOwner ? 1 : 0;
-    const result = db.prepare(
-      `INSERT INTO contacts (name, kind, lifecycle_state, is_owner, created_at, updated_at)
-         VALUES (?, ?, 'active', ?, ?, ?)`
-    ).run(name, input.kind, isOwner, now, now);
-    const id = Number(result.lastInsertRowid);
-    const row = getContactRowById(db, id);
-    if (!row) {
-      throw new AffinityInvariantError("inserted contact row not found");
-    }
-    refreshContactRollup(db, id, now);
-    const primary = mapContactRowToContactListItem(row);
-    return buildContactMutationReceipt(primary, {
-      created: [{ kind: "contact", id }]
-    });
-  });
-}
-
-// src/contacts/fold_search_text.ts
-function foldSearchText(value) {
-  let folded = value.toLowerCase();
-  if (/[^\u0020-\u007e]/.test(folded))
-    folded = folded.replace(/ß/g, "ss").normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "");
-  return folded.replace(/ae/g, "a").replace(/oe/g, "o").replace(/ue/g, "u");
-}
-
 // src/identities/queries.ts
 function getIdentityRowById(db, id) {
   const row = db.prepare(
@@ -4547,14 +4924,19 @@ function buildIdentityMutationReceipt(primary, partial) {
 // src/identities/validators.ts
 function assertNoIdentityCollision(db, normalizedKey, excludeIdentityId) {
   const row = excludeIdentityId === void 0 ? db.prepare(
-    "SELECT id FROM identities WHERE normalized_key = ? AND removed_at IS NULL"
-  ).get(normalizedKey) : db.prepare(
-    "SELECT id FROM identities WHERE normalized_key = ? AND removed_at IS NULL AND id != ?"
-  ).get(normalizedKey, excludeIdentityId);
+    "SELECT id FROM identities WHERE (normalized_key IN (?, ?) OR (type='custom:atproto-did' AND ? = 'did:' || lower(value))) AND removed_at IS NULL"
+  ).get(normalizedKey, legacyIdentityKey(normalizedKey), normalizedKey) : db.prepare(
+    "SELECT id FROM identities WHERE (normalized_key IN (?, ?) OR (type='custom:atproto-did' AND ? = 'did:' || lower(value))) AND removed_at IS NULL AND id != ?"
+  ).get(
+    normalizedKey,
+    legacyIdentityKey(normalizedKey),
+    normalizedKey,
+    excludeIdentityId
+  );
   if (row !== void 0) {
     const owner = db.prepare(
-      "SELECT c.id, c.name FROM contacts c JOIN identities i ON i.contact_id = c.id WHERE i.normalized_key = ? AND i.removed_at IS NULL"
-    ).get(normalizedKey);
+      "SELECT c.id, c.name FROM contacts c JOIN identities i ON i.contact_id = c.id WHERE (i.normalized_key IN (?, ?) OR (i.type='custom:atproto-did' AND ? = 'did:' || lower(i.value))) AND i.removed_at IS NULL"
+    ).get(normalizedKey, legacyIdentityKey(normalizedKey), normalizedKey);
     throw new AffinityConflictError(
       `${normalizedKey.replace(":", " ")} already belongs to #${owner?.id} ${owner?.name}`
     );
@@ -4563,6 +4945,8 @@ function assertNoIdentityCollision(db, normalizedKey, excludeIdentityId) {
 
 // src/identities/validate_identity_input.ts
 var identityTypes = [
+  "did",
+  "atproto_did",
   "email",
   "phone",
   "url",
@@ -4589,8 +4973,20 @@ var identityTypes = [
   "account_id",
   "alias"
 ];
-function validateIdentityInput(type, value) {
+function validateIdentityInput(type, rawValue) {
   const kind = type.toLowerCase();
+  const value = normalizeIdentityValue(kind, rawValue);
+  if (["did", "atproto_did", "custom:atproto-did"].includes(kind) && !/^did:[a-z0-9]+:[A-Za-z0-9._:%-]+$/.test(value))
+    throw new AffinityValidationError(
+      "did value must match did:<method>:<identifier> (for example did:plc:abc123)"
+    );
+  if (handleIdentityTypes.has(kind)) {
+    const pattern = kind === "bluesky" ? /^[a-z0-9-]+(?:\.[a-z0-9-]+)+$/ : ["x", "twitter"].includes(kind) ? /^[a-z0-9_]{1,15}$/ : kind === "mastodon" ? /^[a-z0-9_.-]+@[a-z0-9-]+(?:\.[a-z0-9-]+)+$/ : /^[a-z0-9_.-]+$/;
+    if (!pattern.test(value))
+      throw new AffinityValidationError(
+        `invalid ${kind === "handle" ? "" : `${kind} `}handle; use a handle without spaces or a URI${kind === "mastodon" ? ": user@host.tld" : kind === "bluesky" ? ": name.bsky.social" : " (leading @ is optional)"}`
+      );
+  }
   if (!identityTypes.includes(kind) && !/^custom:[a-z0-9_-]+$/.test(type))
     throw new AffinityValidationError(
       `identity type must be one of ${identityTypes.join(", ")}, or custom:<name> (lowercase a-z, 0-9, underscore or hyphen)`
@@ -4629,12 +5025,27 @@ function addIdentity(db, contactId, input) {
       throw new AffinityStateError("merged contact is read-only");
     }
     const type = input.type.trim();
-    const value = input.value.trim();
+    const value = normalizeIdentityValue(type, input.value);
     if (type.length === 0 || value.length === 0) {
       throw new AffinityValidationError("type and value must be non-empty");
     }
     validateIdentityInput(type, value);
+    if (input.ifExists !== void 0 && !["error", "return"].includes(input.ifExists))
+      throw new AffinityValidationError("ifExists must be error or return");
     const nk = normalizeIdentityKey(type, value);
+    if (input.ifExists === "return") {
+      const existing = db.prepare(
+        "SELECT id FROM identities WHERE contact_id=? AND (normalized_key IN (?, ?) OR (type='custom:atproto-did' AND ? = 'did:' || lower(value))) AND removed_at IS NULL"
+      ).get(contactId, nk, legacyIdentityKey(nk), nk);
+      if (existing) {
+        const row2 = getIdentityRowById(db, Number(existing.id));
+        if (row2)
+          return buildIdentityMutationReceipt(
+            mapIdentityRowToIdentityRecord(row2),
+            {}
+          );
+      }
+    }
     assertNoIdentityCollision(db, nk);
     const now = resolveNow(input.now);
     const verified = input.verified ? 1 : 0;
@@ -4668,31 +5079,239 @@ function addIdentity(db, contactId, input) {
   });
 }
 
-// src/tools/create_contact_tool_result.ts
-function createContactToolResult(db, input) {
+// src/contacts/create_contact.ts
+var KINDS = /* @__PURE__ */ new Set([
+  "human",
+  "group",
+  "company",
+  "team",
+  "pet",
+  "service",
+  "other"
+]);
+function createContact(db, input) {
   return withTransaction(db, () => {
-    const receipt = createContact(db, input);
-    const identityOwners = /* @__PURE__ */ new Set();
-    for (const identity of input.identities ?? []) {
-      validateIdentityInput(identity.type.trim(), identity.value.trim());
-      const existing = db.prepare(
-        "SELECT contact_id FROM identities WHERE normalized_key = ? AND removed_at IS NULL"
-      ).get(normalizeIdentityKey(identity.type, identity.value));
-      if (existing) {
-        if (Number(existing.contact_id) !== receipt.primary.id)
-          identityOwners.add(Number(existing.contact_id));
-        continue;
-      }
-      const added = addIdentity(db, receipt.primary.id, identity);
-      receipt.created.push(...added.created);
-    }
-    const result = mutationToolResult("create", receipt, "contact");
+    const name = input.name.trim();
+    if (name.length === 0) {
+      throw new AffinityValidationError("name must be non-empty");
+    }
+    if (!KINDS.has(input.kind)) {
+      throw new AffinityValidationError("invalid contact kind");
+    }
+    if (input.isOwner !== void 0) {
+      throw new AffinityValidationError(
+        "isOwner is read-only; pass bootstrapOwner: true to create the owner contact"
+      );
+    }
+    if (input.ifExists !== void 0 && !["error", "return"].includes(input.ifExists))
+      throw new AffinityValidationError("ifExists must be error or return");
+    const matches = (input.identities ?? []).flatMap((identity) => {
+      validateIdentityInput(identity.type.trim(), identity.value.trim());
+      const key = normalizeIdentityKey(identity.type, identity.value);
+      const row2 = db.prepare(
+        `SELECT c.id, c.name FROM identities i JOIN contacts c ON c.id=i.contact_id WHERE i.removed_at IS NULL AND c.deleted_at IS NULL AND (i.normalized_key IN (?, ?) OR (i.type = 'custom:atproto-did' AND ? = 'did:' || lower(i.value)))`
+      ).get(key, legacyIdentityKey(key), key);
+      return row2 ? [{ ...row2, identity }] : [];
+    });
+    const match = matches[0];
+    if (match) {
+      if (input.ifExists === "return") {
+        const existing = getContactRowById(db, match.id);
+        if (!existing)
+          throw new AffinityInvariantError("identity owner not found");
+        const primary2 = mapContactRowToContactListItem(existing);
+        return Object.assign(buildContactMutationReceipt(primary2, {}), {
+          outcome: "no_op",
+          matchedIdentities: matches.map((m) => m.identity)
+        });
+      }
+      const error = new AffinityConflictError(
+        `identity ${normalizeIdentityKey(match.identity.type, match.identity.value).replace(":", " ")} already belongs to #${match.id} ${match.name}`
+      );
+      error.existingContactId = match.id;
+      throw error;
+    }
+    const now = resolveNow(input.now);
+    if (input.bootstrapOwner) {
+      const existing = db.prepare(
+        "SELECT id, name FROM contacts WHERE is_owner = 1 AND deleted_at IS NULL"
+      ).get();
+      if (existing !== void 0) {
+        throw new AffinityConflictError(
+          `owner already exists: contact ${existing.id} (${existing.name}); bootstrapOwner can only be used once`
+        );
+      }
+    }
+    const isOwner = input.bootstrapOwner ? 1 : 0;
+    const result = db.prepare(
+      `INSERT INTO contacts (name, kind, lifecycle_state, is_owner, created_at, updated_at)
+         VALUES (?, ?, 'active', ?, ?, ?)`
+    ).run(name, input.kind, isOwner, now, now);
+    const id = Number(result.lastInsertRowid);
+    const row = getContactRowById(db, id);
+    if (!row) {
+      throw new AffinityInvariantError("inserted contact row not found");
+    }
+    refreshContactRollup(db, id, now);
+    const primary = mapContactRowToContactListItem(row);
+    const receipt = buildContactMutationReceipt(primary, {
+      created: [{ kind: "contact", id }]
+    });
+    for (const identity of input.identities ?? [])
+      receipt.created.push(...addIdentity(db, id, identity).created);
+    return receipt;
+  });
+}
+
+// src/contacts/fold_search_text.ts
+function foldSearchText(value) {
+  let folded = value.toLowerCase();
+  if (/[^\u0020-\u007e]/.test(folded))
+    folded = folded.replace(/ß/g, "ss").normalize("NFKD").replace(new RegExp("\\p{M}", "gu"), "");
+  return folded.replace(/ae/g, "a").replace(/oe/g, "o").replace(/ue/g, "u");
+}
+
+// src/contacts/list_duplicate_candidates.ts
+function pairKey(leftContactId, rightContactId) {
+  const left = Math.min(leftContactId, rightContactId);
+  const right = Math.max(leftContactId, rightContactId);
+  return `${left}:${right}`;
+}
+function normalizeName(name) {
+  return name.trim().toLowerCase().replace(/\s+/g, " ");
+}
+function fuzzyNameScore(leftInput, rightInput) {
+  const left = normalizeName(leftInput);
+  const right = normalizeName(rightInput);
+  if (left === right) {
+    return 0.92;
+  }
+  if (left.length >= 3 && right.length >= 3) {
+    if (left.includes(right) || right.includes(left)) {
+      return 0.72;
+    }
+    const leftTokens = new Set(left.split(" "));
+    const rightTokens = new Set(right.split(" "));
+    const overlap = [...leftTokens].filter(
+      (token) => rightTokens.has(token)
+    ).length;
+    if (overlap > 0) {
+      return overlap / Math.max(leftTokens.size, rightTokens.size) * 0.7;
+    }
+  }
+  return 0;
+}
+function listDuplicateCandidates(db, filters, options) {
+  assertDefaultOrdering("listDuplicateCandidates", options);
+  const { limit, offset } = resolveListLimitOffset(options);
+  const subset = filters?.contactIds;
+  const contacts = db.prepare(
+    `SELECT id, name
+       FROM contacts
+       WHERE deleted_at IS NULL
+         AND lifecycle_state != 'merged'`
+  ).all();
+  const allowedIds = subset === void 0 ? null : new Set(subset.map((contactId) => Number(contactId)));
+  const pairs = /* @__PURE__ */ new Map();
+  const exactMatches = db.prepare(
+    `SELECT
+         i1.contact_id AS left_contact_id,
+         i2.contact_id AS right_contact_id,
+         i1.normalized_key
+       FROM identities i1
+       INNER JOIN identities i2
+         ON i1.normalized_key = i2.normalized_key
+        AND i1.contact_id < i2.contact_id
+       INNER JOIN contacts c1 ON c1.id = i1.contact_id
+       INNER JOIN contacts c2 ON c2.id = i2.contact_id
+       WHERE i1.removed_at IS NULL
+         AND i2.removed_at IS NULL
+         AND c1.deleted_at IS NULL
+         AND c2.deleted_at IS NULL
+         AND c1.lifecycle_state != 'merged'
+         AND c2.lifecycle_state != 'merged'`
+  ).all();
+  for (const match of exactMatches) {
+    if (allowedIds !== null && (!allowedIds.has(match.left_contact_id) || !allowedIds.has(match.right_contact_id))) {
+      continue;
+    }
+    pairs.set(pairKey(match.left_contact_id, match.right_contact_id), {
+      leftContactId: match.left_contact_id,
+      rightContactId: match.right_contact_id,
+      matchReason: `exact identity ${match.normalized_key}`,
+      matchScore: 1
+    });
+  }
+  if (filters?.exactOnly !== true) {
+    for (let index = 0; index < contacts.length; index += 1) {
+      const left = contacts[index];
+      if (left === void 0 || allowedIds !== null && !allowedIds.has(left.id)) {
+        continue;
+      }
+      const leftName = normalizeName(left.name);
+      for (let offsetIndex = index + 1; offsetIndex < contacts.length; offsetIndex += 1) {
+        const right = contacts[offsetIndex];
+        if (right === void 0 || allowedIds !== null && !allowedIds.has(right.id)) {
+          continue;
+        }
+        const score = fuzzyNameScore(leftName, normalizeName(right.name));
+        if (score <= 0) {
+          continue;
+        }
+        const key = pairKey(left.id, right.id);
+        if (!pairs.has(key)) {
+          pairs.set(key, {
+            leftContactId: left.id,
+            rightContactId: right.id,
+            matchReason: "name similarity",
+            matchScore: score
+          });
+        }
+      }
+    }
+  }
+  const dismissedRows = db.prepare("SELECT left_id, right_id FROM dismissed_duplicates").all();
+  const dismissedSet = new Set(
+    dismissedRows.map((r) => pairKey(r.left_id, r.right_id))
+  );
+  const includeDismissed = filters?.includeDismissed === true;
+  for (const candidate of pairs.values()) {
+    if (dismissedSet.has(
+      pairKey(candidate.leftContactId, candidate.rightContactId)
+    )) {
+      candidate.dismissed = true;
+    }
+  }
+  const minScore = filters?.minScore ?? 0;
+  return [...pairs.values()].filter((candidate) => {
+    if (candidate.matchScore < minScore) return false;
+    if (candidate.dismissed === true && !includeDismissed) return false;
+    return true;
+  }).sort((left, right) => {
+    const leftExact = left.matchScore === 1 ? 1 : 0;
+    const rightExact = right.matchScore === 1 ? 1 : 0;
+    return rightExact - leftExact || right.matchScore - left.matchScore;
+  }).slice(offset, offset + limit);
+}
+
+// src/tools/create_contact_tool_result.ts
+function createContactToolResult(db, input) {
+  return withTransaction(db, () => {
+    const receipt = createContact(db, input);
+    const result = mutationToolResult("create", receipt, "contact");
+    if (result.ok && receipt.outcome === "no_op") {
+      result.outcome = "no_op";
+      Object.assign(result.data, {
+        matchedIdentities: receipt.matchedIdentities
+      });
+      return result;
+    }
     const fold = (name) => foldSearchText(name).trim().replace(/\s+/g, " ");
     const warnings = db.prepare(
       "SELECT id, name FROM contacts WHERE id != ? AND deleted_at IS NULL AND lifecycle_state IN ('active', 'dormant')"
     ).all(receipt.primary.id).flatMap((row) => {
-      const score = identityOwners.has(row.id) ? 1 : fold(row.name) === fold(input.name) ? 0.92 : void 0;
-      return score === void 0 ? [] : [
+      const score = fold(row.name) === fold(input.name) ? 0.92 : fuzzyNameScore(row.name, input.name);
+      return score <= 0 ? [] : [
         {
           code: "possible_duplicate",
           message: `Possible duplicate of #${row.id} ${row.name} (score ${score})`,
@@ -4775,6 +5394,13 @@ function manageContactToolHandler(db, rawInput) {
       return contact.result;
     }
     if (input.action === "delete") {
+      if (contact.value.is_owner)
+        return toolFailure(
+          "domain",
+          "conflict",
+          "Cannot delete owner.",
+          "The owner contact cannot be deleted"
+        );
       const deletion = deleteContact(db, contact.value.id, { confirm: true });
       return toolSuccess("Permanently deleted contact.", {
         action: "delete",
@@ -4848,7 +5474,11 @@ var manageContactTool = defineAffinityTool({
               },
               ["type", "value"]
             ),
-            "Optional identities to attach. Identities already owned by another contact are left with that owner and reported as possible duplicates."
+            "Optional identities to attach. An identity owned by another live contact causes a conflict, or returns that contact when ifExists=return."
+          ),
+          ifExists: enumSchema(
+            "Identity collision policy; return attaches nothing.",
+            ["error", "return"]
           ),
           name: stringSchema("Contact name."),
           kind: enumSchema("Contact kind.", [
@@ -5458,6 +6088,268 @@ var manageDuplicateDismissalTool = defineAffinityTool({
   handler: manageDuplicateDismissalToolHandler
 });
 
+// src/events/event_replay.ts
+function replayEventLinks(db, linkIds, now) {
+  const eventIds = /* @__PURE__ */ new Set();
+  for (const linkId of linkIds) {
+    const saved = db.prepare("SELECT state_json FROM event_link_baselines WHERE link_id=?").get(linkId);
+    if (!saved) continue;
+    const baseline = JSON.parse(saved.state_json);
+    const effects = db.prepare(
+      "SELECT event_id, participant_json, provenance_json, created_at FROM link_event_effects WHERE link_id=? ORDER BY event_id"
+    ).all(linkId);
+    const overrides = db.prepare(
+      "SELECT after_event_id,state FROM event_link_state_changes WHERE link_id=? ORDER BY id"
+    ).all(linkId);
+    let overrideIndex = 0;
+    const applyOverrides = (beforeId) => {
+      while (overrideIndex < overrides.length && (overrides[overrideIndex]?.after_event_id ?? Number.POSITIVE_INFINITY) < beforeId) {
+        const override = overrides[overrideIndex];
+        if (override)
+          db.prepare("UPDATE links SET state=? WHERE id=?").run(
+            override.state,
+            linkId
+          );
+        overrideIndex++;
+      }
+    };
+    db.prepare("DELETE FROM link_event_effects WHERE link_id=?").run(linkId);
+    db.prepare(
+      "UPDATE links SET rank=?,affinity=?,trust=?,state=?,cadence_days=?,updated_at=? WHERE id=?"
+    ).run(
+      baseline.rank,
+      baseline.affinity,
+      baseline.trust,
+      baseline.state,
+      baseline.cadence_days,
+      now,
+      linkId
+    );
+    for (const effect of effects) {
+      eventIds.add(effect.event_id);
+      applyOverrides(effect.event_id);
+      if (!db.prepare("SELECT id FROM events WHERE id=? AND deleted_at IS NULL").get(effect.event_id))
+        continue;
+      const event = loadEventRecord(db, effect.event_id);
+      const link = db.prepare("SELECT from_contact_id,to_contact_id FROM links WHERE id=?").get(linkId);
+      const participant = effect.participant_json ? JSON.parse(effect.participant_json) : event.participants.find((p) => p.contactId === link.to_contact_id) ?? event.participants[0];
+      const provenance = db.prepare("SELECT provenance_json FROM events WHERE id=?").get(event.id);
+      applyEventEffectToLink(db, {
+        linkId,
+        eventId: event.id,
+        eventType: event.type,
+        occurredAt: event.occurredAt,
+        significance: event.significance,
+        participant,
+        provenance: provenance.provenance_json ? JSON.parse(provenance.provenance_json) : effect.provenance_json ? JSON.parse(effect.provenance_json) : void 0,
+        now: effect.created_at
+      });
+    }
+    applyOverrides(Number.POSITIVE_INFINITY);
+    refreshLinkRollup(db, linkId, now);
+  }
+  for (const eventId of eventIds)
+    db.prepare(
+      "UPDATE events SET moment_kind=COALESCE(declared_moment_kind,(SELECT moment_kind FROM link_event_effects WHERE event_id=events.id AND moment_kind IS NOT NULL ORDER BY link_id LIMIT 1)) WHERE id=?"
+    ).run(eventId);
+  refreshAllBridgeScores(db, now);
+}
+
+// src/events/manage_event.ts
+function requireEventTarget(db, target) {
+  const selector = typeof target === "number" ? { eventId: target } : target;
+  if (!selector || selector.eventId === void 0 === (selector.ref === void 0))
+    throw new AffinityValidationError("Provide exactly one of eventId or ref");
+  const event = selector.ref ? getEventByExternalRef(db, selector.ref.source, selector.ref.id) : getEventById(db, selector.eventId);
+  if (!event) throw new AffinityNotFoundError("event not found");
+  return event;
+}
+function affected(db, id) {
+  return db.prepare("SELECT link_id FROM link_event_effects WHERE event_id=?").all(id).map((r) => r.link_id);
+}
+function reviseEvent(db, target, patch) {
+  return withTransaction(db, () => {
+    const allowed = [
+      "summary",
+      "content",
+      "occurredAt",
+      "significance",
+      "channel",
+      "type",
+      "externalRef"
+    ];
+    for (const key of Object.keys(patch))
+      if (!allowed.includes(key))
+        throw new AffinityValidationError(
+          `unknown patch key ${key}; allowed keys: ${allowed.join(", ")}`
+        );
+    const event = requireEventTarget(db, target);
+    const next = { ...event, ...patch };
+    const { momentKind: _momentKind, ...metadata } = next;
+    validateEventMetadata(metadata);
+    Object.assign(next, metadata);
+    if (patch.summary !== void 0 && (typeof patch.summary !== "string" || !patch.summary.trim()))
+      throw new AffinityValidationError("summary must be non-empty");
+    if (patch.occurredAt !== void 0)
+      assertFiniteTimestamp(patch.occurredAt, "occurredAt");
+    if (!Number.isInteger(next.significance) || next.significance < 1 || next.significance > 10)
+      throw new AffinityValidationError(
+        "significance must be an integer from 1 to 10"
+      );
+    const interactions = [
+      "conversation",
+      "activity",
+      "gift",
+      "support",
+      "conflict",
+      "correction"
+    ];
+    if (next.type !== event.type && !(interactions.includes(event.type) && interactions.includes(next.type)) && !(["promise", "agreement"].includes(event.type) && ["promise", "agreement"].includes(next.type)))
+      throw new AffinityValidationError(
+        "type must stay within the same event kind"
+      );
+    if (patch.externalRef && event.externalRef)
+      throw new AffinityConflictError(
+        "externalRef can only be set when absent"
+      );
+    if (patch.externalRef && next.externalRef && getEventByExternalRef(db, next.externalRef.source, next.externalRef.id))
+      throw new AffinityConflictError(
+        "externalRef already belongs to an event"
+      );
+    const now = Date.now();
+    const links = affected(db, event.id);
+    db.prepare(
+      "UPDATE events SET summary=?,content=?,occurred_at=?,occurred_on=?,significance=?,channel=?,type=?,external_source=?,external_id=?,updated_at=? WHERE id=?"
+    ).run(
+      next.summary.trim(),
+      next.content ?? null,
+      next.occurredAt,
+      patch.occurredAt === void 0 ? event.occurredOn ?? null : new Date(next.occurredAt).toISOString().slice(0, 10),
+      next.significance,
+      next.channel ?? null,
+      next.type,
+      next.externalRef?.source ?? null,
+      next.externalRef?.id ?? null,
+      now,
+      event.id
+    );
+    if (patch.type && ["promise", "agreement"].includes(patch.type))
+      db.prepare(
+        "UPDATE open_commitments SET commitment_type=? WHERE event_id=?"
+      ).run(patch.type, event.id);
+    if (patch.significance !== void 0 || patch.type !== void 0 || patch.occurredAt !== void 0)
+      replayEventLinks(db, links, now);
+    return buildEventMutationReceipt(requireEventTarget(db, event.id), {
+      updated: [{ kind: "event", id: event.id }],
+      affectedLinks: links
+    });
+  });
+}
+function deleteEvent(db, target, options) {
+  return withTransaction(db, () => {
+    if (options?.confirm !== true)
+      throw new AffinityValidationError("deleteEvent requires confirm: true");
+    const event = requireEventTarget(db, target);
+    const links = affected(db, event.id);
+    for (const table of [
+      "event_participants",
+      "attributes",
+      "open_commitments",
+      "upcoming_occurrences",
+      "link_event_effects"
+    ])
+      db.prepare(`DELETE FROM ${table} WHERE event_id=?`).run(event.id);
+    db.prepare(
+      "UPDATE events SET parent_event_id=NULL WHERE parent_event_id=?"
+    ).run(event.id);
+    db.prepare("DELETE FROM events WHERE id=?").run(event.id);
+    replayEventLinks(db, links, Date.now());
+    return buildEventMutationReceipt(event, {
+      removed: [{ kind: "event", id: event.id }],
+      affectedLinks: links
+    });
+  });
+}
+
+// src/tools/manage_event_tool.ts
+function manageEventToolHandler(db, raw) {
+  const input = structuredClone(raw);
+  const error = validateToolInput(
+    manageEventTool.inputSchema,
+    input,
+    "input",
+    Date.now(),
+    true
+  );
+  if (error)
+    return toolFailure("protocol", "invalid_input", "Invalid input.", error);
+  return withToolHandling(() => {
+    const target = {
+      ...input.eventId === void 0 ? {} : { eventId: input.eventId },
+      ...input.ref === void 0 ? {} : { ref: input.ref }
+    };
+    return mutationToolResult(
+      input.action,
+      input.action === "revise" ? reviseEvent(db, target, input.patch ?? {}) : deleteEvent(db, target, { confirm: input.confirm === true }),
+      "event"
+    );
+  }, "Event management failed.");
+}
+var manageEventTool = defineAffinityTool({
+  name: manageEventToolName,
+  description: "Revise or delete one event by eventId or external reference. Delete requires confirm=true and recomputes affected relationships.",
+  whenToUse: "Correct imported event text or metadata, or remove an event.",
+  whenNotToUse: "Use record_event to capture new evidence.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["event"],
+  inputDescriptions: {
+    action: "revise or delete",
+    eventId: "Exact event id",
+    ref: "External event reference",
+    patch: "Fields to revise",
+    confirm: "Required true for deletion"
+  },
+  outputDescription: "Event mutation receipt and affected links.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action.", ["revise", "delete"]),
+      eventId: integerSchema("Event id; provide eventId or ref."),
+      ref: externalRefSchema,
+      confirm: booleanSchema("Must be true to delete."),
+      patch: objectSchema(
+        {
+          summary: stringSchema("Short non-empty label."),
+          content: stringSchema("Verbatim content, at most 1 MB UTF-8."),
+          occurredAt: integerSchema("Event timestamp."),
+          significance: integerSchema("Significance 1..10."),
+          channel: stringSchema("Channel, at most 40 characters."),
+          type: enumSchema("Type within the same event kind.", [
+            "conversation",
+            "activity",
+            "gift",
+            "support",
+            "conflict",
+            "correction",
+            "observation",
+            "milestone",
+            "transaction",
+            "promise",
+            "agreement",
+            "date_anchor"
+          ]),
+          externalRef: externalRefSchema
+        },
+        [],
+        "Fields to revise; externalRef may only be added when absent."
+      )
+    },
+    ["action"]
+  ),
+  handler: manageEventToolHandler
+});
+
 // src/identities/remove_identity.ts
 function removeIdentity(db, identityId, removedAt) {
   return withTransaction(db, () => {
@@ -5505,7 +6397,10 @@ function reviseIdentity(db, identityId, patch) {
       });
     }
     const nextType = patch.type !== void 0 ? patch.type.trim() : row.type;
-    const nextValue = patch.value !== void 0 ? patch.value.trim() : row.value;
+    const nextValue = normalizeIdentityValue(
+      nextType,
+      patch.value ?? row.value
+    );
     if (nextType.length === 0 || nextValue.length === 0) {
       throw new AffinityValidationError("type and value must be non-empty");
     }
@@ -5564,6 +6459,10 @@ function contactLocatorSchema6(description) {
       contactId: integerSchema("Exact contact id."),
       identity: objectSchema(
         {
+          ifExists: enumSchema(
+            "Return an existing identity on this contact without changes.",
+            ["error", "return"]
+          ),
           type: stringSchema(
             `Identity type: ${identityTypes.join(", ")}, or custom:<name> (lowercase a-z, 0-9, underscore or hyphen).`
           ),
@@ -5660,6 +6559,10 @@ var manageIdentityTool = defineAffinityTool({
       ),
       input: objectSchema(
         {
+          ifExists: enumSchema(
+            "Return an existing identity on this contact without changes.",
+            ["error", "return"]
+          ),
           type: stringSchema(
             `Identity type: ${identityTypes.join(", ")}, or custom:<name> (lowercase a-z, 0-9, underscore or hyphen).`
           ),
@@ -5721,6 +6624,9 @@ function overrideLinkState(db, linkId, state, options) {
       now,
       linkId
     );
+    db.prepare(
+      "INSERT INTO event_link_state_changes(link_id,after_event_id,state) SELECT ?, COALESCE(MAX(event_id),0), ? FROM link_event_effects WHERE link_id=?"
+    ).run(linkId, state, linkId);
     refreshLinkRollup(db, linkId, now);
     if (state === "archived" || row.state === "archived") {
       refreshAllBridgeScores(db, now);
@@ -6355,6 +7261,8 @@ var ALLOWED = /* @__PURE__ */ new Set([
 function recordInteraction(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     if (!ALLOWED.has(input.type)) {
       throw new AffinityValidationError("invalid interaction event type");
     }
@@ -6364,11 +7272,12 @@ function recordInteraction(db, input) {
     assertOwnerParticipates(ownerId, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: input.type,
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -6376,12 +7285,24 @@ function recordInteraction(db, input) {
       eventId,
       eventType: input.type,
       occurredAt: input.occurredAt,
+      occurredOn: input.occurredOn,
       significance: input.significance,
       participants: input.participants,
       provenance: input.provenance,
       now
     });
+    if (input.momentKind !== void 0)
+      db.prepare("UPDATE events SET moment_kind=? WHERE id=?").run(
+        input.momentKind,
+        eventId
+      );
     return buildEventMutationReceipt(loadEventRecord(db, eventId), {
+      warnings: input.occurredAt > now && (input.occurredOn ?? new Date(input.occurredAt).toISOString().slice(0, 10)) > localCalendarDate(now) ? [
+        {
+          code: "future_event",
+          message: "occurredAt is in the future; it will not count as contact until then"
+        }
+      ] : void 0,
       created: [{ kind: "event", id: eventId }, ...mechanics.created],
       affectedLinks: mechanics.affectedLinks,
       derivedEffects: mechanics.derivedEffects
@@ -6393,17 +7314,20 @@ function recordInteraction(db, input) {
 function recordMilestone(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     const ownerId = requireOwnerContactId(db);
     const ids = input.participants.map((p) => p.contactId);
     assertParticipantContactsLive(db, ids);
     assertOwnerParticipates(ownerId, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: "milestone",
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -6411,12 +7335,24 @@ function recordMilestone(db, input) {
       eventId,
       eventType: "milestone",
       occurredAt: input.occurredAt,
+      occurredOn: input.occurredOn,
       significance: input.significance,
       participants: input.participants,
       provenance: input.provenance,
       now
     });
+    if (input.momentKind !== void 0)
+      db.prepare("UPDATE events SET moment_kind=? WHERE id=?").run(
+        input.momentKind,
+        eventId
+      );
     return buildEventMutationReceipt(loadEventRecord(db, eventId), {
+      warnings: input.occurredAt > now && (input.occurredOn ?? new Date(input.occurredAt).toISOString().slice(0, 10)) > localCalendarDate(now) ? [
+        {
+          code: "future_event",
+          message: "occurredAt is in the future; it will not count as contact until then"
+        }
+      ] : void 0,
       created: [{ kind: "event", id: eventId }, ...mechanics.created],
       affectedLinks: mechanics.affectedLinks,
       derivedEffects: mechanics.derivedEffects
@@ -6428,15 +7364,18 @@ function recordMilestone(db, input) {
 function recordObservation(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     const ids = input.participants.map((p) => p.contactId);
     assertParticipantContactsLive(db, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: "observation",
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -6444,12 +7383,24 @@ function recordObservation(db, input) {
       eventId,
       eventType: "observation",
       occurredAt: input.occurredAt,
+      occurredOn: input.occurredOn,
       significance: input.significance,
       participants: input.participants,
       provenance: input.provenance,
       now
     });
+    if (input.momentKind !== void 0)
+      db.prepare("UPDATE events SET moment_kind=? WHERE id=?").run(
+        input.momentKind,
+        eventId
+      );
     return buildEventMutationReceipt(loadEventRecord(db, eventId), {
+      warnings: input.occurredAt > now && (input.occurredOn ?? new Date(input.occurredAt).toISOString().slice(0, 10)) > localCalendarDate(now) ? [
+        {
+          code: "future_event",
+          message: "occurredAt is in the future; it will not count as contact until then"
+        }
+      ] : void 0,
       created: [{ kind: "event", id: eventId }, ...mechanics.created],
       affectedLinks: mechanics.affectedLinks,
       derivedEffects: mechanics.derivedEffects
@@ -6461,17 +7412,20 @@ function recordObservation(db, input) {
 function recordTransaction(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     const ownerId = requireOwnerContactId(db);
     const ids = input.participants.map((p) => p.contactId);
     assertParticipantContactsLive(db, ids);
     assertOwnerParticipates(ownerId, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: "transaction",
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -6479,12 +7433,24 @@ function recordTransaction(db, input) {
       eventId,
       eventType: "transaction",
       occurredAt: input.occurredAt,
+      occurredOn: input.occurredOn,
       significance: input.significance,
       participants: input.participants,
       provenance: input.provenance,
       now
     });
+    if (input.momentKind !== void 0)
+      db.prepare("UPDATE events SET moment_kind=? WHERE id=?").run(
+        input.momentKind,
+        eventId
+      );
     return buildEventMutationReceipt(loadEventRecord(db, eventId), {
+      warnings: input.occurredAt > now && (input.occurredOn ?? new Date(input.occurredAt).toISOString().slice(0, 10)) > localCalendarDate(now) ? [
+        {
+          code: "future_event",
+          message: "occurredAt is in the future; it will not count as contact until then"
+        }
+      ] : void 0,
       created: [{ kind: "event", id: eventId }, ...mechanics.created],
       affectedLinks: mechanics.affectedLinks,
       derivedEffects: mechanics.derivedEffects
@@ -6493,11 +7459,13 @@ function recordTransaction(db, input) {
 }
 
 // src/tools/record_event_tool.ts
-function normalizeParticipant2(p) {
+function normalizeParticipant2(db, p) {
   let contactId = p.contactId;
   if (contactId === void 0 && p.contact != null) {
     const loc = p.contact;
-    contactId = loc.contactId;
+    const resolved = resolveContactLocator(db, loc);
+    if (!resolved.ok) throw resolved.result;
+    contactId = resolved.value.id;
   }
   const result = {
     contactId,
@@ -6515,12 +7483,18 @@ function ensureOwnerParticipates2(db, participants) {
   return [{ contactId: ownerId, role: "actor" }, ...participants];
 }
 function prepareParticipants2(db, raw, injectOwner) {
-  const normalized = raw.map(normalizeParticipant2);
+  const normalized = raw.map((p) => normalizeParticipant2(db, p));
   return injectOwner ? ensureOwnerParticipates2(db, normalized) : normalized;
 }
 function recordEventToolHandler(db, rawInput) {
   const input = structuredClone(rawInput);
-  const inputError = validateToolInput(recordEventTool.inputSchema, input);
+  const inputError = validateToolInput(
+    recordEventTool.inputSchema,
+    input,
+    "input",
+    Date.now(),
+    true
+  );
   if (inputError)
     return toolFailure(
       "protocol",
@@ -6600,6 +7574,7 @@ var recordEventTool = defineAffinityTool({
               "correction"
             ]
           ),
+          ...eventMetadataSchema,
           occurredAt: integerSchema(
             "When the event occurred, Unix timestamp in milliseconds."
           ),
@@ -6608,6 +7583,19 @@ var recordEventTool = defineAffinityTool({
           participants: arraySchema(
             objectSchema(
               {
+                contact: objectSchema(
+                  {
+                    contactId: integerSchema("Contact id."),
+                    identity: objectSchema(
+                      {
+                        type: stringSchema("Identity type."),
+                        value: stringSchema("Identity value.")
+                      },
+                      ["type", "value"]
+                    )
+                  },
+                  []
+                ),
                 contactId: integerSchema(
                   "Participant contact id. The owner contact MUST be included."
                 ),
@@ -6631,7 +7619,7 @@ var recordEventTool = defineAffinityTool({
           ),
           now: integerSchema("Optional timestamp override.")
         },
-        ["occurredAt", "summary", "significance", "participants"],
+        ["occurredAt", "significance", "participants"],
         "Event payload. Always required. Interaction events also require `type`."
       )
     },
@@ -6647,7 +7635,10 @@ function contactAttributeClauses(filters) {
   const params = [];
   const attributes = filters?.attribute === void 0 ? [] : [filters.attribute].flat();
   const tags = filters?.tag === void 0 ? [] : [filters.tag].flat();
-  for (const filter of [...attributes, ...tags.map((tag) => `tag:${tag}`)]) {
+  for (const filter of [
+    ...attributes,
+    ...tags.map((tag) => `tag:${tag.replace(/^tag:/i, "")}`)
+  ]) {
     const separator = filter.indexOf("=");
     const name = separator < 0 ? filter : filter.slice(0, separator);
     clauses.push(`EXISTS (SELECT 1 FROM attributes a WHERE a.contact_id = contacts.id
@@ -6681,153 +7672,32 @@ function listContacts(db, filters, options) {
   if (filters?.includeDormant === false || options?.includeDormant === false) {
     clauses.push("lifecycle_state != 'dormant'");
   }
-  const attributeFilters = contactAttributeClauses(filters);
-  clauses.push(...attributeFilters.clauses);
-  params.push(...attributeFilters.params);
-  const where = clauses.join(" AND ");
-  const rows = db.prepare(
-    `SELECT id, name, kind, lifecycle_state, is_owner, merged_into_contact_id,
-              created_at, updated_at, deleted_at,
-              (
-                SELECT value
-                FROM identities i
-                WHERE i.contact_id = contacts.id AND i.removed_at IS NULL
-                ORDER BY i.id
-                LIMIT 1
-              ) AS primary_identity
-       FROM contacts
-       WHERE ${where}
-       ORDER BY name ASC
-       LIMIT ? OFFSET ?`
-  ).all(...params, limit, offset);
-  return rows.map((r) => {
-    const item = mapContactRowToContactListItem(r);
-    return {
-      ...item,
-      primaryIdentity: r.primary_identity ?? null
-    };
-  });
-}
-
-// src/contacts/list_duplicate_candidates.ts
-function pairKey(leftContactId, rightContactId) {
-  const left = Math.min(leftContactId, rightContactId);
-  const right = Math.max(leftContactId, rightContactId);
-  return `${left}:${right}`;
-}
-function normalizeName(name) {
-  return name.trim().toLowerCase().replace(/\s+/g, " ");
-}
-function fuzzyNameScore(left, right) {
-  if (left === right) {
-    return 0.92;
-  }
-  if (left.length >= 3 && right.length >= 3) {
-    if (left.includes(right) || right.includes(left)) {
-      return 0.72;
-    }
-    const leftTokens = new Set(left.split(" "));
-    const rightTokens = new Set(right.split(" "));
-    const overlap = [...leftTokens].filter(
-      (token) => rightTokens.has(token)
-    ).length;
-    if (overlap > 0) {
-      return overlap / Math.max(leftTokens.size, rightTokens.size) * 0.7;
-    }
-  }
-  return 0;
-}
-function listDuplicateCandidates(db, filters, options) {
-  assertDefaultOrdering("listDuplicateCandidates", options);
-  const { limit, offset } = resolveListLimitOffset(options);
-  const subset = filters?.contactIds;
-  const contacts = db.prepare(
-    `SELECT id, name
-       FROM contacts
-       WHERE deleted_at IS NULL
-         AND lifecycle_state != 'merged'`
-  ).all();
-  const allowedIds = subset === void 0 ? null : new Set(subset.map((contactId) => Number(contactId)));
-  const pairs = /* @__PURE__ */ new Map();
-  const exactMatches = db.prepare(
-    `SELECT
-         i1.contact_id AS left_contact_id,
-         i2.contact_id AS right_contact_id,
-         i1.normalized_key
-       FROM identities i1
-       INNER JOIN identities i2
-         ON i1.normalized_key = i2.normalized_key
-        AND i1.contact_id < i2.contact_id
-       INNER JOIN contacts c1 ON c1.id = i1.contact_id
-       INNER JOIN contacts c2 ON c2.id = i2.contact_id
-       WHERE i1.removed_at IS NULL
-         AND i2.removed_at IS NULL
-         AND c1.deleted_at IS NULL
-         AND c2.deleted_at IS NULL
-         AND c1.lifecycle_state != 'merged'
-         AND c2.lifecycle_state != 'merged'`
-  ).all();
-  for (const match of exactMatches) {
-    if (allowedIds !== null && (!allowedIds.has(match.left_contact_id) || !allowedIds.has(match.right_contact_id))) {
-      continue;
-    }
-    pairs.set(pairKey(match.left_contact_id, match.right_contact_id), {
-      leftContactId: match.left_contact_id,
-      rightContactId: match.right_contact_id,
-      matchReason: `exact identity ${match.normalized_key}`,
-      matchScore: 1
-    });
-  }
-  if (filters?.exactOnly !== true) {
-    for (let index = 0; index < contacts.length; index += 1) {
-      const left = contacts[index];
-      if (left === void 0 || allowedIds !== null && !allowedIds.has(left.id)) {
-        continue;
-      }
-      const leftName = normalizeName(left.name);
-      for (let offsetIndex = index + 1; offsetIndex < contacts.length; offsetIndex += 1) {
-        const right = contacts[offsetIndex];
-        if (right === void 0 || allowedIds !== null && !allowedIds.has(right.id)) {
-          continue;
-        }
-        const score = fuzzyNameScore(leftName, normalizeName(right.name));
-        if (score <= 0) {
-          continue;
-        }
-        const key = pairKey(left.id, right.id);
-        if (!pairs.has(key)) {
-          pairs.set(key, {
-            leftContactId: left.id,
-            rightContactId: right.id,
-            matchReason: "name similarity",
-            matchScore: score
-          });
-        }
-      }
-    }
-  }
-  const dismissedRows = db.prepare("SELECT left_id, right_id FROM dismissed_duplicates").all();
-  const dismissedSet = new Set(
-    dismissedRows.map((r) => pairKey(r.left_id, r.right_id))
-  );
-  const includeDismissed = filters?.includeDismissed === true;
-  for (const candidate of pairs.values()) {
-    if (dismissedSet.has(
-      pairKey(candidate.leftContactId, candidate.rightContactId)
-    )) {
-      candidate.dismissed = true;
-    }
-  }
-  const minScore = filters?.minScore ?? 0;
-  return [...pairs.values()].filter((candidate) => {
-    if (candidate.matchScore < minScore) return false;
-    if (candidate.dismissed === true && !includeDismissed) return false;
-    return true;
-  }).sort((left, right) => {
-    const leftExact = left.matchScore === 1 ? 1 : 0;
-    const rightExact = right.matchScore === 1 ? 1 : 0;
-    return rightExact - leftExact || right.matchScore - left.matchScore;
-  }).slice(offset, offset + limit);
+  const attributeFilters = contactAttributeClauses(filters);
+  clauses.push(...attributeFilters.clauses);
+  params.push(...attributeFilters.params);
+  const where = clauses.join(" AND ");
+  const rows = db.prepare(
+    `SELECT id, name, kind, lifecycle_state, is_owner, merged_into_contact_id,
+              created_at, updated_at, deleted_at,
+              (
+                SELECT value
+                FROM identities i
+                WHERE i.contact_id = contacts.id AND i.removed_at IS NULL
+                ORDER BY i.id
+                LIMIT 1
+              ) AS primary_identity
+       FROM contacts
+       WHERE ${where}
+       ORDER BY name ASC
+       LIMIT ? OFFSET ?`
+  ).all(...params, limit, offset);
+  return rows.map((r) => {
+    const item = mapContactRowToContactListItem(r);
+    return {
+      ...item,
+      primaryIdentity: r.primary_identity ?? null
+    };
+  });
 }
 
 // src/dates/list_upcoming_dates.ts
@@ -6863,12 +7733,12 @@ function listUpcomingDates(db, filters, options) {
   }
   const clauses = ["e.deleted_at IS NULL", "e.type = 'date_anchor'"];
   const params = [];
-  const since = options?.since ?? utcStartOfDayMs(Date.now());
+  const since = options?.since ?? Date.parse(`${localCalendarDate(options?.now ?? Date.now())}T00:00:00Z`);
   clauses.push("uo.occurs_on >= ?");
   params.push(since);
   let maxOccurs = options?.until;
   if (filters?.horizonDays !== void 0) {
-    const anchor = options?.since ?? Date.now();
+    const anchor = since;
     const horizonEnd = anchor + filters.horizonDays * 864e5;
     maxOccurs = maxOccurs === void 0 ? horizonEnd : Math.min(maxOccurs, horizonEnd);
   }
@@ -6915,6 +7785,68 @@ function listUpcomingDates(db, filters, options) {
   return rows.map((r) => mapUpcomingRowToUpcomingDateRecord(r));
 }
 
+// src/events/event_discovery.ts
+function searchEvents(db, query, options) {
+  const { limit, offset } = resolveListLimitOffset(options);
+  const tokens = foldSearchText(query).split(/\s+/).filter(Boolean);
+  if (!tokens.length) return [];
+  const rows = db.prepare(
+    "SELECT id,type,occurred_at,occurred_on,CAST(summary AS BLOB) AS summary,CAST(content AS BLOB) AS content,external_source,external_id,channel FROM events WHERE deleted_at IS NULL ORDER BY occurred_at DESC,id DESC"
+  ).all();
+  return rows.flatMap((row) => {
+    const fields = {
+      summary: decodeEventText(row.summary),
+      content: row.content === null ? null : decodeEventText(row.content),
+      source: row.external_source,
+      id: row.external_id,
+      channel: row.channel
+    };
+    const folded = Object.entries(fields).map(
+      ([key, value]) => [key, foldSearchText(value ?? "")]
+    );
+    if (!tokens.every((t) => folded.some(([, v]) => v.includes(t))))
+      return [];
+    return [
+      {
+        kind: "event",
+        id: row.id,
+        type: row.type,
+        title: deriveEventSummary(decodeEventText(row.summary)),
+        occurredOn: row.occurred_on ?? new Date(row.occurred_at).toISOString().slice(0, 10),
+        matchedOn: folded.filter(([, v]) => tokens.some((t) => v.includes(t))).map(([k]) => k),
+        ...row.external_source && row.external_id ? {
+          externalRef: {
+            source: row.external_source,
+            id: row.external_id
+          }
+        } : {}
+      }
+    ];
+  }).slice(offset, offset + limit);
+}
+function getEventThread(db, source, id, options) {
+  const { limit, offset } = resolveListLimitOffset(options);
+  const root = getEventByExternalRef(db, source, id);
+  if (!root) return [];
+  const rows = db.prepare(`WITH RECURSIVE thread(id) AS (
+    SELECT ? UNION SELECT e.id FROM events e JOIN thread t JOIN events p ON p.id=t.id
+    WHERE e.deleted_at IS NULL AND (e.parent_event_id=p.id OR (e.parent_source=p.external_source AND e.parent_ref_id=p.external_id) OR (e.thread_source=? AND e.thread_id=?))
+  ) SELECT e.id FROM events e JOIN thread t ON e.id=t.id WHERE e.deleted_at IS NULL AND (? IS NULL OR e.channel=?) ORDER BY e.occurred_at,e.id LIMIT ? OFFSET ?`).all(
+    root.id,
+    root.externalRef?.source ?? null,
+    root.externalRef?.id ?? null,
+    options?.channel ?? null,
+    options?.channel?.trim().toLowerCase() ?? null,
+    limit,
+    offset
+  );
+  return batchLoadEventRecords(
+    db,
+    rows.map((r) => r.id),
+    options?.includeContent ?? false
+  );
+}
+
 // src/graph/get_affinity_chart.ts
 function getAffinityChart(db, options) {
   const contactClauses = [
@@ -7100,21 +8032,6 @@ function listProgressionReadiness(db, filters, options) {
 }
 
 // src/links/list_radar.ts
-function deriveRadarReason(drift, recency, normalizedRank3) {
-  if (drift > 0.5) {
-    return "Significantly overdue for contact";
-  }
-  if (drift > 0.2) {
-    return "Drifting \u2014 approaching overdue";
-  }
-  if (recency < 0.3 && normalizedRank3 > 0.3) {
-    return "Important link losing recency";
-  }
-  if (normalizedRank3 > 0.5 && recency < 0.5) {
-    return "High-rank link needs attention";
-  }
-  return "Routine check-in recommended";
-}
 function listRadar(db, filters, options) {
   assertDefaultOrdering("listRadar", options);
   const ownerId = findOwnerContactId(db);
@@ -7122,7 +8039,10 @@ function listRadar(db, filters, options) {
     return [];
   }
   const now = resolveNow(options?.now);
-  const overdue = `EXISTS (SELECT 1 FROM open_commitments oc JOIN events e ON e.id = oc.event_id JOIN event_participants ep ON ep.event_id = e.id WHERE ep.contact_id = CASE WHEN l.from_contact_id = ${ownerId} THEN l.to_contact_id ELSE l.from_contact_id END AND e.deleted_at IS NULL AND oc.resolved_at IS NULL AND oc.due_at < ${now})`;
+  const today = localCalendarDate(now);
+  const lastContact = `(SELECT MAX(le.occurred_at) FROM link_event_effects le JOIN events ev ON ev.id = le.event_id WHERE le.link_id = l.id AND le.counts_for_recency = 1 AND ev.deleted_at IS NULL AND (le.occurred_at <= ${now} OR ev.occurred_on <= '${today}'))`;
+  const drift = `(${lastContact} IS NOT NULL AND (${now} - ${lastContact}) > 1.5 * COALESCE(l.cadence_days, 1) * 86400000)`;
+  const overdue = `EXISTS (SELECT 1 FROM open_commitments oc JOIN events e ON e.id = oc.event_id JOIN event_participants ep ON ep.event_id = e.id WHERE ep.contact_id = CASE WHEN l.from_contact_id = ${ownerId} THEN l.to_contact_id ELSE l.from_contact_id END AND e.deleted_at IS NULL AND oc.resolved_at IS NULL AND (CASE WHEN oc.due_on IS NOT NULL AND oc.due_at = CAST(strftime('%s', oc.due_on) AS INTEGER) * 1000 + 86399999 THEN oc.due_on < '${today}' ELSE oc.due_at < ${now} END))`;
   const { limit, offset } = resolveListLimitOffset(options);
   const clauses = [
     "l.removed_at IS NULL",
@@ -7147,10 +8067,23 @@ function listRadar(db, filters, options) {
   if (options?.includeObserved === false) {
     clauses.push("l.kind != 'observed'");
   }
+  if (options?.includeDormant !== true)
+    clauses.push("c_to.lifecycle_state != 'dormant'");
+  if (filters?.includeLost !== true)
+    clauses.push("c_to.lifecycle_state != 'lost'");
+  const other = `CASE WHEN l.from_contact_id = ${ownerId} THEN l.to_contact_id ELSE l.from_contact_id END`;
+  clauses.push(`(${lastContact} IS NOT NULL OR ${overdue} OR NOT EXISTS (
+    SELECT 1 FROM event_participants ep JOIN events ev ON ev.id=ep.event_id
+    WHERE ep.contact_id=${other} AND ev.deleted_at IS NULL
+      AND (ev.affects_bond=0 OR (ev.type='observation' AND ev.significance<=2) OR json_extract(ev.provenance_json, '$.ambient')=1 OR ep.directionality='owner_initiated' OR EXISTS (SELECT 1 FROM event_participants op WHERE op.event_id=ev.id AND op.contact_id=${ownerId} AND op.directionality='owner_initiated'))
+  ))`);
   const where = clauses.join(" AND ");
   const rows = db.prepare(
     `SELECT
          l.id,
+         l.cadence_days,
+         ${lastContact} AS last_contact,
+         ${drift} AS drift,
          ${overdue} AS overdue_commitment,
          l.from_contact_id,
          l.to_contact_id,
@@ -7164,23 +8097,44 @@ function listRadar(db, filters, options) {
          AND c_to.deleted_at IS NULL AND c_to.lifecycle_state != 'merged'
        LEFT JOIN link_rollups lr ON lr.link_id = l.id
        WHERE ${where}
-       ORDER BY ${overdue} DESC, COALESCE(lr.radar_score, 0) DESC
+       ORDER BY (${overdue} OR ${drift}) DESC, ${overdue} DESC, COALESCE(lr.radar_score, 0) DESC
        LIMIT ? OFFSET ?`
   ).all(...params, limit, offset);
-  return rows.map((row) => ({
-    linkId: row.id,
-    contactId: row.from_contact_id === ownerId ? row.to_contact_id : row.from_contact_id,
-    reasons: row.overdue_commitment ? ["overdue_commitment"] : [],
-    driftPriority: row.overdue_commitment ? Math.max(1, row.drift_priority ?? 0) : row.drift_priority ?? 0,
-    recencyScore: row.recency_score ?? 0,
-    normalizedRank: row.normalized_rank ?? 0,
-    trust: row.trust ?? 0,
-    recommendedReason: deriveRadarReason(
-      row.drift_priority ?? 0,
-      row.recency_score ?? 0,
-      row.normalized_rank ?? 0
-    )
-  }));
+  return rows.map((row) => {
+    const contactId = row.from_contact_id === ownerId ? row.to_contact_id : row.from_contact_id;
+    const promise = row.overdue_commitment ? db.prepare(
+      `SELECT e.summary, oc.due_at, oc.due_on FROM open_commitments oc JOIN events e ON e.id = oc.event_id JOIN event_participants ep ON ep.event_id = e.id WHERE ep.contact_id = ? AND e.deleted_at IS NULL AND oc.resolved_at IS NULL AND ${OVERDUE_SQL} ORDER BY oc.due_at LIMIT 1`
+    ).get(contactId, today, now) : void 0;
+    const reasons = [
+      ...row.overdue_commitment ? ["overdue_commitment"] : [],
+      ...row.drift ? ["drift"] : []
+    ];
+    const snippets = [
+      ...promise ? [
+        `Overdue promise: ${promise.summary} (due ${promise.due_on ?? new Date(promise.due_at).toISOString().slice(0, 10)})`
+      ] : [],
+      ...row.drift ? [
+        `No contact for ${Math.floor((now - (row.last_contact ?? now)) / 864e5)} days (cadence ${row.cadence_days ?? 1} days)`
+      ] : []
+    ];
+    const elapsed = row.last_contact === null ? null : Math.max(0, (now - row.last_contact) / 864e5);
+    const currentDrift = elapsed === null ? 0 : driftPriority({
+      daysSinceLastMeaningfulEvent: elapsed,
+      cadenceDays: row.cadence_days ?? 1,
+      trust: row.trust ?? 0,
+      rank: row.rank ?? 0
+    });
+    return {
+      linkId: row.id,
+      contactId: row.from_contact_id === ownerId ? row.to_contact_id : row.from_contact_id,
+      reasons,
+      driftPriority: row.overdue_commitment ? Math.max(1, currentDrift) : currentDrift,
+      recencyScore: elapsed === null ? 0 : Math.max(0, 1 - elapsed / Math.max(row.cadence_days ?? 1, 1)),
+      normalizedRank: row.normalized_rank ?? 0,
+      trust: row.trust ?? 0,
+      recommendedReason: snippets.join("; ") || "Routine check-in recommended"
+    };
+  });
 }
 
 // src/merges/get_merge_history.ts
@@ -7250,13 +8204,40 @@ function enrichReviewItem(db, item) {
       result.subtitle = `${item.subtitle} \xB7 ${name(link.from_contact_id)} \xB7 ${name(link.to_contact_id)}`;
   }
   if (Array.isArray(item.participants)) {
-    result.counterpartyNames = item.participants.map(
-      (p) => name(p.contactId)
+    result.participants = item.participants.map(
+      (p) => ({
+        id: p.contactId,
+        name: name(p.contactId),
+        role: p.role
+      })
     );
-    result.subtitle = [
-      item.subtitle,
-      result.counterpartyNames.join(", ")
-    ].filter(Boolean).join(" \xB7 ");
+    for (const key of ["title", "subtitle", "snippet", "state", "eventId"])
+      result[key] = void 0;
+  }
+  if (result.momentKind === null) result.momentKind = void 0;
+  if (result.eventId === result.id) result.eventId = void 0;
+  if (result.linkId === result.id) result.linkId = void 0;
+  if (result.title === result.summary) result.title = void 0;
+  if (item.kind === "link" && item.occursAt !== void 0) {
+    for (const key of [
+      "affinity",
+      "trust",
+      "rank",
+      "recencyScore",
+      "driftPriority",
+      "readinessScore",
+      "normalizedRank",
+      "reciprocityScore",
+      "radarScore",
+      "subtitle",
+      "snippet",
+      "targetRef",
+      "occursOnDate"
+    ])
+      result[key] = void 0;
+  } else if (item.kind === "link") {
+    result.recommendedReason = void 0;
+    result.snippet = void 0;
   }
   if (typeof item.leftContactId === "number")
     result.title = `${name(item.leftContactId)} \xB7 ${name(item.rightContactId)}`;
@@ -7285,6 +8266,8 @@ function summarizeCount(count, singular) {
 // src/tools/review_affinity_tool.ts
 function buildReadOptions(input) {
   return {
+    ...input.includeContent === void 0 ? {} : { includeContent: input.includeContent },
+    ...input.channel === void 0 ? {} : { channel: input.channel },
     ...input.now === void 0 ? {} : { now: input.now },
     ...input.limit === void 0 ? {} : { limit: input.limit },
     ...input.offset === void 0 ? {} : { offset: input.offset },
@@ -7421,7 +8404,7 @@ function momentItem(moment) {
     id: moment.eventId,
     title: moment.summary,
     subtitle: moment.momentKind,
-    snippet: new Date(moment.occurredAt).toISOString().slice(0, 10)
+    snippet: moment.occurredOn ?? new Date(moment.occurredAt).toISOString().slice(0, 10)
   };
 }
 function commitmentItem(commitment) {
@@ -7431,7 +8414,7 @@ function commitmentItem(commitment) {
     id: commitment.eventId,
     title: commitment.summary,
     subtitle: commitment.type,
-    snippet: `state ${commitment.resolutionState}; participants ${commitment.participants.length}; due ${commitment.dueAt == null ? "none" : new Date(commitment.dueAt).toISOString().slice(0, 10)}`
+    snippet: `state ${commitment.resolutionState}; participants ${commitment.participants.length}; due ${commitment.dueAt == null ? "none" : commitment.dueOn ?? new Date(commitment.dueAt).toISOString().slice(0, 10)}`
   };
 }
 function radarItem(radar) {
@@ -7447,6 +8430,7 @@ function radarItem(radar) {
 function upcomingDateItem(date) {
   return {
     ...date,
+    occursOn: new Date(date.occursOn).toISOString().slice(0, 10),
     occursAt: date.occursOn,
     occursAtIso: new Date(date.occursOn).toISOString(),
     kind: date.targetRef.kind,
@@ -7484,6 +8468,9 @@ function compactFilters(input) {
   );
 }
 function reviewAffinityToolHandler(db, rawInput) {
+  return reviewPage(db, rawInput, false);
+}
+function reviewPage(db, rawInput, pageOnly) {
   const input = structuredClone(rawInput);
   const inputError = validateToolInput(reviewAffinityTool.inputSchema, input);
   if (inputError)
@@ -7498,6 +8485,41 @@ function reviewAffinityToolHandler(db, rawInput) {
     if (invalid) {
       return invalid;
     }
+    if (!pageOnly && input.view !== "graph.chart") {
+      const limit = input.limit ?? 50;
+      const offset = input.offset ?? 0;
+      if (!Number.isInteger(limit) || limit < 1 || limit > 250 || !Number.isInteger(offset) || offset < 0)
+        return toolFailure(
+          "protocol",
+          "invalid_input",
+          "Invalid pagination.",
+          "limit must be 1..250; offset must be non-negative"
+        );
+      const all = [];
+      let page;
+      do {
+        page = reviewPage(
+          db,
+          { ...input, limit: 250, offset: all.length },
+          true
+        );
+        if (!page.ok) return page;
+        all.push(...page.data.items);
+      } while (page.data.items.length === 250);
+      const items2 = all.slice(offset, offset + limit);
+      return toolSuccess(
+        summarizeCount(items2.length, "item"),
+        {
+          view: input.view,
+          items: items2,
+          count: items2.length,
+          total: all.length,
+          hasMore: offset + items2.length < all.length,
+          appliedFilters: compactFilters(input)
+        },
+        { entities: items2.map(({ content: _content, ...item }) => item) }
+      );
+    }
     const options = buildReadOptions(input);
     let items = [];
     let chart;
@@ -7529,6 +8551,19 @@ function reviewAffinityToolHandler(db, rawInput) {
           options
         ).map(duplicateCandidateItem);
         break;
+      case "events.thread": {
+        if (!input.ref)
+          return toolFailure(
+            "protocol",
+            "invalid_input",
+            "Missing thread reference.",
+            "ref is required for events.thread."
+          );
+        items = getEventThread(db, input.ref.source, input.ref.id, options).map(
+          toEventListToolItem
+        );
+        break;
+      }
       case "events.contact_journal": {
         const locator = input.contact;
         if (locator === void 0) {
@@ -7670,6 +8705,7 @@ function reviewAffinityToolHandler(db, rawInput) {
         items = listRadar(
           db,
           {
+            ...input.includeLost === void 0 ? {} : { includeLost: input.includeLost },
             ...input.kind === void 0 ? {} : { kind: input.kind },
             ...input.linkState === void 0 ? {} : { state: input.linkState }
           },
@@ -7719,6 +8755,14 @@ function reviewAffinityToolHandler(db, rawInput) {
         items = listDismissedDuplicates(db, options).map(dismissedPairItem);
         break;
     }
+    if (input.includeContent && ["events.moments", "commitments.open"].includes(input.view))
+      items = items.map((item) => {
+        const content = getEventById(
+          db,
+          Number(item.eventId ?? item.id)
+        )?.content;
+        return content === void 0 ? item : { ...item, content };
+      });
     items = items.map((item) => enrichReviewItem(db, item));
     return toolSuccess(
       summarizeCount(items.length, "item"),
@@ -7730,7 +8774,7 @@ function reviewAffinityToolHandler(db, rawInput) {
         ...chart === void 0 ? {} : { chart }
       },
       {
-        entities: items,
+        entities: items.map(({ content: _content, ...item }) => item),
         warnings: items.length === 0 ? [
           toolWarning(
             "empty_result",
@@ -7782,9 +8826,15 @@ var reviewAffinityTool = defineAffinityTool({
   outputDescription: "Returns compact review items, a count, the applied filters, and the chart payload for graph review.",
   inputSchema: objectSchema(
     {
+      ref: externalRefSchema,
+      includeContent: booleanSchema(
+        "Include verbatim content in event rows; defaults to false."
+      ),
+      channel: stringSchema("Filter events by channel."),
       view: enumSchema("Which review surface to return.", [
         "contacts.list",
         "contacts.duplicates",
+        "events.thread",
         "events.contact_journal",
         "events.link_timeline",
         "events.moments",
@@ -7839,7 +8889,20 @@ var reviewAffinityTool = defineAffinityTool({
       includeArchived: booleanSchema("Whether archived links are included."),
       includeObserved: booleanSchema("Whether observed links are included."),
       eventTypes: arraySchema(
-        stringSchema("Event type."),
+        enumSchema("Event type.", [
+          "conversation",
+          "activity",
+          "gift",
+          "support",
+          "milestone",
+          "observation",
+          "conflict",
+          "correction",
+          "transaction",
+          "promise",
+          "agreement",
+          "date_anchor"
+        ]),
         "Optional event-type filter."
       ),
       momentKind: enumSchema("Optional moment kind filter.", [
@@ -7879,7 +8942,7 @@ var reviewAffinityTool = defineAffinityTool({
 
 // src/contacts/search_contacts.ts
 function searchContacts(db, query, filters, options) {
-  const q = foldSearchText(query.trim());
+  const q = foldSearchText(query.trim().replace(/^@/, ""));
   if (!q) return [];
   assertDefaultOrdering("searchContacts", options);
   const { limit, offset } = resolveListLimitOffset(options);
@@ -7899,6 +8962,7 @@ function searchContacts(db, query, filters, options) {
   const tokens = q.split(/\s+/);
   const phone = /^[+\d()\-/.\s]+$/.test(q) && q.replace(/\D/g, "").length >= 3;
   const digits = q.replace(/\D/g, "").replace(/^00/, "");
+  const suffix = digits.replace(/^0/, "");
   const attributeFilters = contactAttributeClauses(filters);
   const clauses = [
     "deleted_at IS NULL",
@@ -7934,7 +8998,7 @@ function searchContacts(db, query, filters, options) {
       )
     ];
     const phoneFields = phone ? values.filter(
-      (field) => field.source === "identity:phone" && field.text.split(" ").join("").replace(/[^\d]/g, "").replace(/^00/, "").includes(digits)
+      (field) => field.source === "identity:phone" && field.text.split(" ").join("").replace(/[^\d]/g, "").replace(/^00/, "").includes(digits) || field.source === "identity:phone" && suffix.length >= 6 && field.text.replace(/\D/g, "").endsWith(suffix)
     ) : [];
     if (!phoneFields.length && !tokens.every(
       (token) => values.some((field) => field.text.includes(token))
@@ -7964,6 +9028,9 @@ function searchContacts(db, query, filters, options) {
 
 // src/tools/search_affinity_tool.ts
 function searchAffinityToolHandler(db, rawInput) {
+  return searchPage(db, rawInput, false);
+}
+function searchPage(db, rawInput, pageOnly) {
   const input = structuredClone(rawInput);
   const inputError = validateToolInput(searchAffinityTool.inputSchema, input);
   if (inputError)
@@ -7974,11 +9041,53 @@ function searchAffinityToolHandler(db, rawInput) {
       inputError
     );
   return withToolHandling(() => {
+    if (!pageOnly) {
+      const limit = input.limit ?? 50;
+      const offset = input.offset ?? 0;
+      if (!Number.isInteger(limit) || limit < 1 || limit > 250 || !Number.isInteger(offset) || offset < 0)
+        return toolFailure(
+          "protocol",
+          "invalid_input",
+          "Invalid pagination.",
+          "limit must be 1..250; offset must be non-negative"
+        );
+      const all = [];
+      const scopes = input.scope === "all" ? ["contacts", "events"] : [input.scope ?? "contacts"];
+      for (const scope of scopes) {
+        let page;
+        let nextOffset = 0;
+        do {
+          page = searchPage(
+            db,
+            { ...input, scope, limit: 250, offset: nextOffset },
+            true
+          );
+          if (!page.ok) return page;
+          all.push(...page.data.items);
+          nextOffset += page.data.count;
+        } while (page.data.count === 250);
+      }
+      const items2 = all.slice(offset, offset + limit);
+      return toolSuccess(
+        summarizeCount(
+          items2.length,
+          input.scope === "events" ? "event" : input.scope === "all" ? "item" : "contact"
+        ),
+        {
+          query: input.query,
+          items: items2,
+          count: items2.length,
+          total: all.length,
+          hasMore: offset + items2.length < all.length
+        },
+        { entities: items2 }
+      );
+    }
     const options = {
       ...input.limit === void 0 ? {} : { limit: input.limit },
       ...input.offset === void 0 ? {} : { offset: input.offset }
     };
-    const rows = searchContacts(
+    const rows = input.scope === "events" ? [] : searchContacts(
       db,
       input.query,
       {
@@ -7992,9 +9101,15 @@ function searchAffinityToolHandler(db, rawInput) {
       },
       options
     );
-    const items = rows.map(toContactListToolItem);
+    const items = [
+      ...rows.map(toContactListToolItem),
+      ...input.scope === "events" || input.scope === "all" ? searchEvents(db, input.query, options) : []
+    ];
     return toolSuccess(
-      summarizeCount(items.length, "contact"),
+      summarizeCount(
+        items.length,
+        input.scope === "events" ? "event" : input.scope === "all" ? "item" : "contact"
+      ),
       {
         query: input.query,
         items,
@@ -8030,6 +9145,11 @@ var searchAffinityTool = defineAffinityTool({
   outputDescription: "Returns compact contact hits, the original query, and the hit count.",
   inputSchema: objectSchema(
     {
+      scope: enumSchema("Search scope; defaults to contacts.", [
+        "contacts",
+        "events",
+        "all"
+      ]),
       query: stringSchema("Free-text or natural-key query."),
       kind: enumSchema("Optional contact kind filter.", [
         "human",
@@ -8081,72 +9201,36 @@ var affinityTools = [
   recordEventTool,
   manageCommitmentTool,
   manageDateAnchorTool,
-  manageAttributeTool
+  manageAttributeTool,
+  manageEventTool
 ];
 
 // src/surface/plain_dates.ts
-function parsePlainDue(raw, now = Date.now(), endOfDay = true) {
-  const invalid = () => new CliUsageError(
-    `Invalid timestamp "${raw}". Use YYYY-MM-DD, DD.MM.YYYY, today, tomorrow, yesterday, +3d, -2d or an ISO date-time.`
-  );
-  if (/^-?\d+$/.test(raw)) {
-    const value = Number(raw);
-    if (Number.isSafeInteger(value) && Number.isFinite(new Date(value).getTime()))
-      return value;
-    throw invalid();
-  }
-  const iso = /^(\d{4})-(\d{2})-(\d{2})$/.exec(raw);
-  const european = /^(\d{2})\.(\d{2})\.(\d{4})$/.exec(raw);
-  let date;
-  if (iso || european) {
-    const year = Number(iso?.[1] ?? european?.[3]);
-    const month = Number(iso?.[2] ?? european?.[2]);
-    const day = Number(iso?.[3] ?? european?.[1]);
-    date = /* @__PURE__ */ new Date(0);
-    date.setFullYear(year, month - 1, day);
-    date.setHours(
-      endOfDay ? 23 : 0,
-      endOfDay ? 59 : 0,
-      endOfDay ? 59 : 0,
-      endOfDay ? 999 : 0
-    );
-    if (date.getFullYear() !== year || date.getMonth() !== month - 1 || date.getDate() !== day)
-      throw invalid();
-  } else if (raw === "today" || raw === "tomorrow" || raw === "yesterday" || /^[+-]\d+d$/.test(raw)) {
-    date = new Date(now);
-    date.setDate(
-      date.getDate() + (raw === "today" ? 0 : raw === "tomorrow" ? 1 : raw === "yesterday" ? -1 : Number(raw.slice(0, -1)))
-    );
-    date.setHours(
-      endOfDay ? 23 : 0,
-      endOfDay ? 59 : 0,
-      endOfDay ? 59 : 0,
-      endOfDay ? 999 : 0
-    );
-  } else {
-    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/.test(
-      raw
-    ))
-      throw invalid();
-    parsePlainDue(raw.slice(0, 10), now);
-    date = new Date(raw);
-  }
-  if (!Number.isFinite(date.getTime())) throw invalid();
-  return date.getTime();
-}
-function parsePlainStart(raw, now = Date.now()) {
-  return parsePlainDue(raw, now, false);
-}
-function normalizeTimeInputs(value, now = Date.now()) {
+function normalizeTimeInputs(value, now = Date.now(), inPatch = false) {
   if (Array.isArray(value))
     return value.map((item) => normalizeTimeInputs(item, now));
   if (!value || typeof value !== "object") return value;
-  return Object.fromEntries(
-    Object.entries(value).map(([key, item]) => [
-      key,
-      typeof item === "string" && (key.endsWith("At") || ["asOf", "now"].includes(key)) ? key === "dueAt" ? parsePlainDue(item, now) : parsePlainStart(item, now) : normalizeTimeInputs(item, now)
-    ])
-  );
+  const result = {};
+  for (const [key, item] of Object.entries(value)) {
+    if (key === "occurredAt" && item === null)
+      throw new CliUsageError(
+        "occurredAt is required (ISO, YYYY-MM-DD, epoch ms, today, +3d \u2026)"
+      );
+    if (typeof item === "string" && (key.endsWith("At") || ["asOf", "now", "since", "until"].includes(key))) {
+      let parsed;
+      try {
+        parsed = parseCalendarTime(item, key, now);
+      } catch (error) {
+        throw new CliUsageError(
+          `Invalid timestamp "${item}". ${error.message}`
+        );
+      }
+      result[key] = parsed.timestamp;
+      if (!inPatch && ["occurredAt", "dueAt"].includes(key))
+        result[key.replace(/At$/, "On")] = parsed.day;
+    } else result[key] = normalizeTimeInputs(item, now, key === "patch");
+  }
+  return result;
 }
 
 // src/surface/timestamp_schema.ts
@@ -8173,20 +9257,57 @@ function timestampSchema(schema) {
 }
 
 // src/surface/affinity_surface_tools.ts
+function surfaceProperties(tool) {
+  return {
+    ...tool.inputSchema.properties,
+    ...["inspect_affinity_item", "review_affinity", "manage_event"].includes(
+      tool.name
+    ) ? {
+      refSource: {
+        type: "string",
+        description: "External reference source."
+      },
+      refId: {
+        type: "string",
+        description: "External reference id."
+      }
+    } : {},
+    ...tool.name === "review_affinity" ? {
+      withContent: {
+        type: "boolean",
+        description: "Include verbatim event content."
+      }
+    } : {}
+  };
+}
 var affinitySurfaceTools = affinityTools.map((tool) => ({
   name: tool.name,
   description: tool.description,
-  whenToUse: tool.whenToUse,
-  ...tool.whenNotToUse === void 0 ? {} : { whenNotToUse: tool.whenNotToUse },
   readOnly: tool.readOnly,
   sideEffects: tool.sideEffects,
   inputSchema: {
-    ...timestampSchema({ ...tool.inputSchema, type: "object" }),
+    ...timestampSchema({
+      ...tool.inputSchema,
+      properties: surfaceProperties(tool),
+      type: "object"
+    }),
     type: "object"
   },
   handler: (db, input) => {
     try {
-      return tool.handler(db, normalizeTimeInputs(input));
+      const { withContent, refSource, refId, ...normalized } = input;
+      if (withContent !== void 0) normalized.includeContent = withContent;
+      if (refSource !== void 0 || refId !== void 0) {
+        if (normalized.ref !== void 0)
+          return toolFailure(
+            "protocol",
+            "invalid_input",
+            "Invalid target.",
+            "Provide ref or ref-source/ref-id, not both."
+          );
+        normalized.ref = { source: refSource, id: refId };
+      }
+      return tool.handler(db, normalizeTimeInputs(normalized));
     } catch (error) {
       if (error instanceof CliUsageError)
         return toolFailure(
@@ -8211,7 +9332,7 @@ function affinityMcpOptions(context) {
     context,
     annotations: (tool) => ({
       readOnlyHint: tool.readOnly ?? false,
-      destructiveHint: tool.name === "merge_contacts" || /remove|unset|undismiss/.test(
+      destructiveHint: tool.name === "merge_contacts" || tool.name === "manage_event" || /remove|unset|undismiss/.test(
         String(tool.inputSchema.properties?.action?.enum ?? [])
       ),
       idempotentHint: tool.readOnly ?? false,
@@ -8220,13 +9341,95 @@ function affinityMcpOptions(context) {
   };
 }
 
+// src/events/init_events_tables.ts
+function initEventsTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      occurred_at INTEGER NOT NULL,
+      summary TEXT NOT NULL,
+      significance REAL NOT NULL DEFAULT 0,
+      moment_kind TEXT,
+      recurrence_kind TEXT,
+      anchor_month INTEGER,
+      anchor_day INTEGER,
+      anchor_contact_id INTEGER REFERENCES contacts (id) ON DELETE CASCADE,
+      anchor_link_id INTEGER REFERENCES links (id) ON DELETE CASCADE,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      deleted_at INTEGER,
+      CHECK (length(trim(summary)) > 0),
+      CHECK (
+        type IN (
+          'conversation', 'activity', 'gift', 'support', 'milestone', 'observation',
+          'conflict', 'correction', 'transaction', 'promise', 'agreement', 'date_anchor'
+        )
+      ),
+      CHECK (
+        (type = 'date_anchor' AND (
+          (anchor_contact_id IS NOT NULL AND anchor_link_id IS NULL)
+          OR (anchor_contact_id IS NULL AND anchor_link_id IS NOT NULL)
+        ))
+        OR (type != 'date_anchor' AND anchor_contact_id IS NULL AND anchor_link_id IS NULL)
+      ),
+      CHECK (moment_kind IS NULL OR moment_kind IN (
+        'breakthrough', 'rupture', 'reconciliation', 'milestone', 'turning_point'
+      )),
+      CHECK (recurrence_kind IS NULL OR recurrence_kind IN (
+        'birthday', 'anniversary', 'renewal', 'memorial', 'custom_yearly'
+      )),
+      CHECK (anchor_month IS NULL OR (anchor_month >= 1 AND anchor_month <= 12)),
+      CHECK (anchor_day IS NULL OR (anchor_day >= 1 AND anchor_day <= 31))
+    )
+  `);
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_events_occurred_at ON events(occurred_at DESC) WHERE deleted_at IS NULL"
+  );
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_events_type ON events(type) WHERE deleted_at IS NULL"
+  );
+  const columns = db.prepare("PRAGMA table_info(events)").all();
+  if (!columns.some((c) => c.name === "declared_moment_kind"))
+    db.exec("ALTER TABLE events ADD COLUMN declared_moment_kind TEXT");
+  if (!columns.some((c) => c.name === "affects_bond"))
+    db.exec("ALTER TABLE events ADD COLUMN affects_bond INTEGER");
+  if (!columns.some((c) => c.name === "content"))
+    db.exec("ALTER TABLE events ADD COLUMN content TEXT");
+  if (!columns.some((c) => c.name === "external_source"))
+    db.exec("ALTER TABLE events ADD COLUMN external_source TEXT");
+  if (!columns.some((c) => c.name === "external_id"))
+    db.exec("ALTER TABLE events ADD COLUMN external_id TEXT");
+  if (!columns.some((c) => c.name === "channel"))
+    db.exec("ALTER TABLE events ADD COLUMN channel TEXT");
+  if (!columns.some((c) => c.name === "parent_source"))
+    db.exec("ALTER TABLE events ADD COLUMN parent_source TEXT");
+  if (!columns.some((c) => c.name === "parent_ref_id"))
+    db.exec("ALTER TABLE events ADD COLUMN parent_ref_id TEXT");
+  if (!columns.some((c) => c.name === "parent_event_id"))
+    db.exec("ALTER TABLE events ADD COLUMN parent_event_id INTEGER");
+  if (!columns.some((c) => c.name === "thread_source"))
+    db.exec("ALTER TABLE events ADD COLUMN thread_source TEXT");
+  if (!columns.some((c) => c.name === "thread_id"))
+    db.exec("ALTER TABLE events ADD COLUMN thread_id TEXT");
+  if (!columns.some((c) => c.name === "provenance_json"))
+    db.exec("ALTER TABLE events ADD COLUMN provenance_json TEXT");
+  db.exec(
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_events_external_ref ON events(external_source, external_id)"
+  );
+  if (!columns.some((column) => column.name === "occurred_on"))
+    db.exec("ALTER TABLE events ADD COLUMN occurred_on TEXT");
+}
+
 // src/attributes/init_attributes_tables.ts
 function initAttributesTables(db) {
+  initEventsTables(db);
   db.exec(`
     CREATE TABLE IF NOT EXISTS attributes (
       id INTEGER PRIMARY KEY AUTOINCREMENT,
       contact_id INTEGER REFERENCES contacts (id) ON DELETE CASCADE,
       link_id INTEGER REFERENCES links (id) ON DELETE CASCADE,
+      event_id INTEGER REFERENCES events (id) ON DELETE CASCADE,
       name TEXT NOT NULL,
       value TEXT,
       created_at INTEGER NOT NULL,
@@ -8234,15 +9437,35 @@ function initAttributesTables(db) {
       deleted_at INTEGER,
       CHECK (length(trim(name)) > 0),
       CHECK (
-        (contact_id IS NOT NULL AND link_id IS NULL)
-        OR
-        (contact_id IS NULL AND link_id IS NOT NULL)
+        (contact_id IS NOT NULL) + (link_id IS NOT NULL) + (event_id IS NOT NULL) = 1
       )
     )
   `);
+  const columns = db.prepare("PRAGMA table_info(attributes)").all();
+  if (!columns.some((c) => c.name === "event_id")) {
+    withTransaction(
+      db,
+      () => db.exec(`CREATE TABLE attributes_upgrade (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      contact_id INTEGER REFERENCES contacts(id) ON DELETE CASCADE,
+      link_id INTEGER REFERENCES links(id) ON DELETE CASCADE,
+      event_id INTEGER REFERENCES events(id) ON DELETE CASCADE,
+      name TEXT NOT NULL CHECK(length(trim(name)) > 0), value TEXT,
+      created_at INTEGER NOT NULL, updated_at INTEGER NOT NULL, deleted_at INTEGER,
+      CHECK ((contact_id IS NOT NULL) + (link_id IS NOT NULL) + (event_id IS NOT NULL) = 1)
+    );
+    INSERT INTO attributes_upgrade (id,contact_id,link_id,name,value,created_at,updated_at,deleted_at)
+      SELECT id,contact_id,link_id,name,value,created_at,updated_at,deleted_at FROM attributes;
+    DROP TABLE attributes;
+    ALTER TABLE attributes_upgrade RENAME TO attributes;`)
+    );
+  }
   db.exec(
     "CREATE INDEX IF NOT EXISTS idx_attributes_contact ON attributes(contact_id) WHERE deleted_at IS NULL"
   );
+  db.exec(
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_attributes_event_name_live ON attributes(event_id,name) WHERE deleted_at IS NULL AND event_id IS NOT NULL"
+  );
   db.exec(
     "CREATE INDEX IF NOT EXISTS idx_attributes_link ON attributes(link_id) WHERE deleted_at IS NULL"
   );
@@ -8355,56 +9578,6 @@ function initEventParticipantsTables(db) {
   );
 }
 
-// src/events/init_events_tables.ts
-function initEventsTables(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      type TEXT NOT NULL,
-      occurred_at INTEGER NOT NULL,
-      summary TEXT NOT NULL,
-      significance REAL NOT NULL DEFAULT 0,
-      moment_kind TEXT,
-      recurrence_kind TEXT,
-      anchor_month INTEGER,
-      anchor_day INTEGER,
-      anchor_contact_id INTEGER REFERENCES contacts (id) ON DELETE CASCADE,
-      anchor_link_id INTEGER REFERENCES links (id) ON DELETE CASCADE,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      deleted_at INTEGER,
-      CHECK (length(trim(summary)) > 0),
-      CHECK (
-        type IN (
-          'conversation', 'activity', 'gift', 'support', 'milestone', 'observation',
-          'conflict', 'correction', 'transaction', 'promise', 'agreement', 'date_anchor'
-        )
-      ),
-      CHECK (
-        (type = 'date_anchor' AND (
-          (anchor_contact_id IS NOT NULL AND anchor_link_id IS NULL)
-          OR (anchor_contact_id IS NULL AND anchor_link_id IS NOT NULL)
-        ))
-        OR (type != 'date_anchor' AND anchor_contact_id IS NULL AND anchor_link_id IS NULL)
-      ),
-      CHECK (moment_kind IS NULL OR moment_kind IN (
-        'breakthrough', 'rupture', 'reconciliation', 'milestone', 'turning_point'
-      )),
-      CHECK (recurrence_kind IS NULL OR recurrence_kind IN (
-        'birthday', 'anniversary', 'renewal', 'memorial', 'custom_yearly'
-      )),
-      CHECK (anchor_month IS NULL OR (anchor_month >= 1 AND anchor_month <= 12)),
-      CHECK (anchor_day IS NULL OR (anchor_day >= 1 AND anchor_day <= 31))
-    )
-  `);
-  db.exec(
-    "CREATE INDEX IF NOT EXISTS idx_events_occurred_at ON events(occurred_at DESC) WHERE deleted_at IS NULL"
-  );
-  db.exec(
-    "CREATE INDEX IF NOT EXISTS idx_events_type ON events(type) WHERE deleted_at IS NULL"
-  );
-}
-
 // src/events/init_open_commitments_tables.ts
 function initOpenCommitmentsTables(db) {
   db.exec(`
@@ -8424,6 +9597,9 @@ function initOpenCommitmentsTables(db) {
       )
     )
   `);
+  const columns = db.prepare("PRAGMA table_info(open_commitments)").all();
+  if (!columns.some((column) => column.name === "due_on"))
+    db.exec("ALTER TABLE open_commitments ADD COLUMN due_on TEXT");
 }
 
 // src/identities/init_identities_tables.ts
@@ -8488,6 +9664,21 @@ function initLinkEventEffectsTables(db) {
   db.exec(
     "CREATE INDEX IF NOT EXISTS idx_link_event_effects_link_time ON link_event_effects(link_id, occurred_at DESC, event_id DESC)"
   );
+  for (const name of ["participant_json", "provenance_json"])
+    if (!columns.some((c) => c.name === name))
+      db.exec(`ALTER TABLE link_event_effects ADD COLUMN ${name} TEXT`);
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS event_link_baselines (link_id INTEGER PRIMARY KEY REFERENCES links(id) ON DELETE CASCADE, state_json TEXT NOT NULL)"
+  );
+  db.exec(
+    "CREATE TABLE IF NOT EXISTS event_link_state_changes (id INTEGER PRIMARY KEY AUTOINCREMENT, link_id INTEGER NOT NULL REFERENCES links(id) ON DELETE CASCADE, after_event_id INTEGER NOT NULL, state TEXT NOT NULL)"
+  );
+  db.exec(`INSERT OR IGNORE INTO event_link_baselines(link_id,state_json)
+    SELECT l.id,json_object('rank',l.rank-COALESCE(SUM(e.rank_delta),0),'affinity',l.affinity-COALESCE(SUM(e.affinity_delta),0),'trust',l.trust-COALESCE(SUM(e.trust_delta),0),'state','active','cadence_days',NULL)
+    FROM links l JOIN link_event_effects e ON e.link_id=l.id GROUP BY l.id`);
+  db.exec(
+    "UPDATE link_event_effects SET counts_for_recency = 0 WHERE event_id IN (SELECT id FROM events WHERE type IN ('promise', 'agreement'))"
+  );
   db.exec(
     "CREATE INDEX IF NOT EXISTS idx_link_event_effects_moment ON link_event_effects(moment_kind, occurred_at DESC, impact_score DESC) WHERE moment_kind IS NOT NULL"
   );
@@ -8663,7 +9854,10 @@ async function openAffinityDb(path) {
   } finally {
     process.emitWarning = original;
   }
-  if (path !== ":memory:") mkdirSync(dirname(path), { recursive: true });
+  if (path !== ":memory:" && !path.startsWith("file:")) {
+    mkdirSync(dirname(path), { recursive: true, mode: 448 });
+    if (!existsSync(path)) closeSync(openSync(path, "wx", 384));
+  }
   const db = new sqlite.DatabaseSync(path);
   try {
     db.exec("PRAGMA journal_mode=WAL; PRAGMA busy_timeout=5000;");
@@ -8687,6 +9881,13 @@ function isErrorResult(result) {
 
 // src/surfaces/validate_input.ts
 function validateInput(schema, input, path = "$") {
+  if (path.endsWith(".occurredAt") && input == null)
+    return ["occurredAt is required (ISO, YYYY-MM-DD, epoch ms, today, +3d \u2026)"];
+  const branches = schema.oneOf ?? schema.anyOf;
+  if (path.endsWith(".value") && branches?.some((b) => b.type === "string") && branches.some((b) => b.type === "null") && input !== null && typeof input !== "string")
+    return [
+      `attribute values are strings or null; pass "${String(input)}" to store it as text`
+    ];
   const errors = [];
   const matchesType = (type) => {
     switch (type) {
@@ -8717,6 +9918,10 @@ function validateInput(schema, input, path = "$") {
     (branch) => validateInput(branch, input, path).length === 0
   ))
     errors.push(`${path}: must match at least one schema branch`);
+  if (schema.anyOf && !schema.anyOf.some(
+    (branch) => validateInput(branch, input, path).length === 0
+  ))
+    errors.push(`${path}: must match at least one schema branch`);
   if (typeof input === "object" && input !== null && !Array.isArray(input)) {
     const record = input;
     for (const name of schema.required ?? [])