@ghostpaw/affinity 0.5.0 → 0.6.1

package/dist/mcp-server.js

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-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';
 
@@ -29,6 +29,13 @@ var init_surface_types = __esm({
 
 // 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) {
@@ -59,6 +66,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 ?? [])
@@ -285,7 +296,7 @@ var init_mcp_stdio = __esm({
 var affinityVersion;
 var init_version = __esm({
   "src/version.ts"() {
-    affinityVersion = "0.5.0";
+    affinityVersion = "0.6.1";
   }
 });
 
@@ -415,6 +426,174 @@ var init_affinity_not_found_error = __esm({
   }
 });
 
+// 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
+  };
+}
+var init_normalize_mutation_receipt = __esm({
+  "src/lib/normalize_mutation_receipt.ts"() {
+  }
+});
+
+// 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
+  };
+}
+var init_receipts = __esm({
+  "src/events/receipts.ts"() {
+    init_normalize_mutation_receipt();
+  }
+});
+
+// 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
+    }));
+}
+var init_event_metadata = __esm({
+  "src/events/event_metadata.ts"() {
+    init_affinity_validation_error();
+    init_loaders();
+    init_receipts();
+  }
+});
+
 // src/contacts/queries.ts
 function getContactRowById(db, id) {
   const row = db.prepare(
@@ -484,8 +663,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;
@@ -548,6 +730,7 @@ var init_validators = __esm({
     init_affinity_not_found_error();
     init_affinity_state_error();
     init_affinity_validation_error();
+    init_event_metadata();
     PARTICIPANT_ROLES = /* @__PURE__ */ new Set([
       "actor",
       "recipient",
@@ -578,11 +761,27 @@ 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.provenance_json != null)
+    base.provenance = JSON.parse(row.provenance_json);
+  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;
@@ -612,10 +811,14 @@ 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");
+}
 var init_mappers = __esm({
   "src/events/mappers.ts"() {
     init_affinity_invariant_error();
@@ -626,17 +829,17 @@ var init_mappers = __esm({
 // 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;
@@ -686,6 +889,7 @@ function findDuplicateDateAnchor(db, params) {
 }
 var init_queries2 = __esm({
   "src/events/queries.ts"() {
+    init_mappers();
   }
 });
 
@@ -708,19 +912,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
@@ -744,7 +956,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;
@@ -787,6 +1001,7 @@ var init_loaders = __esm({
   "src/events/loaders.ts"() {
     init_affinity_invariant_error();
     init_affinity_not_found_error();
+    init_event_metadata();
     init_mappers();
     init_queries2();
   }
@@ -811,6 +1026,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
@@ -821,7 +1040,8 @@ 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
   );
 }
 var init_get_contact_journal = __esm({
@@ -832,6 +1052,73 @@ var init_get_contact_journal = __esm({
   }
 });
 
+// src/lib/parse_calendar_time.ts
+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;
+}
+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";
+  }
+  text = text.replace(
+    /\.(\d{4,})(?=Z|[+-]\d{2}:\d{2}$)/,
+    (_, digits) => `.${digits.slice(0, 3)}`
+  );
+  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);
+  if (!Number.isFinite(timestamp)) return fail();
+  return { timestamp, day };
+}
+var timeInputForms, OVERDUE_SQL;
+var init_parse_calendar_time = __esm({
+  "src/lib/parse_calendar_time.ts"() {
+    init_affinity_validation_error();
+    timeInputForms = "epoch milliseconds integer, ISO 8601 date-time with Z/offset, YYYY-MM-DD, DD.MM.YYYY, today, tomorrow, yesterday, +3d or -2d";
+    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)";
+  }
+});
+
 // src/resolve_now.ts
 function resolveNow(now) {
   if (now !== void 0) {
@@ -904,9 +1191,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
@@ -923,7 +1214,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)
   }));
 }
@@ -931,6 +1223,7 @@ var DAY_MS;
 var init_list_open_commitments = __esm({
   "src/events/list_open_commitments.ts"() {
     init_affinity_validation_error();
+    init_parse_calendar_time();
     init_assert_default_ordering();
     init_resolve_list_limit_offset();
     init_resolve_now();
@@ -1008,8 +1301,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);
@@ -1023,6 +1318,7 @@ function computeNextAnchorOccursOn(params) {
 }
 var init_calendar = __esm({
   "src/dates/calendar.ts"() {
+    init_parse_calendar_time();
   }
 });
 
@@ -1240,7 +1536,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);
@@ -1283,7 +1585,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()
@@ -1351,6 +1666,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
@@ -1358,6 +1677,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
@@ -1370,6 +1690,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
   }));
@@ -1469,6 +1790,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
@@ -1480,7 +1805,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
   );
 }
 var init_get_link_timeline = __esm({
@@ -1664,26 +1990,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) {
@@ -1793,6 +2127,7 @@ var DAY_MS2;
 var init_rollups2 = __esm({
   "src/links/rollups.ts"() {
     init_rollups();
+    init_parse_calendar_time();
     init_mechanics();
     init_queries3();
     DAY_MS2 = 864e5;
@@ -1855,41 +2190,12 @@ var init_get_link_detail = __esm({
 
 // src/tools/parse_time_input.ts
 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;
 }
-var timeInputForms;
 var init_parse_time_input = __esm({
   "src/tools/parse_time_input.ts"() {
-    init_affinity_validation_error();
-    timeInputForms = "epoch milliseconds integer, ISO 8601 date-time with Z/offset, YYYY-MM-DD, today, tomorrow, yesterday, +3d or -2d";
+    init_parse_calendar_time();
+    init_parse_calendar_time();
   }
 });
 
@@ -1966,8 +2272,47 @@ var init_tool_metadata = __esm({
   }
 });
 
+// src/tools/event_metadata_schema.ts
+var externalRefSchema, eventMetadataSchema;
+var init_event_metadata_schema = __esm({
+  "src/tools/event_metadata_schema.ts"() {
+    init_tool_metadata();
+    externalRefSchema = objectSchema(
+      {
+        source: stringSchema("External source; trimmed and lowercased."),
+        id: stringSchema("Non-empty external id.")
+      },
+      ["source", "id"]
+    );
+    eventMetadataSchema = {
+      affectsBond: booleanSchema(
+        "Whether evidence affects the relationship; defaults false for like/follow/repost labels and observations with significance <=2; explicit true opts in."
+      ),
+      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, reviewAffinityToolName, inspectAffinityItemToolName, manageContactToolName, mergeContactsToolName, manageDuplicateDismissalToolName, manageIdentityToolName, manageRelationshipToolName, recordEventToolName, manageCommitmentToolName, manageDateAnchorToolName, manageAttributeToolName;
+var searchAffinityToolName, reviewAffinityToolName, inspectAffinityItemToolName, manageContactToolName, mergeContactsToolName, manageDuplicateDismissalToolName, manageIdentityToolName, manageRelationshipToolName, recordEventToolName, manageCommitmentToolName, manageDateAnchorToolName, manageAttributeToolName, manageEventToolName;
 var init_tool_names = __esm({
   "src/tools/tool_names.ts"() {
     searchAffinityToolName = "search_affinity";
@@ -1982,6 +2327,7 @@ var init_tool_names = __esm({
     manageCommitmentToolName = "manage_commitment";
     manageDateAnchorToolName = "manage_date_anchor";
     manageAttributeToolName = "manage_attribute";
+    manageEventToolName = "manage_event";
   }
 });
 
@@ -2028,7 +2374,7 @@ function toEventEntityRef(value) {
   return {
     kind: "event",
     id: value.id,
-    title: value.summary,
+    title: deriveEventSummary(value.summary),
     subtitle: value.type,
     state: value.type
   };
@@ -2063,21 +2409,48 @@ function toReceiptEntityRefs(receipt) {
 }
 var init_tool_ref = __esm({
   "src/tools/tool_ref.ts"() {
+    init_event_metadata();
   }
 });
 
 // src/identities/normalize.ts
+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;
+}
+var handleIdentityTypes;
 var init_normalize = __esm({
   "src/identities/normalize.ts"() {
     init_affinity_validation_error();
+    handleIdentityTypes = /* @__PURE__ */ new Set([
+      "handle",
+      "bluesky",
+      "x",
+      "twitter",
+      "mastodon",
+      "github",
+      "instagram",
+      "telegram",
+      "linkedin",
+      "facebook",
+      "youtube",
+      "tiktok",
+      "discord",
+      "slack"
+    ]);
   }
 });
 
@@ -2210,7 +2583,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 };
@@ -2235,9 +2608,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,
@@ -2388,13 +2765,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);
@@ -2443,27 +2828,32 @@ var init_tool_resolvers = __esm({
 });
 
 // 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(
@@ -2478,11 +2868,21 @@ 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
           );
+          if (!path.endsWith(".patch") && ["occurredAt", "dueAt"].includes(key) && typeof object[key] === "string" && /\.\d{4,}/.test(object[key])) {
+            const provenance = object.provenance;
+            object.provenance = {
+              ...provenance && typeof provenance === "object" ? provenance : {},
+              [`raw${key[0]?.toUpperCase()}${key.slice(1)}`]: object[key]
+            };
+          }
+          object[key] = parsed.timestamp;
+          if (!path.endsWith(".patch") && ["occurredAt", "dueAt"].includes(key))
+            object[key.replace(/At$/, "On")] ??= parsed.day;
         } catch (error) {
           return error.message;
         }
@@ -2497,8 +2897,9 @@ function validateToolInput(schema, value, path = "input", injectedNow = Date.now
       const error = validateToolInput(
         child,
         object[key],
-        `${path}.${key}`,
-        referenceNow
+        key === "input" && path === "input" ? path : `${path}.${key}`,
+        referenceNow,
+        strict
       );
       if (error) return error;
     }
@@ -2511,7 +2912,8 @@ function validateToolInput(schema, value, path = "input", injectedNow = Date.now
         schema.items ?? {},
         item,
         `${path}[${index}]`,
-        injectedNow
+        injectedNow,
+        strict
       );
       if (error) return error;
     }
@@ -2529,6 +2931,7 @@ function validateToolInput(schema, value, path = "input", injectedNow = Date.now
 }
 var init_validate_tool_input = __esm({
   "src/tools/validate_tool_input.ts"() {
+    init_parse_calendar_time();
     init_parse_time_input();
   }
 });
@@ -2582,6 +2985,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,
@@ -2664,7 +3087,9 @@ var init_inspect_affinity_item_tool = __esm({
   "src/tools/inspect_affinity_item_tool.ts"() {
     init_get_contact_profile();
     init_get_owner_profile();
+    init_event_metadata();
     init_get_link_detail();
+    init_event_metadata_schema();
     init_tool_metadata();
     init_tool_names();
     init_tool_ref();
@@ -2692,10 +3117,13 @@ var init_inspect_affinity_item_tool = __esm({
       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."
           ),
@@ -2716,6 +3144,7 @@ var init_inspect_affinity_item_tool = __esm({
 // 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,
@@ -2731,6 +3160,7 @@ var init_helpers = __esm({
 // 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,
@@ -2744,131 +3174,46 @@ var init_mappers5 = __esm({
 });
 
 // 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);
 }
 var init_queries4 = __esm({
   "src/attributes/queries.ts"() {
   }
 });
 
-// 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
-  };
-}
-var init_normalize_mutation_receipt = __esm({
-  "src/lib/normalize_mutation_receipt.ts"() {
-  }
-});
-
-// 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
-  };
-}
-var init_receipts = __esm({
+var init_receipts2 = __esm({
   "src/attributes/receipts.ts"() {
     init_normalize_mutation_receipt();
   }
@@ -2931,11 +3276,14 @@ 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;
 }
 var init_normalize2 = __esm({
   "src/attributes/normalize.ts"() {
+    init_affinity_validation_error();
   }
 });
 
@@ -2963,6 +3311,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) {
@@ -3009,26 +3362,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), {
@@ -3054,11 +3395,12 @@ var init_replace_attributes = __esm({
     init_helpers();
     init_mappers5();
     init_queries4();
-    init_receipts();
+    init_receipts2();
     init_validators3();
     init_affinity_invariant_error();
     init_resolve_now();
     init_with_transaction();
+    init_queries4();
   }
 });
 
@@ -3070,6 +3412,11 @@ function setAttribute(db, target, name, value) {
     const stored = normalizeAttributeValue(value);
     const now = resolveNow();
     const existing = getLiveAttributeRow(db, target, key);
+    if (existing?.value === stored)
+      return buildAttributeMutationReceipt(
+        mapAttributeRowToAttributeRecord(existing),
+        {}
+      );
     if (existing) {
       db.prepare(
         "UPDATE attributes SET value = ?, updated_at = ? WHERE id = ?"
@@ -3085,27 +3432,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) {
@@ -3124,11 +3454,12 @@ var init_set_attribute = __esm({
     init_mappers5();
     init_normalize2();
     init_queries4();
-    init_receipts();
+    init_receipts2();
     init_validators3();
     init_affinity_invariant_error();
     init_resolve_now();
     init_with_transaction();
+    init_queries4();
   }
 });
 
@@ -3155,7 +3486,7 @@ var init_unset_attribute = __esm({
   "src/attributes/unset_attribute.ts"() {
     init_mappers5();
     init_queries4();
-    init_receipts();
+    init_receipts2();
     init_validators3();
     init_affinity_not_found_error();
     init_resolve_now();
@@ -3184,14 +3515,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
   });
 }
 function describeChanges(receipt) {
@@ -3255,6 +3587,30 @@ function linkLocatorSchema2(description) {
   };
 }
 function resolveAttributeTarget(db, target) {
+  if (target.kind === "event") {
+    if (target.eventId === void 0 === (target.ref === void 0))
+      return {
+        kind: "error",
+        result: toolFailure(
+          "protocol",
+          "invalid_input",
+          "Invalid event target.",
+          "Provide exactly one of target.eventId or target.ref."
+        )
+      };
+    const eventId = target.eventId ?? (target.ref && getEventByExternalRef(db, target.ref.source, target.ref.id)?.id);
+    if (eventId === void 0)
+      return {
+        kind: "error",
+        result: toolFailure(
+          "domain",
+          "not_found",
+          "Event not found.",
+          "No event matches target.ref."
+        )
+      };
+    return { kind: "ok", target: { kind: "event", eventId } };
+  }
   if (target.kind === "contact") {
     const contact = resolveContactLocator(db, target.contact, "target.contact");
     if (!contact.ok) {
@@ -3318,6 +3674,8 @@ var init_manage_attribute_tool = __esm({
     init_replace_attributes();
     init_set_attribute();
     init_unset_attribute();
+    init_event_metadata();
+    init_event_metadata_schema();
     init_tool_metadata();
     init_tool_mutation();
     init_tool_names();
@@ -3326,7 +3684,7 @@ var init_manage_attribute_tool = __esm({
     init_validate_tool_input();
     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",
@@ -3347,7 +3705,9 @@ var init_manage_attribute_tool = __esm({
           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; provide eventId or ref."),
+              ref: externalRefSchema,
               contact: contactLocatorSchema2(
                 "Contact locator. Required when kind=contact. Provide contactId or identity."
               ),
@@ -3377,7 +3737,7 @@ var init_manage_attribute_tool = __esm({
           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
     });
@@ -3387,7 +3747,7 @@ var init_manage_attribute_tool = __esm({
 // 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,
@@ -3404,6 +3764,35 @@ 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 || ["activity", "milestone", "observation"].includes(params.type) && /^(?:follow(?:ed|ing)?|like(?:d)?|repost(?:ed)?)(?:\b|[-_])/i.test(
+      summary
+    ) && !/^follow[ -]up\b/i.test(summary) ? 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
@@ -3446,6 +3835,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
@@ -3469,29 +3862,11 @@ var init_persistence = __esm({
   "src/events/persistence.ts"() {
     init_affinity_invariant_error();
     init_resolve_now();
+    init_event_metadata();
     init_queries2();
   }
 });
 
-// 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
-  };
-}
-var init_receipts2 = __esm({
-  "src/events/receipts.ts"() {
-    init_normalize_mutation_receipt();
-  }
-});
-
 // src/graph/betweenness.ts
 function computeNodeBetweenness(adjacency) {
   const nodes = [...adjacency.keys()];
@@ -4104,6 +4479,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";
   }
@@ -4133,6 +4510,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;
@@ -4177,7 +4566,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(
@@ -4218,15 +4607,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
@@ -4246,7 +4636,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,
@@ -4289,7 +4683,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);
@@ -4323,6 +4725,7 @@ var init_effects = __esm({
     init_calendar();
     init_mechanics2();
     init_affinity_state_error();
+    init_parse_calendar_time();
     init_mechanics();
     init_queries3();
     init_rollups2();
@@ -4337,6 +4740,7 @@ var init_affinity_conflict_error = __esm({
   "src/lib/errors/affinity_conflict_error.ts"() {
     init_affinity_error();
     AffinityConflictError = class extends AffinityError {
+      existingContactId;
       code = "CONFLICT";
     };
   }
@@ -4403,6 +4807,8 @@ var init_receipts3 = __esm({
 // 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");
     }
@@ -4410,11 +4816,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"
       );
@@ -4534,15 +4943,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;
       }
@@ -4550,13 +4980,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);
@@ -4591,7 +5022,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
       })
@@ -4624,6 +5058,8 @@ var init_apply_journal_event_mechanics = __esm({
 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"
@@ -4638,11 +5074,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
     });
@@ -4651,15 +5088,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,
@@ -4672,12 +5119,13 @@ var init_record_commitment = __esm({
     init_queries();
     init_loaders();
     init_persistence();
-    init_receipts2();
+    init_receipts();
     init_validators();
     init_affinity_validation_error();
     init_resolve_now();
     init_with_transaction();
     init_apply_journal_event_mechanics();
+    init_event_metadata();
   }
 });
 
@@ -4746,6 +5194,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,
@@ -4762,6 +5211,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,
@@ -4800,7 +5250,7 @@ var init_resolve_commitment = __esm({
     init_loaders();
     init_persistence();
     init_queries2();
-    init_receipts2();
+    init_receipts();
     init_validators();
     init_affinity_conflict_error();
     init_affinity_invariant_error();
@@ -4839,7 +5289,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",
@@ -4869,6 +5325,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(
@@ -4887,6 +5358,7 @@ var init_manage_commitment_tool = __esm({
     init_queries();
     init_record_commitment();
     init_resolve_commitment();
+    init_event_metadata_schema();
     init_tool_metadata();
     init_tool_mutation();
     init_tool_names();
@@ -4919,15 +5391,21 @@ var init_manage_commitment_tool = __esm({
                 "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."
                     ),
@@ -4940,13 +5418,7 @@ var init_manage_commitment_tool = __esm({
               ),
               now: integerSchema("Optional timestamp override.")
             },
-            [
-              "commitmentType",
-              "occurredAt",
-              "summary",
-              "significance",
-              "participants"
-            ],
+            ["commitmentType", "occurredAt", "significance", "participants"],
             "Commitment payload. Required when action=record."
           ),
           commitmentEventId: integerSchema(
@@ -4961,6 +5433,19 @@ var init_manage_commitment_tool = __esm({
               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."),
@@ -5054,30 +5539,50 @@ var init_delete_contact = __esm({
   }
 });
 
-// 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;
   });
+}
+var init_export_rows = __esm({
+  "src/contacts/export_rows.ts"() {
+  }
+});
+
+// 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.*, COALESCE(e.parent_event_id, (SELECT parent.id FROM events parent WHERE parent.external_source=e.parent_source AND parent.external_id=e.parent_ref_id AND parent.deleted_at IS NULL)) AS parent_event_id, 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
@@ -5121,22 +5626,46 @@ function exportContact(db, id) {
 var init_export_contact = __esm({
   "src/contacts/export_contact.ts"() {
     init_affinity_not_found_error();
+    init_export_rows();
   }
 });
 
 // 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)
+    }))
   };
 }
 var init_export_affinity = __esm({
   "src/contacts/export_affinity.ts"() {
     init_export_contact();
+    init_export_rows();
   }
 });
 
@@ -5227,7 +5756,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) {
@@ -5300,97 +5829,18 @@ var init_set_contact_lifecycle = __esm({
   }
 });
 
-// src/contacts/create_contact.ts
-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 }]
-    });
-  });
-}
-var KINDS;
-var init_create_contact = __esm({
-  "src/contacts/create_contact.ts"() {
-    init_mappers4();
-    init_queries();
-    init_receipts4();
-    init_rollups();
-    init_affinity_conflict_error();
-    init_affinity_invariant_error();
-    init_affinity_validation_error();
-    init_resolve_now();
-    init_with_transaction();
-    KINDS = /* @__PURE__ */ new Set([
-      "human",
-      "group",
-      "company",
-      "team",
-      "pet",
-      "service",
-      "other"
-    ]);
-  }
-});
-
-// 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");
-}
-var init_fold_search_text = __esm({
-  "src/contacts/fold_search_text.ts"() {
-  }
-});
-
-// src/identities/queries.ts
-function getIdentityRowById(db, id) {
-  const row = db.prepare(
-    `SELECT id, contact_id, type, value, label, normalized_key, verified, verified_at,
-              created_at, updated_at, removed_at
-       FROM identities
-       WHERE id = ? AND removed_at IS NULL`
-  ).get(id);
-  if (row === void 0) {
-    return null;
-  }
-  return row;
+// src/identities/queries.ts
+function getIdentityRowById(db, id) {
+  const row = db.prepare(
+    `SELECT id, contact_id, type, value, label, normalized_key, verified, verified_at,
+              created_at, updated_at, removed_at
+       FROM identities
+       WHERE id = ? AND removed_at IS NULL`
+  ).get(id);
+  if (row === void 0) {
+    return null;
+  }
+  return row;
 }
 var init_queries5 = __esm({
   "src/identities/queries.ts"() {
@@ -5419,14 +5869,19 @@ var init_receipts5 = __esm({
 // 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}`
     );
@@ -5435,12 +5890,25 @@ function assertNoIdentityCollision(db, normalizedKey, excludeIdentityId) {
 var init_validators5 = __esm({
   "src/identities/validators.ts"() {
     init_affinity_conflict_error();
+    init_normalize();
   }
 });
 
 // src/identities/validate_identity_input.ts
-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)`
@@ -5471,7 +5939,10 @@ var identityTypes;
 var init_validate_identity_input = __esm({
   "src/identities/validate_identity_input.ts"() {
     init_affinity_validation_error();
+    init_normalize();
     identityTypes = [
+      "did",
+      "atproto_did",
       "email",
       "phone",
       "url",
@@ -5512,12 +5983,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;
@@ -5569,31 +6055,266 @@ var init_add_identity = __esm({
   }
 });
 
-// src/tools/create_contact_tool_result.ts
-function createContactToolResult(db, input) {
+// src/contacts/create_contact.ts
+function createContact(db, input) {
   return withTransaction(db, () => {
-    const receipt = createContact(db, input);
-    const identityOwners = /* @__PURE__ */ new Set();
-    for (const identity of input.identities ?? []) {
+    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 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));
+        "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;
+  });
+}
+var KINDS;
+var init_create_contact = __esm({
+  "src/contacts/create_contact.ts"() {
+    init_mappers4();
+    init_queries();
+    init_receipts4();
+    init_rollups();
+    init_add_identity();
+    init_normalize();
+    init_validate_identity_input();
+    init_affinity_conflict_error();
+    init_affinity_invariant_error();
+    init_affinity_validation_error();
+    init_resolve_now();
+    init_with_transaction();
+    KINDS = /* @__PURE__ */ new Set([
+      "human",
+      "group",
+      "company",
+      "team",
+      "pet",
+      "service",
+      "other"
+    ]);
+  }
+});
+
+// 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");
+}
+var init_fold_search_text = __esm({
+  "src/contacts/fold_search_text.ts"() {
+  }
+});
+
+// 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 added = addIdentity(db, receipt.primary.id, identity);
-      receipt.created.push(...added.created);
+      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);
+}
+var init_list_duplicate_candidates = __esm({
+  "src/contacts/list_duplicate_candidates.ts"() {
+    init_assert_default_ordering();
+    init_resolve_list_limit_offset();
+  }
+});
+
+// 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})`,
@@ -5610,9 +6331,7 @@ var init_create_contact_tool_result = __esm({
   "src/tools/create_contact_tool_result.ts"() {
     init_create_contact();
     init_fold_search_text();
-    init_add_identity();
-    init_normalize();
-    init_validate_identity_input();
+    init_list_duplicate_candidates();
     init_with_transaction();
     init_tool_mutation();
   }
@@ -5687,6 +6406,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",
@@ -5776,7 +6502,11 @@ var init_manage_contact_tool = __esm({
                   },
                   ["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.", [
@@ -5900,7 +6630,7 @@ var init_add_date_anchor = __esm({
     init_loaders();
     init_persistence();
     init_queries2();
-    init_receipts2();
+    init_receipts();
     init_validators();
     init_affinity_conflict_error();
     init_affinity_not_found_error();
@@ -5932,7 +6662,7 @@ var init_remove_date_anchor = __esm({
   "src/dates/remove_date_anchor.ts"() {
     init_loaders();
     init_mappers();
-    init_receipts2();
+    init_receipts();
     init_resolve_now();
     init_with_transaction();
     init_upcoming_occurrences();
@@ -6001,7 +6731,7 @@ var init_revise_date_anchor = __esm({
   "src/dates/revise_date_anchor.ts"() {
     init_loaders();
     init_queries2();
-    init_receipts2();
+    init_receipts();
     init_validators();
     init_affinity_conflict_error();
     init_affinity_validation_error();
@@ -6414,67 +7144,362 @@ function manageDuplicateDismissalToolHandler(db, rawInput) {
           ]
         }
       );
-    }
-    const receipt = undismissDuplicate(db, left.value.id, right.value.id);
-    return toolSuccess(
-      `Un-dismissed pair #${receipt.primary.leftContactId} / #${receipt.primary.rightContactId}.`,
-      {
-        ...receipt,
-        action: "undismiss",
-        changes: existed ? [
-          {
-            entity: "duplicate_dismissal",
-            leftContactId,
-            rightContactId,
-            action: "removed"
-          }
-        ] : []
-      }
+    }
+    const receipt = undismissDuplicate(db, left.value.id, right.value.id);
+    return toolSuccess(
+      `Un-dismissed pair #${receipt.primary.leftContactId} / #${receipt.primary.rightContactId}.`,
+      {
+        ...receipt,
+        action: "undismiss",
+        changes: existed ? [
+          {
+            entity: "duplicate_dismissal",
+            leftContactId,
+            rightContactId,
+            action: "removed"
+          }
+        ] : []
+      }
+    );
+  }, "Duplicate dismissal failed.");
+}
+var manageDuplicateDismissalTool;
+var init_manage_duplicate_dismissal_tool = __esm({
+  "src/tools/manage_duplicate_dismissal_tool.ts"() {
+    init_dismiss_duplicate();
+    init_undismiss_duplicate();
+    init_tool_metadata();
+    init_tool_names();
+    init_tool_resolvers();
+    init_tool_types();
+    init_tool_types();
+    init_validate_tool_input();
+    manageDuplicateDismissalTool = defineAffinityTool({
+      name: manageDuplicateDismissalToolName,
+      description: "Dismiss or un-dismiss a duplicate candidate pair so it does not resurface in review_affinity contacts.duplicates.",
+      whenToUse: "Use dismiss after confirming two contacts are different people (not duplicates). Use undismiss to re-surface a pair for re-evaluation.",
+      whenNotToUse: "Do not use this to merge contacts \u2014 use merge_contacts for confirmed duplicates.",
+      sideEffects: "writes_state",
+      readOnly: false,
+      supportsClarification: true,
+      targetKinds: ["contact"],
+      inputDescriptions: {
+        action: "dismiss to suppress the pair; undismiss to re-surface it.",
+        left: "One contact of the pair.",
+        right: "The other contact of the pair.",
+        reason: "Optional reason for the dismissal (audit trail)."
+      },
+      outputDescription: "Returns the dismissal receipt with the canonical pair identifiers.",
+      inputSchema: objectSchema(
+        {
+          action: enumSchema("Action to perform.", ["dismiss", "undismiss"]),
+          left: contactLocatorSchema5(
+            "Left contact. Provide contactId or identity."
+          ),
+          right: contactLocatorSchema5(
+            "Right contact. Provide contactId or identity."
+          ),
+          reason: nullableStringSchema("Optional reason for the dismissal.")
+        },
+        ["action", "left", "right"],
+        "Dismiss or un-dismiss a duplicate candidate pair."
+      ),
+      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);
+}
+var init_event_replay = __esm({
+  "src/events/event_replay.ts"() {
+    init_bridge_scores();
+    init_effects();
+    init_rollups2();
+    init_loaders();
+  }
+});
+
+// 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
     );
-  }, "Duplicate dismissal failed.");
+    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
+    });
+  });
 }
-var manageDuplicateDismissalTool;
-var init_manage_duplicate_dismissal_tool = __esm({
-  "src/tools/manage_duplicate_dismissal_tool.ts"() {
-    init_dismiss_duplicate();
-    init_undismiss_duplicate();
+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
+    });
+  });
+}
+var init_manage_event = __esm({
+  "src/events/manage_event.ts"() {
+    init_affinity_conflict_error();
+    init_affinity_not_found_error();
+    init_affinity_validation_error();
+    init_with_transaction();
+    init_event_metadata();
+    init_event_replay();
+    init_receipts();
+    init_validators();
+  }
+});
+
+// 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;
+var init_manage_event_tool = __esm({
+  "src/tools/manage_event_tool.ts"() {
+    init_manage_event();
+    init_event_metadata_schema();
     init_tool_metadata();
+    init_tool_mutation();
     init_tool_names();
     init_tool_resolvers();
     init_tool_types();
-    init_tool_types();
     init_validate_tool_input();
-    manageDuplicateDismissalTool = defineAffinityTool({
-      name: manageDuplicateDismissalToolName,
-      description: "Dismiss or un-dismiss a duplicate candidate pair so it does not resurface in review_affinity contacts.duplicates.",
-      whenToUse: "Use dismiss after confirming two contacts are different people (not duplicates). Use undismiss to re-surface a pair for re-evaluation.",
-      whenNotToUse: "Do not use this to merge contacts \u2014 use merge_contacts for confirmed duplicates.",
+    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: true,
-      targetKinds: ["contact"],
+      supportsClarification: false,
+      targetKinds: ["event"],
       inputDescriptions: {
-        action: "dismiss to suppress the pair; undismiss to re-surface it.",
-        left: "One contact of the pair.",
-        right: "The other contact of the pair.",
-        reason: "Optional reason for the dismissal (audit trail)."
+        action: "revise or delete",
+        eventId: "Exact event id",
+        ref: "External event reference",
+        patch: "Fields to revise",
+        confirm: "Required true for deletion"
       },
-      outputDescription: "Returns the dismissal receipt with the canonical pair identifiers.",
+      outputDescription: "Event mutation receipt and affected links.",
       inputSchema: objectSchema(
         {
-          action: enumSchema("Action to perform.", ["dismiss", "undismiss"]),
-          left: contactLocatorSchema5(
-            "Left contact. Provide contactId or identity."
-          ),
-          right: contactLocatorSchema5(
-            "Right contact. Provide contactId or identity."
-          ),
-          reason: nullableStringSchema("Optional reason for the dismissal.")
+          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", "left", "right"],
-        "Dismiss or un-dismiss a duplicate candidate pair."
+        ["action"]
       ),
-      handler: manageDuplicateDismissalToolHandler
+      handler: manageEventToolHandler
     });
   }
 });
@@ -6539,7 +7564,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");
     }
@@ -6626,6 +7654,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).`
           ),
@@ -6736,6 +7768,10 @@ var init_manage_identity_tool = __esm({
           ),
           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).`
               ),
@@ -6799,6 +7835,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);
@@ -7523,6 +8562,8 @@ var init_merge_contacts_tool = __esm({
 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");
     }
@@ -7532,11 +8573,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
     });
@@ -7544,12 +8586,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
@@ -7562,12 +8616,14 @@ var init_record_interaction = __esm({
     init_queries();
     init_loaders();
     init_persistence();
-    init_receipts2();
+    init_receipts();
     init_validators();
     init_affinity_validation_error();
+    init_parse_calendar_time();
     init_resolve_now();
     init_with_transaction();
     init_apply_journal_event_mechanics();
+    init_event_metadata();
     ALLOWED = /* @__PURE__ */ new Set([
       "conversation",
       "activity",
@@ -7583,17 +8639,20 @@ var init_record_interaction = __esm({
 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
     });
@@ -7601,12 +8660,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
@@ -7618,11 +8689,13 @@ var init_record_milestone = __esm({
     init_queries();
     init_loaders();
     init_persistence();
-    init_receipts2();
+    init_receipts();
     init_validators();
+    init_parse_calendar_time();
     init_resolve_now();
     init_with_transaction();
     init_apply_journal_event_mechanics();
+    init_event_metadata();
   }
 });
 
@@ -7630,15 +8703,18 @@ var init_record_milestone = __esm({
 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
     });
@@ -7646,12 +8722,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
@@ -7662,11 +8750,13 @@ var init_record_observation = __esm({
   "src/events/record_observation.ts"() {
     init_loaders();
     init_persistence();
-    init_receipts2();
+    init_receipts();
     init_validators();
+    init_parse_calendar_time();
     init_resolve_now();
     init_with_transaction();
     init_apply_journal_event_mechanics();
+    init_event_metadata();
   }
 });
 
@@ -7674,17 +8764,20 @@ var init_record_observation = __esm({
 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
     });
@@ -7692,12 +8785,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
@@ -7709,20 +8814,24 @@ var init_record_transaction = __esm({
     init_queries();
     init_loaders();
     init_persistence();
-    init_receipts2();
+    init_receipts();
     init_validators();
+    init_parse_calendar_time();
     init_resolve_now();
     init_with_transaction();
     init_apply_journal_event_mechanics();
+    init_event_metadata();
   }
 });
 
 // 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,
@@ -7740,12 +8849,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",
@@ -7798,6 +8913,7 @@ var init_record_event_tool = __esm({
     init_record_milestone();
     init_record_observation();
     init_record_transaction();
+    init_event_metadata_schema();
     init_tool_metadata();
     init_tool_mutation();
     init_tool_names();
@@ -7839,6 +8955,7 @@ var init_record_event_tool = __esm({
                   "correction"
                 ]
               ),
+              ...eventMetadataSchema,
               occurredAt: integerSchema(
                 "When the event occurred, Unix timestamp in milliseconds."
               ),
@@ -7847,6 +8964,19 @@ var init_record_event_tool = __esm({
               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."
                     ),
@@ -7870,7 +9000,7 @@ var init_record_event_tool = __esm({
               ),
               now: integerSchema("Optional timestamp override.")
             },
-            ["occurredAt", "summary", "significance", "participants"],
+            ["occurredAt", "significance", "participants"],
             "Event payload. Always required. Interaction events also require `type`."
           )
         },
@@ -7888,7 +9018,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
@@ -7949,143 +9082,16 @@ function listContacts(db, filters, options) {
     const item = mapContactRowToContactListItem(r);
     return {
       ...item,
-      primaryIdentity: r.primary_identity ?? null
-    };
-  });
-}
-var init_list_contacts = __esm({
-  "src/contacts/list_contacts.ts"() {
-    init_assert_default_ordering();
-    init_resolve_list_limit_offset();
-    init_contact_attribute_clauses();
-    init_mappers4();
-  }
-});
-
-// 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);
+      primaryIdentity: r.primary_identity ?? null
+    };
+  });
 }
-var init_list_duplicate_candidates = __esm({
-  "src/contacts/list_duplicate_candidates.ts"() {
+var init_list_contacts = __esm({
+  "src/contacts/list_contacts.ts"() {
     init_assert_default_ordering();
     init_resolve_list_limit_offset();
+    init_contact_attribute_clauses();
+    init_mappers4();
   }
 });
 
@@ -8113,12 +9119,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);
   }
@@ -8170,9 +9176,9 @@ var init_list_upcoming_dates = __esm({
     init_mappers();
     init_validators();
     init_affinity_validation_error();
+    init_parse_calendar_time();
     init_assert_default_ordering();
     init_resolve_list_limit_offset();
-    init_calendar();
     CONTACT_KINDS = /* @__PURE__ */ new Set([
       "human",
       "group",
@@ -8185,6 +9191,79 @@ var init_list_upcoming_dates = __esm({
   }
 });
 
+// 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=?) AND (? IS NULL OR e.type IN (SELECT value FROM json_each(?))) 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,
+    options?.eventTypes === void 0 ? null : JSON.stringify(options.eventTypes),
+    options?.eventTypes === void 0 ? null : JSON.stringify(options.eventTypes),
+    limit,
+    offset
+  );
+  return batchLoadEventRecords(
+    db,
+    rows.map((r) => r.id),
+    options?.includeContent ?? false
+  );
+}
+var init_event_discovery = __esm({
+  "src/events/event_discovery.ts"() {
+    init_fold_search_text();
+    init_resolve_list_limit_offset();
+    init_event_metadata();
+    init_loaders();
+    init_mappers();
+  }
+});
+
 // src/graph/get_affinity_chart.ts
 function getAffinityChart(db, options) {
   const contactClauses = [
@@ -8397,21 +9476,6 @@ var init_list_progression_readiness = __esm({
 });
 
 // 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);
@@ -8419,7 +9483,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",
@@ -8444,10 +9511,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,
@@ -8461,30 +9541,53 @@ 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"
+    };
+  });
 }
 var init_list_radar = __esm({
   "src/links/list_radar.ts"() {
     init_queries();
+    init_parse_calendar_time();
     init_assert_default_ordering();
     init_resolve_list_limit_offset();
     init_resolve_now();
+    init_mechanics();
   }
 });
 
@@ -8567,13 +9670,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)}`;
@@ -8610,6 +9740,8 @@ var init_tool_summary = __esm({
 // 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 },
@@ -8746,7 +9878,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) {
@@ -8756,7 +9888,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) {
@@ -8772,6 +9904,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,
@@ -8809,6 +9942,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)
@@ -8823,6 +9959,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 > 1e4 || !Number.isInteger(offset) || offset < 0)
+        return toolFailure(
+          "protocol",
+          "invalid_input",
+          "Invalid pagination.",
+          "limit must be 1..10000; use offset to page through larger results; 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;
@@ -8848,12 +10019,26 @@ function reviewAffinityToolHandler(db, rawInput) {
           {
             ...input.contactIds === void 0 ? {} : { contactIds: input.contactIds },
             ...input.exactOnly === void 0 ? {} : { exactOnly: input.exactOnly },
-            ...input.minScore === void 0 ? {} : { minScore: input.minScore },
+            ...input.minScore === void 0 ? { minScore: 0.5 } : { minScore: input.minScore },
             ...input.includeDismissed === void 0 ? {} : { includeDismissed: input.includeDismissed }
           },
           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,
+          ...input.eventTypes === void 0 ? {} : { eventTypes: input.eventTypes }
+        }).map(toEventListToolItem);
+        break;
+      }
       case "events.contact_journal": {
         const locator = input.contact;
         if (locator === void 0) {
@@ -8995,6 +10180,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 }
           },
@@ -9044,6 +10230,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"),
@@ -9055,7 +10249,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",
@@ -9072,6 +10266,8 @@ var init_review_affinity_tool = __esm({
     init_list_contacts();
     init_list_duplicate_candidates();
     init_list_upcoming_dates();
+    init_event_discovery();
+    init_event_metadata();
     init_get_contact_journal();
     init_list_moments();
     init_list_open_commitments();
@@ -9084,6 +10280,7 @@ var init_review_affinity_tool = __esm({
     init_get_merge_history();
     init_list_dismissed_duplicates();
     init_enrich_review_item();
+    init_event_metadata_schema();
     init_tool_metadata();
     init_tool_names();
     init_tool_ref();
@@ -9127,15 +10324,21 @@ var init_review_affinity_tool = __esm({
         includeDismissed: "Whether dismissed pairs should be included in duplicate review (marked with dismissed flag).",
         since: "Optional lower timestamp bound for time-based views.",
         until: "Optional upper timestamp bound for time-based views.",
-        limit: "Optional result limit.",
+        limit: "Optional result limit, 1..10000 (default 50); use offset for paging.",
         offset: "Optional result offset."
       },
       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",
@@ -9190,7 +10393,20 @@ var init_review_affinity_tool = __esm({
           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.", [
@@ -9213,13 +10429,17 @@ var init_review_affinity_tool = __esm({
           ]),
           horizonDays: integerSchema("Optional horizon-days filter."),
           exactOnly: booleanSchema("Whether duplicate review is exact-only."),
-          minScore: numberSchema("Optional duplicate minimum score."),
+          minScore: numberSchema(
+            "Optional duplicate minimum score (default 0.5; use 0 for all candidates)."
+          ),
           includeDismissed: booleanSchema(
             "Whether dismissed pairs are included in duplicate review (marked with dismissed flag)."
           ),
           since: integerSchema("Optional lower timestamp bound."),
           until: integerSchema("Optional upper timestamp bound."),
-          limit: integerSchema("Optional result limit."),
+          limit: integerSchema(
+            "Optional result limit, 1..10000 (default 50); use offset for paging."
+          ),
           offset: integerSchema("Optional result offset.")
         },
         ["view"],
@@ -9232,7 +10452,7 @@ var init_review_affinity_tool = __esm({
 
 // 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);
@@ -9252,6 +10472,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",
@@ -9287,7 +10508,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))
@@ -9326,6 +10547,9 @@ var init_search_contacts = __esm({
 
 // 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)
@@ -9336,11 +10560,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,
       {
@@ -9354,9 +10620,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,
@@ -9372,6 +10644,7 @@ var searchAffinityTool;
 var init_search_affinity_tool = __esm({
   "src/tools/search_affinity_tool.ts"() {
     init_search_contacts();
+    init_event_discovery();
     init_tool_metadata();
     init_tool_names();
     init_tool_ref();
@@ -9404,6 +10677,11 @@ var init_search_affinity_tool = __esm({
       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",
@@ -9454,6 +10732,7 @@ var init_tool_registry = __esm({
     init_manage_contact_tool();
     init_manage_date_anchor_tool();
     init_manage_duplicate_dismissal_tool();
+    init_manage_event_tool();
     init_manage_identity_tool();
     init_manage_relationship_tool();
     init_merge_contacts_tool();
@@ -9472,77 +10751,50 @@ var init_tool_registry = __esm({
       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}`
+        );
+      }
+      if (!inPatch && ["occurredAt", "dueAt"].includes(key) && typeof item === "string" && /\.\d{4,}/.test(item)) {
+        const provenance = result.provenance ?? value.provenance;
+        result.provenance = {
+          ...provenance && typeof provenance === "object" ? provenance : {},
+          [`raw${key[0]?.toUpperCase()}${key.slice(1)}`]: item
+        };
+      }
+      result[key] = parsed.timestamp;
+      if (!inPatch && ["occurredAt", "dueAt"].includes(key))
+        result[key.replace(/At$/, "On")] = parsed.day;
+    } else if (key !== "provenance" || result.provenance === void 0)
+      result[key] = key === "provenance" ? item : normalizeTimeInputs(item, now, key === "patch");
+  }
+  return result;
 }
 var init_plain_dates = __esm({
   "src/surface/plain_dates.ts"() {
+    init_parse_calendar_time();
     init_cli_args();
   }
 });
@@ -9575,6 +10827,35 @@ var init_timestamp_schema = __esm({
 });
 
 // src/surface/affinity_surface_tools.ts
+function surfaceProperties(tool) {
+  return {
+    ...tool.inputSchema.properties,
+    ...tool.name === "review_affinity" ? {
+      includeContent: {
+        type: "boolean",
+        description: "Deprecated alias for --with-content; includes verbatim event content."
+      }
+    } : {},
+    ...["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;
 var init_affinity_surface_tools = __esm({
   "src/surface/affinity_surface_tools.ts"() {
@@ -9586,17 +10867,31 @@ var init_affinity_surface_tools = __esm({
     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(
@@ -9623,7 +10918,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,
@@ -9639,13 +10934,99 @@ var init_affinity_mcp_options = __esm({
   }
 });
 
+// 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");
+}
+var init_init_events_tables = __esm({
+  "src/events/init_events_tables.ts"() {
+  }
+});
+
 // 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,
@@ -9653,15 +11034,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"
   );
@@ -9678,6 +11079,8 @@ function initAttributesTables(db) {
 }
 var init_init_attributes_tables = __esm({
   "src/attributes/init_attributes_tables.ts"() {
+    init_init_events_tables();
+    init_with_transaction();
   }
 });
 
@@ -9794,60 +11197,6 @@ var init_init_event_participants_tables = __esm({
   }
 });
 
-// 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"
-  );
-}
-var init_init_events_tables = __esm({
-  "src/events/init_events_tables.ts"() {
-  }
-});
-
 // src/events/init_open_commitments_tables.ts
 function initOpenCommitmentsTables(db) {
   db.exec(`
@@ -9867,6 +11216,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");
 }
 var init_init_open_commitments_tables = __esm({
   "src/events/init_open_commitments_tables.ts"() {
@@ -9939,6 +11291,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"
   );
@@ -10149,12 +11516,15 @@ 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;");
+    db.exec("PRAGMA busy_timeout=5000; PRAGMA journal_mode=WAL;");
     const context = db;
-    initAffinityTables(context);
+    withTransaction(context, () => initAffinityTables(context));
     return context;
   } catch (error) {
     db.close();
@@ -10164,6 +11534,7 @@ async function openAffinityDb(path) {
 var init_open_affinity_db = __esm({
   "src/surface/open_affinity_db.ts"() {
     init_init_affinity_tables();
+    init_with_transaction();
   }
 });
 function resolveAffinityDbPath(options = {}) {