@ghostpaw/affinity 0.5.0 → 0.6.1

package/dist/index.js

@@ -4,13 +4,130 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/events/init_events_tables.ts
+function initEventsTables(db) {
+  db.exec(`
+    CREATE TABLE IF NOT EXISTS events (
+      id INTEGER PRIMARY KEY AUTOINCREMENT,
+      type TEXT NOT NULL,
+      occurred_at INTEGER NOT NULL,
+      summary TEXT NOT NULL,
+      significance REAL NOT NULL DEFAULT 0,
+      moment_kind TEXT,
+      recurrence_kind TEXT,
+      anchor_month INTEGER,
+      anchor_day INTEGER,
+      anchor_contact_id INTEGER REFERENCES contacts (id) ON DELETE CASCADE,
+      anchor_link_id INTEGER REFERENCES links (id) ON DELETE CASCADE,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      deleted_at INTEGER,
+      CHECK (length(trim(summary)) > 0),
+      CHECK (
+        type IN (
+          'conversation', 'activity', 'gift', 'support', 'milestone', 'observation',
+          'conflict', 'correction', 'transaction', 'promise', 'agreement', 'date_anchor'
+        )
+      ),
+      CHECK (
+        (type = 'date_anchor' AND (
+          (anchor_contact_id IS NOT NULL AND anchor_link_id IS NULL)
+          OR (anchor_contact_id IS NULL AND anchor_link_id IS NOT NULL)
+        ))
+        OR (type != 'date_anchor' AND anchor_contact_id IS NULL AND anchor_link_id IS NULL)
+      ),
+      CHECK (moment_kind IS NULL OR moment_kind IN (
+        'breakthrough', 'rupture', 'reconciliation', 'milestone', 'turning_point'
+      )),
+      CHECK (recurrence_kind IS NULL OR recurrence_kind IN (
+        'birthday', 'anniversary', 'renewal', 'memorial', 'custom_yearly'
+      )),
+      CHECK (anchor_month IS NULL OR (anchor_month >= 1 AND anchor_month <= 12)),
+      CHECK (anchor_day IS NULL OR (anchor_day >= 1 AND anchor_day <= 31))
+    )
+  `);
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_events_occurred_at ON events(occurred_at DESC) WHERE deleted_at IS NULL"
+  );
+  db.exec(
+    "CREATE INDEX IF NOT EXISTS idx_events_type ON events(type) WHERE deleted_at IS NULL"
+  );
+  const columns = db.prepare("PRAGMA table_info(events)").all();
+  if (!columns.some((c) => c.name === "declared_moment_kind"))
+    db.exec("ALTER TABLE events ADD COLUMN declared_moment_kind TEXT");
+  if (!columns.some((c) => c.name === "affects_bond"))
+    db.exec("ALTER TABLE events ADD COLUMN affects_bond INTEGER");
+  if (!columns.some((c) => c.name === "content"))
+    db.exec("ALTER TABLE events ADD COLUMN content TEXT");
+  if (!columns.some((c) => c.name === "external_source"))
+    db.exec("ALTER TABLE events ADD COLUMN external_source TEXT");
+  if (!columns.some((c) => c.name === "external_id"))
+    db.exec("ALTER TABLE events ADD COLUMN external_id TEXT");
+  if (!columns.some((c) => c.name === "channel"))
+    db.exec("ALTER TABLE events ADD COLUMN channel TEXT");
+  if (!columns.some((c) => c.name === "parent_source"))
+    db.exec("ALTER TABLE events ADD COLUMN parent_source TEXT");
+  if (!columns.some((c) => c.name === "parent_ref_id"))
+    db.exec("ALTER TABLE events ADD COLUMN parent_ref_id TEXT");
+  if (!columns.some((c) => c.name === "parent_event_id"))
+    db.exec("ALTER TABLE events ADD COLUMN parent_event_id INTEGER");
+  if (!columns.some((c) => c.name === "thread_source"))
+    db.exec("ALTER TABLE events ADD COLUMN thread_source TEXT");
+  if (!columns.some((c) => c.name === "thread_id"))
+    db.exec("ALTER TABLE events ADD COLUMN thread_id TEXT");
+  if (!columns.some((c) => c.name === "provenance_json"))
+    db.exec("ALTER TABLE events ADD COLUMN provenance_json TEXT");
+  db.exec(
+    "CREATE UNIQUE INDEX IF NOT EXISTS idx_events_external_ref ON events(external_source, external_id)"
+  );
+  if (!columns.some((column) => column.name === "occurred_on"))
+    db.exec("ALTER TABLE events ADD COLUMN occurred_on TEXT");
+}
+
+// src/with_transaction.ts
+var transactionDepth = /* @__PURE__ */ new WeakMap();
+function withTransaction(db, fn) {
+  const depth = transactionDepth.get(db) ?? 0;
+  const savepoint = `affinity_${String(depth)}`;
+  if (depth === 0) {
+    db.exec("BEGIN IMMEDIATE");
+  } else {
+    db.exec(`SAVEPOINT ${savepoint}`);
+  }
+  transactionDepth.set(db, depth + 1);
+  try {
+    const result = fn();
+    if (depth === 0) {
+      db.exec("COMMIT");
+    } else {
+      db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+    }
+    transactionDepth.set(db, depth);
+    return result;
+  } catch (error) {
+    try {
+      if (depth === 0) {
+        db.exec("ROLLBACK");
+      } else {
+        db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
+        db.exec(`RELEASE SAVEPOINT ${savepoint}`);
+      }
+    } catch {
+    }
+    transactionDepth.set(db, depth);
+    throw error;
+  }
+}
+
 // 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,
@@ -18,15 +135,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"
   );
@@ -139,56 +276,6 @@ function initEventParticipantsTables(db) {
   );
 }
 
-// src/events/init_events_tables.ts
-function initEventsTables(db) {
-  db.exec(`
-    CREATE TABLE IF NOT EXISTS events (
-      id INTEGER PRIMARY KEY AUTOINCREMENT,
-      type TEXT NOT NULL,
-      occurred_at INTEGER NOT NULL,
-      summary TEXT NOT NULL,
-      significance REAL NOT NULL DEFAULT 0,
-      moment_kind TEXT,
-      recurrence_kind TEXT,
-      anchor_month INTEGER,
-      anchor_day INTEGER,
-      anchor_contact_id INTEGER REFERENCES contacts (id) ON DELETE CASCADE,
-      anchor_link_id INTEGER REFERENCES links (id) ON DELETE CASCADE,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL,
-      deleted_at INTEGER,
-      CHECK (length(trim(summary)) > 0),
-      CHECK (
-        type IN (
-          'conversation', 'activity', 'gift', 'support', 'milestone', 'observation',
-          'conflict', 'correction', 'transaction', 'promise', 'agreement', 'date_anchor'
-        )
-      ),
-      CHECK (
-        (type = 'date_anchor' AND (
-          (anchor_contact_id IS NOT NULL AND anchor_link_id IS NULL)
-          OR (anchor_contact_id IS NULL AND anchor_link_id IS NOT NULL)
-        ))
-        OR (type != 'date_anchor' AND anchor_contact_id IS NULL AND anchor_link_id IS NULL)
-      ),
-      CHECK (moment_kind IS NULL OR moment_kind IN (
-        'breakthrough', 'rupture', 'reconciliation', 'milestone', 'turning_point'
-      )),
-      CHECK (recurrence_kind IS NULL OR recurrence_kind IN (
-        'birthday', 'anniversary', 'renewal', 'memorial', 'custom_yearly'
-      )),
-      CHECK (anchor_month IS NULL OR (anchor_month >= 1 AND anchor_month <= 12)),
-      CHECK (anchor_day IS NULL OR (anchor_day >= 1 AND anchor_day <= 31))
-    )
-  `);
-  db.exec(
-    "CREATE INDEX IF NOT EXISTS idx_events_occurred_at ON events(occurred_at DESC) WHERE deleted_at IS NULL"
-  );
-  db.exec(
-    "CREATE INDEX IF NOT EXISTS idx_events_type ON events(type) WHERE deleted_at IS NULL"
-  );
-}
-
 // src/events/init_open_commitments_tables.ts
 function initOpenCommitmentsTables(db) {
   db.exec(`
@@ -208,6 +295,9 @@ function initOpenCommitmentsTables(db) {
       )
     )
   `);
+  const columns = db.prepare("PRAGMA table_info(open_commitments)").all();
+  if (!columns.some((column) => column.name === "due_on"))
+    db.exec("ALTER TABLE open_commitments ADD COLUMN due_on TEXT");
 }
 
 // src/identities/init_identities_tables.ts
@@ -272,6 +362,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"
   );
@@ -455,6 +560,7 @@ var AffinityError = class extends Error {
 
 // src/lib/errors/affinity_conflict_error.ts
 var AffinityConflictError = class extends AffinityError {
+  existingContactId;
   code = "CONFLICT";
 };
 
@@ -524,6 +630,9 @@ __export(read_exports, {
   getAffinityChart: () => getAffinityChart,
   getContactJournal: () => getContactJournal,
   getContactProfile: () => getContactProfile,
+  getEventByExternalRef: () => getEventByExternalRef,
+  getEventById: () => getEventById,
+  getEventThread: () => getEventThread,
   getLinkDetail: () => getLinkDetail,
   getLinkTimeline: () => getLinkTimeline,
   getLinksBetween: () => getLinksBetween,
@@ -539,7 +648,8 @@ __export(read_exports, {
   listProgressionReadiness: () => listProgressionReadiness,
   listRadar: () => listRadar,
   listUpcomingDates: () => listUpcomingDates,
-  searchContacts: () => searchContacts
+  searchContacts: () => searchContacts,
+  searchEvents: () => searchEvents
 });
 
 // src/contacts/mappers.ts
@@ -727,6 +837,104 @@ function refreshContactRollup(db, contactId, now) {
   ).run(contactId, warnings.length, JSON.stringify(warnings), "{}", now);
 }
 
+// src/identities/mappers.ts
+function mapIdentityRowToIdentityRecord(row) {
+  return {
+    id: row.id,
+    contactId: row.contact_id,
+    type: row.type,
+    value: row.value,
+    label: row.label,
+    verified: row.verified === 1,
+    verifiedAt: row.verified_at
+  };
+}
+
+// src/identities/normalize.ts
+var handleIdentityTypes = /* @__PURE__ */ new Set([
+  "handle",
+  "bluesky",
+  "x",
+  "twitter",
+  "mastodon",
+  "github",
+  "instagram",
+  "telegram",
+  "linkedin",
+  "facebook",
+  "youtube",
+  "tiktok",
+  "discord",
+  "slack"
+]);
+function normalizeIdentityValue(type, value) {
+  const v = value.trim();
+  return handleIdentityTypes.has(type.toLowerCase()) ? v.replace(/^@/, "").toLowerCase() : v;
+}
+function normalizeIdentityKey(type, value) {
+  let t = type.trim().toLowerCase();
+  if (["did", "atproto_did", "custom:atproto-did"].includes(t)) t = "did";
+  const v = normalizeIdentityValue(t, value).toLowerCase();
+  if (t.length === 0 || v.length === 0) {
+    throw new AffinityValidationError("type and value must be non-empty");
+  }
+  return `${t}:${v}`;
+}
+function legacyIdentityKey(key) {
+  const colon = key.indexOf(":");
+  return handleIdentityTypes.has(key.slice(0, colon)) ? `${key.slice(0, colon + 1)}@${key.slice(colon + 1)}` : key;
+}
+
+// src/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/receipts.ts
+function buildIdentityMutationReceipt(primary, partial) {
+  const normalized = normalizeMutationReceiptPartial(partial);
+  return {
+    primary,
+    created: normalized.created,
+    updated: normalized.updated,
+    archived: normalized.archived,
+    removed: normalized.removed,
+    affectedLinks: normalized.affectedLinks,
+    derivedEffects: normalized.derivedEffects
+  };
+}
+
+// src/identities/validators.ts
+function assertNoIdentityCollision(db, normalizedKey, excludeIdentityId) {
+  const row = excludeIdentityId === void 0 ? db.prepare(
+    "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 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}`
+    );
+  }
+}
+
 // src/resolve_now.ts
 function resolveNow(now) {
   if (now !== void 0) {
@@ -740,39 +948,140 @@ function resolveNow(now) {
   return Date.now();
 }
 
-// src/with_transaction.ts
-var transactionDepth = /* @__PURE__ */ new WeakMap();
-function withTransaction(db, fn) {
-  const depth = transactionDepth.get(db) ?? 0;
-  const savepoint = `affinity_${String(depth)}`;
-  if (depth === 0) {
-    db.exec("BEGIN IMMEDIATE");
-  } else {
-    db.exec(`SAVEPOINT ${savepoint}`);
+// src/identities/validate_identity_input.ts
+var identityTypes = [
+  "did",
+  "atproto_did",
+  "email",
+  "phone",
+  "url",
+  "website",
+  "handle",
+  "x",
+  "twitter",
+  "linkedin",
+  "github",
+  "mastodon",
+  "bluesky",
+  "telegram",
+  "whatsapp",
+  "signal",
+  "matrix",
+  "discord",
+  "slack",
+  "instagram",
+  "facebook",
+  "youtube",
+  "tiktok",
+  "address",
+  "other",
+  "account_id",
+  "alias"
+];
+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)"}`
+      );
   }
-  transactionDepth.set(db, depth + 1);
-  try {
-    const result = fn();
-    if (depth === 0) {
-      db.exec("COMMIT");
-    } else {
-      db.exec(`RELEASE SAVEPOINT ${savepoint}`);
-    }
-    transactionDepth.set(db, depth);
-    return result;
-  } catch (error) {
+  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)`
+    );
+  if (!value.trim())
+    throw new AffinityValidationError("identity value must be non-empty");
+  if (kind === "email" && !/^[^\s@]+@[^\s@.]+(?:\.[^\s@.]+)+$/.test(value))
+    throw new AffinityValidationError(
+      "email value must match local@domain.tld"
+    );
+  if (kind === "phone" && value.replace(/\D/g, "").length < 5)
+    throw new AffinityValidationError(
+      "phone value must contain at least 5 digits"
+    );
+  if (kind === "url" || kind === "website") {
     try {
-      if (depth === 0) {
-        db.exec("ROLLBACK");
-      } else {
-        db.exec(`ROLLBACK TO SAVEPOINT ${savepoint}`);
-        db.exec(`RELEASE SAVEPOINT ${savepoint}`);
-      }
+      const url = new URL(value.includes("://") ? value : `https://${value}`);
+      if (!["http:", "https:"].includes(url.protocol) || !url.hostname || /\s/.test(value))
+        throw new Error();
     } catch {
+      throw new AffinityValidationError(
+        "url/website value must be an http/https URL or bare domain"
+      );
+    }
+  }
+}
+
+// src/identities/add_identity.ts
+function addIdentity(db, contactId, input) {
+  return withTransaction(db, () => {
+    const contact = getContactRowById(db, contactId);
+    if (!contact) {
+      throw new AffinityNotFoundError("contact not found");
+    }
+    if (contact.lifecycle_state === "merged") {
+      throw new AffinityStateError("merged contact is read-only");
+    }
+    const type = input.type.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;
+    const verifiedAt = verified === 1 ? now : null;
+    const result = db.prepare(
+      `INSERT INTO identities (contact_id, type, value, label, normalized_key, verified, verified_at, created_at, updated_at)
+         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
+    ).run(
+      contactId,
+      type,
+      value,
+      input.label ?? null,
+      nk,
+      verified,
+      verifiedAt,
+      now,
+      now
+    );
+    const id = Number(result.lastInsertRowid);
+    const row = getIdentityRowById(db, id);
+    if (!row) {
+      throw new AffinityInvariantError("inserted identity not found");
     }
-    transactionDepth.set(db, depth);
-    throw error;
-  }
+    refreshContactRollup(db, contactId, now);
+    db.prepare(
+      "DELETE FROM dismissed_duplicates WHERE left_id = ? OR right_id = ?"
+    ).run(contactId, contactId);
+    return buildIdentityMutationReceipt(mapIdentityRowToIdentityRecord(row), {
+      created: [{ kind: "identity", id }]
+    });
+  });
 }
 
 // src/contacts/create_contact.ts
@@ -799,6 +1108,34 @@ function createContact(db, input) {
         "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(
@@ -822,9 +1159,12 @@ function createContact(db, input) {
     }
     refreshContactRollup(db, id, now);
     const primary = mapContactRowToContactListItem(row);
-    return buildContactMutationReceipt(primary, {
+    const receipt = buildContactMutationReceipt(primary, {
       created: [{ kind: "contact", id }]
     });
+    for (const identity of input.identities ?? [])
+      receipt.created.push(...addIdentity(db, id, identity).created);
+    return receipt;
   });
 }
 
@@ -847,6 +1187,100 @@ function resolveListLimitOffset(options) {
   return { limit, offset };
 }
 
+// src/events/receipts.ts
+function buildEventMutationReceipt(primary, partial) {
+  const normalized = normalizeMutationReceiptPartial(partial);
+  return {
+    primary,
+    ...partial?.warnings ? { warnings: partial.warnings } : {},
+    created: normalized.created,
+    updated: normalized.updated,
+    archived: normalized.archived,
+    removed: normalized.removed,
+    affectedLinks: normalized.affectedLinks,
+    derivedEffects: normalized.derivedEffects
+  };
+}
+
+// src/events/event_metadata.ts
+function normalizeExternalRef(ref) {
+  if (!ref || typeof ref.source !== "string" || typeof ref.id !== "string" || !ref.source.trim() || !ref.id.trim())
+    throw new AffinityValidationError(
+      "external reference source and id must be non-empty strings"
+    );
+  return { source: ref.source.trim().toLowerCase(), id: ref.id.trim() };
+}
+function deriveEventSummary(content) {
+  const line = content.split(/\r?\n/).find((line2) => line2.trim())?.replace(/\s+/g, " ").trim() ?? "(no text)";
+  return line.length > 140 ? `${line.slice(0, 139)}\u2026` : line;
+}
+function validateEventMetadata(input) {
+  if (input.affectsBond !== void 0 && typeof input.affectsBond !== "boolean")
+    throw new AffinityValidationError("affectsBond must be boolean");
+  if (input.content !== void 0 && (typeof input.content !== "string" || Buffer.byteLength(input.content, "utf8") > 1048576))
+    throw new AffinityValidationError(
+      "content must be a string of at most 1 MB (1048576 UTF-8 bytes)"
+    );
+  for (const key of ["externalRef", "parentRef", "threadRef"])
+    if (input[key] !== void 0) input[key] = normalizeExternalRef(input[key]);
+  if (input.channel !== void 0) {
+    if (typeof input.channel !== "string" || !input.channel.trim() || input.channel.trim().length > 40)
+      throw new AffinityValidationError(
+        "channel must be non-empty and at most 40 characters"
+      );
+    input.channel = input.channel.trim().toLowerCase();
+  }
+  if (input.parentEventId !== void 0 && (!Number.isSafeInteger(input.parentEventId) || input.parentEventId <= 0))
+    throw new AffinityValidationError(
+      "parentEventId must be a positive integer"
+    );
+  const moments = [
+    "breakthrough",
+    "rupture",
+    "reconciliation",
+    "milestone",
+    "turning_point"
+  ];
+  if (input.momentKind !== void 0 && !moments.includes(input.momentKind))
+    throw new AffinityValidationError(
+      `momentKind must be one of: ${moments.join(", ")}`
+    );
+}
+function getEventById(db, eventId) {
+  return db.prepare("SELECT 1 FROM events WHERE id=? AND deleted_at IS NULL").get(eventId) ? loadEventRecord(db, eventId) : null;
+}
+function getEventByExternalRef(db, source, id) {
+  const ref = normalizeExternalRef({ source, id });
+  const row = db.prepare(
+    "SELECT id FROM events WHERE external_source=? AND external_id=? AND deleted_at IS NULL"
+  ).get(ref.source, ref.id);
+  return row ? loadEventRecord(db, row.id) : null;
+}
+function existingEventReceipt(db, ref) {
+  const event = ref && getEventByExternalRef(db, ref.source, ref.id);
+  return event ? { ...buildEventMutationReceipt(event, {}), outcome: "no_op" } : null;
+}
+function enrichEventMetadata(db, record) {
+  const bond = db.prepare("SELECT affects_bond FROM events WHERE id=?").get(record.id);
+  record.affectsBond = bond?.affects_bond == null ? !(record.type === "observation" && record.significance <= 2) : Boolean(bond.affects_bond);
+  if (record.parentEventId === void 0 && record.parentRef) {
+    const row = db.prepare(
+      "SELECT id FROM events WHERE external_source=? AND external_id=? AND deleted_at IS NULL"
+    ).get(record.parentRef.source, record.parentRef.id);
+    if (row) record.parentEventId = row.id;
+  }
+  const attrs = db.prepare(
+    "SELECT id, name, value FROM attributes WHERE event_id=? AND deleted_at IS NULL ORDER BY id"
+  ).all(record.id);
+  if (attrs.length)
+    record.attributes = attrs.map((a) => ({
+      ...a,
+      contactId: null,
+      linkId: null,
+      eventId: record.id
+    }));
+}
+
 // src/events/validators.ts
 var PARTICIPANT_ROLES = /* @__PURE__ */ new Set([
   "actor",
@@ -889,8 +1323,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;
@@ -954,11 +1391,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;
@@ -988,25 +1441,29 @@ function mapUpcomingRowToUpcomingDateRecord(row) {
     targetRef,
     recurrenceKind,
     occursOn: row.occurs_on,
-    summary: row.summary,
+    occursOnDate: new Date(row.occurs_on).toISOString().slice(0, 10),
+    summary: decodeEventText(row.summary),
     significance: row.significance
   };
 }
+function decodeEventText(value) {
+  return typeof value === "string" ? value : Buffer.from(value).toString("utf8");
+}
 
 // src/events/queries.ts
 function getEventRowById(db, id) {
   const row = db.prepare(
-    `SELECT id, type, occurred_at, summary, significance, moment_kind,
-              recurrence_kind, anchor_month, anchor_day,
-              anchor_contact_id, anchor_link_id,
-              created_at, updated_at, deleted_at
+    `SELECT *, CAST(content AS BLOB) AS content, CAST(summary AS BLOB) AS summary
        FROM events
        WHERE id = ? AND deleted_at IS NULL`
   ).get(id);
   if (row === void 0) {
     return null;
   }
-  return row;
+  const event = row;
+  event.summary = decodeEventText(event.summary);
+  if (event.content != null) event.content = decodeEventText(event.content);
+  return event;
 }
 function findDuplicateDateAnchor(db, params) {
   const exclude = params.excludeEventId;
@@ -1074,19 +1531,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
@@ -1110,7 +1575,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;
@@ -1169,6 +1636,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
@@ -1179,8 +1650,70 @@ function getContactJournal(db, contactId, options) {
   ).all(...params, limit, offset);
   return batchLoadEventRecords(
     db,
-    rows.map((r) => r.id)
+    rows.map((r) => r.id),
+    options?.includeContent ?? false
+  );
+}
+
+// src/lib/parse_calendar_time.ts
+var timeInputForms = "epoch milliseconds integer, ISO 8601 date-time with Z/offset, YYYY-MM-DD, DD.MM.YYYY, today, tomorrow, yesterday, +3d or -2d";
+function isCommitmentOverdue(dueAt, dueOn, now) {
+  if (dueAt === null) return false;
+  if (dueOn && dueAt === Date.parse(`${dueOn}T23:59:59.999Z`)) {
+    return localCalendarDate(now) > dueOn;
+  }
+  return dueAt < now;
+}
+var OVERDUE_SQL = "(CASE WHEN oc.due_on IS NOT NULL AND oc.due_at = CAST(strftime('%s', oc.due_on) AS INTEGER) * 1000 + 86399999 THEN oc.due_on < ? ELSE oc.due_at < ? END)";
+function localCalendarDate(now) {
+  const d = new Date(now);
+  return `${String(d.getFullYear()).padStart(4, "0")}-${String(d.getMonth() + 1).padStart(2, "0")}-${String(d.getDate()).padStart(2, "0")}`;
+}
+function parseCalendarTime(value, field = "time", now = Date.now()) {
+  if (value == null && field.endsWith("occurredAt"))
+    throw new AffinityValidationError(
+      "occurredAt is required (ISO, YYYY-MM-DD, epoch ms, today, +3d \u2026)"
+    );
+  const fail = () => {
+    throw new AffinityValidationError(`${field}: expected ${timeInputForms}`);
+  };
+  if (typeof value === "number" || typeof value === "string" && /^-?\d+$/.test(value.trim())) {
+    const timestamp2 = Number(value);
+    if (!Number.isSafeInteger(timestamp2) || !Number.isFinite(new Date(timestamp2).getTime()))
+      return fail();
+    return { timestamp: timestamp2, day: new Date(timestamp2).toISOString().slice(0, 10) };
+  }
+  if (typeof value !== "string") return fail();
+  let text = value.trim();
+  if (/^\d{4}-\d{2}-\d{2} \d{2}:\d{2}/.test(text)) {
+    text = text.replace(" ", "T");
+    if (!/(?:Z|[+-]\d{2}:\d{2})$/.test(text)) text += "Z";
+  }
+  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 };
 }
 
 // src/events/list_open_commitments.ts
@@ -1238,9 +1771,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
@@ -1257,7 +1794,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)
   }));
 }
@@ -1291,8 +1829,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);
@@ -1352,19 +1892,6 @@ function loadActiveDatesForContact(db, contactId) {
   return rows.map((row) => mapUpcomingRowToUpcomingDateRecord(row));
 }
 
-// src/identities/mappers.ts
-function mapIdentityRowToIdentityRecord(row) {
-  return {
-    id: row.id,
-    contactId: row.contact_id,
-    type: row.type,
-    value: row.value,
-    label: row.label,
-    verified: row.verified === 1,
-    verifiedAt: row.verified_at
-  };
-}
-
 // src/links/mappers.ts
 function mapLinkRowToLinkListItem(row) {
   const kind = row.kind;
@@ -1425,7 +1952,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);
@@ -1458,7 +1991,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()
@@ -1488,7 +2034,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
@@ -1559,7 +2108,9 @@ function pairKey(leftContactId, rightContactId) {
 function normalizeName(name) {
   return name.trim().toLowerCase().replace(/\s+/g, " ");
 }
-function fuzzyNameScore(left, right) {
+function fuzzyNameScore(leftInput, rightInput) {
+  const left = normalizeName(leftInput);
+  const right = normalizeName(rightInput);
   if (left === right) {
     return 0.92;
   }
@@ -1717,7 +2268,7 @@ function foldSearchText(value) {
 
 // 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);
@@ -1737,6 +2288,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",
@@ -1772,7 +2324,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))
@@ -1807,7 +2359,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) {
@@ -1862,7 +2414,7 @@ function setContactLifecycle(db, contactId, lifecycleState, options) {
 // 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,
@@ -1879,6 +2431,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
@@ -1921,6 +2502,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
@@ -1941,20 +2526,6 @@ function insertDateAnchorEvent(db, params) {
   return eventId;
 }
 
-// src/events/receipts.ts
-function buildEventMutationReceipt(primary, partial) {
-  const normalized = normalizeMutationReceiptPartial(partial);
-  return {
-    primary,
-    created: normalized.created,
-    updated: normalized.updated,
-    archived: normalized.archived,
-    removed: normalized.removed,
-    affectedLinks: normalized.affectedLinks,
-    derivedEffects: normalized.derivedEffects
-  };
-}
-
 // src/links/queries.ts
 function getLinkRowById(db, id) {
   const row = db.prepare(
@@ -2116,12 +2687,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);
   }
@@ -2659,6 +3230,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
@@ -2666,6 +3241,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
@@ -2678,6 +3254,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
   }));
@@ -2706,6 +3283,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
@@ -2717,7 +3298,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
   );
 }
 
@@ -2791,26 +3373,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) {
@@ -3129,21 +3719,6 @@ function listProgressionReadiness(db, filters, options) {
 }
 
 // src/links/list_radar.ts
-function deriveRadarReason(drift, recency, normalizedRank3) {
-  if (drift > 0.5) {
-    return "Significantly overdue for contact";
-  }
-  if (drift > 0.2) {
-    return "Drifting \u2014 approaching overdue";
-  }
-  if (recency < 0.3 && normalizedRank3 > 0.3) {
-    return "Important link losing recency";
-  }
-  if (normalizedRank3 > 0.5 && recency < 0.5) {
-    return "High-rank link needs attention";
-  }
-  return "Routine check-in recommended";
-}
 function listRadar(db, filters, options) {
   assertDefaultOrdering("listRadar", options);
   const ownerId = findOwnerContactId(db);
@@ -3151,7 +3726,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",
@@ -3176,10 +3754,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,
@@ -3193,23 +3784,44 @@ function listRadar(db, filters, options) {
          AND c_to.deleted_at IS NULL AND c_to.lifecycle_state != 'merged'
        LEFT JOIN link_rollups lr ON lr.link_id = l.id
        WHERE ${where}
-       ORDER BY ${overdue} DESC, COALESCE(lr.radar_score, 0) DESC
+       ORDER BY (${overdue} OR ${drift}) DESC, ${overdue} DESC, COALESCE(lr.radar_score, 0) DESC
        LIMIT ? OFFSET ?`
   ).all(...params, limit, offset);
-  return rows.map((row) => ({
-    linkId: row.id,
-    contactId: row.from_contact_id === ownerId ? row.to_contact_id : row.from_contact_id,
-    reasons: row.overdue_commitment ? ["overdue_commitment"] : [],
-    driftPriority: row.overdue_commitment ? Math.max(1, row.drift_priority ?? 0) : row.drift_priority ?? 0,
-    recencyScore: row.recency_score ?? 0,
-    normalizedRank: row.normalized_rank ?? 0,
-    trust: row.trust ?? 0,
-    recommendedReason: deriveRadarReason(
-      row.drift_priority ?? 0,
-      row.recency_score ?? 0,
-      row.normalized_rank ?? 0
-    )
-  }));
+  return rows.map((row) => {
+    const contactId = row.from_contact_id === ownerId ? row.to_contact_id : row.from_contact_id;
+    const promise = row.overdue_commitment ? db.prepare(
+      `SELECT e.summary, oc.due_at, oc.due_on FROM open_commitments oc JOIN events e ON e.id = oc.event_id JOIN event_participants ep ON ep.event_id = e.id WHERE ep.contact_id = ? AND e.deleted_at IS NULL AND oc.resolved_at IS NULL AND ${OVERDUE_SQL} ORDER BY oc.due_at LIMIT 1`
+    ).get(contactId, today, now) : void 0;
+    const reasons = [
+      ...row.overdue_commitment ? ["overdue_commitment"] : [],
+      ...row.drift ? ["drift"] : []
+    ];
+    const snippets = [
+      ...promise ? [
+        `Overdue promise: ${promise.summary} (due ${promise.due_on ?? new Date(promise.due_at).toISOString().slice(0, 10)})`
+      ] : [],
+      ...row.drift ? [
+        `No contact for ${Math.floor((now - (row.last_contact ?? now)) / 864e5)} days (cadence ${row.cadence_days ?? 1} days)`
+      ] : []
+    ];
+    const elapsed = row.last_contact === null ? null : Math.max(0, (now - row.last_contact) / 864e5);
+    const currentDrift = elapsed === null ? 0 : driftPriority({
+      daysSinceLastMeaningfulEvent: elapsed,
+      cadenceDays: row.cadence_days ?? 1,
+      trust: row.trust ?? 0,
+      rank: row.rank ?? 0
+    });
+    return {
+      linkId: row.id,
+      contactId: row.from_contact_id === ownerId ? row.to_contact_id : row.from_contact_id,
+      reasons,
+      driftPriority: row.overdue_commitment ? Math.max(1, currentDrift) : currentDrift,
+      recencyScore: elapsed === null ? 0 : Math.max(0, 1 - elapsed / Math.max(row.cadence_days ?? 1, 1)),
+      normalizedRank: row.normalized_rank ?? 0,
+      trust: row.trust ?? 0,
+      recommendedReason: snippets.join("; ") || "Routine check-in recommended"
+    };
+  });
 }
 
 // src/links/receipts.ts
@@ -3292,6 +3904,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);
@@ -3366,6 +3981,8 @@ function reviseBond(db, linkId, bond, options) {
 // 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");
     }
@@ -3373,11 +3990,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"
       );
@@ -4196,6 +4816,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";
   }
@@ -4225,6 +4847,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;
@@ -4269,7 +4903,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(
@@ -4310,15 +4944,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
@@ -4338,7 +4973,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,
@@ -4381,7 +5020,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);
@@ -4464,15 +5111,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;
       }
@@ -4480,13 +5148,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);
@@ -4521,7 +5190,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
       })
@@ -4545,6 +5217,8 @@ function applyJournalEventMechanics(db, params) {
 function recordCommitment(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     if (input.commitmentType !== "promise" && input.commitmentType !== "agreement") {
       throw new AffinityValidationError(
         "commitmentType must be promise or agreement"
@@ -4559,11 +5233,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
     });
@@ -4572,15 +5247,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,
@@ -4601,6 +5286,8 @@ var ALLOWED = /* @__PURE__ */ new Set([
 function recordInteraction(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     if (!ALLOWED.has(input.type)) {
       throw new AffinityValidationError("invalid interaction event type");
     }
@@ -4610,11 +5297,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
     });
@@ -4622,12 +5310,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
@@ -4639,17 +5339,20 @@ function recordInteraction(db, input) {
 function recordMilestone(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     const ownerId = requireOwnerContactId(db);
     const ids = input.participants.map((p) => p.contactId);
     assertParticipantContactsLive(db, ids);
     assertOwnerParticipates(ownerId, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: "milestone",
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -4657,12 +5360,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
@@ -4674,15 +5389,18 @@ function recordMilestone(db, input) {
 function recordObservation(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     const ids = input.participants.map((p) => p.contactId);
     assertParticipantContactsLive(db, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: "observation",
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -4690,12 +5408,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
@@ -4707,17 +5437,20 @@ function recordObservation(db, input) {
 function recordTransaction(db, input) {
   return withTransaction(db, () => {
     validateSocialEventInput(input);
+    const existing = existingEventReceipt(db, input.externalRef);
+    if (existing) return existing;
     const ownerId = requireOwnerContactId(db);
     const ids = input.participants.map((p) => p.contactId);
     assertParticipantContactsLive(db, ids);
     assertOwnerParticipates(ownerId, ids);
     const now = resolveNow(input.now);
     const eventId = insertJournalEvent(db, {
+      ...input,
       type: "transaction",
       occurredAt: input.occurredAt,
-      summary: input.summary,
+      occurredOn: input.occurredOn,
       significance: input.significance,
-      momentKind: null,
+      momentKind: input.momentKind ?? null,
       participants: input.participants,
       now
     });
@@ -4725,12 +5458,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
@@ -4803,6 +5548,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,
@@ -4819,6 +5565,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,
@@ -4852,30 +5599,46 @@ function resolveCommitment(db, commitmentEventId, resolution, options) {
   });
 }
 
-// src/contacts/export_contact.ts
-function exportContact(db, id) {
-  const query = (sql, ...params) => db.prepare(sql).all(...params).map((row) => {
+// src/contacts/export_rows.ts
+function exportRows(db, sql, ...params) {
+  return db.prepare(sql).all(...params).map((row) => {
     const result = {};
     for (const [key, value] of Object.entries(row)) {
       const name = key.replace(
         /_([a-z])/g,
         (_, letter) => letter.toUpperCase()
       );
-      result[name] = value;
-      if ((name.endsWith("At") || name === "dueAt") && typeof value === "number")
+      result[name] = [
+        "affects_bond",
+        "is_owner",
+        "is_structural",
+        "verified",
+        "counts_for_recency",
+        "manual"
+      ].includes(key) ? Boolean(value) : value instanceof Uint8Array ? Buffer.from(value).toString("utf8") : value;
+      if (name.endsWith("At") && typeof value === "number")
         result[`${name}Iso`] = new Date(value).toISOString();
       if (key.endsWith("_json") && typeof value === "string")
         result[name] = JSON.parse(value);
     }
     return result;
   });
+}
+
+// src/contacts/export_contact.ts
+function exportContact(db, id) {
+  const query = (sql, ...params) => exportRows(db, sql, ...params);
   const contact = query("SELECT * FROM contacts WHERE id = ?", id)[0];
   if (!contact) throw new AffinityNotFoundError("contact not found");
   const events = query(
-    "SELECT DISTINCT e.* FROM events e JOIN event_participants p ON p.event_id = e.id WHERE p.contact_id = ? ORDER BY e.id",
+    "SELECT DISTINCT e.*, 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
@@ -4920,14 +5683,100 @@ function exportContact(db, id) {
 // src/contacts/export_affinity.ts
 function exportAffinity(db) {
   const now = Date.now();
+  const records = db.prepare("SELECT id FROM contacts ORDER BY id").all().map((row) => exportContact(db, row.id));
+  const events = exportRows(
+    db,
+    "SELECT *, CAST(content AS BLOB) AS content, CAST(summary AS BLOB) AS summary FROM events ORDER BY id"
+  ).map((event) => ({
+    ...event,
+    attributes: exportRows(
+      db,
+      "SELECT * FROM attributes WHERE event_id=? ORDER BY id",
+      event.id
+    ),
+    participants: exportRows(
+      db,
+      "SELECT p.contact_id, p.role, c.name AS contact_name FROM event_participants p JOIN contacts c ON c.id = p.contact_id WHERE p.event_id = ? ORDER BY p.contact_id",
+      event.id
+    )
+  }));
   return {
     version: 1,
     exportedAt: now,
     exportedAtIso: new Date(now).toISOString(),
-    contacts: db.prepare("SELECT id FROM contacts ORDER BY id").all().map((row) => exportContact(db, row.id))
+    events,
+    contacts: records.map(({ events: events2, dates, ...record }) => ({
+      ...record,
+      eventIds: events2.map((event) => event.id),
+      dateIds: dates.map((date) => date.id)
+    }))
   };
 }
 
+// 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
+  );
+}
+
 // src/soul.ts
 var soul_exports = {};
 __export(soul_exports, {
@@ -5134,6 +5983,15 @@ var identifyAndLocateContactsSkill = defineAffinitySkill({
   description: "Find the right contact reliably, prefer stable natural keys when possible, and avoid creating duplicates through weak lookup discipline.",
   content: `# Identify And Locate Contacts
 
+Handle identities normalize leading @ and case. Bluesky uses a domain handle,
+X/Twitter uses 1\u201315 letters/digits/underscores, Mastodon uses user@host.tld.
+Native did (alias atproto_did) validates did:<method>:<identifier>; legacy
+custom:atproto-did locators find the same identity. Keep old handles as identities.
+An owned identity makes contact creation fail atomically with conflict and
+existingContactId. input.ifExists="return" returns the matching contact and
+matchedIdentities without attaching any free identities. CLI: --if-exists return.
+Name-only possible duplicates still warn. Search @handle is always literal.
+
 Primary tools:
 - \`search_affinity\`
 - \`inspect_affinity_item\`
@@ -5191,6 +6049,31 @@ var importHistoryWithoutFakingEvidenceSkill = defineAffinitySkill({
   description: "Import pre-existing relationship state honestly, using seeded links for known history instead of inventing fake journal evidence.",
   content: `# Import History Without Faking Evidence
 
+For social imports, use native did identities (atproto_did is an alias; legacy
+custom:atproto-did locators remain equivalent). Create with input.ifExists="return"
+for safe retries: this attaches nothing to an existing contact. For handle changes,
+call manage_identity add separately with input.ifExists="return"; an identity already
+on that contact is a no-op, while another owner still conflicts. Seed links with
+input.ifExists="return" to reuse them without changing their state.
+Use ghostpaw-affinity batch [--chunk 500] with JSONL {tool,args}, or
+{op:"event",kind:"interaction",input:{...}}. Per-line savepoints isolate failures;
+--stop-on-error stops early. Exit 2 identifies malformed JSON; other failures exit 1.
+Use externalRef {source:"bluesky",id:recordUri}, verbatim content and channel.
+Participant contact locators may use identities, including did, instead of ids.
+Read JSON flags from stdin with --input - or from @file for large payloads (E2BIG).
+SQLite date-times without offsets mean UTC; microseconds truncate to milliseconds; raw timestamps remain in provenance.
+Missing inbound-follow timestamps should use a known first_seen or be counted as skipped.
+The synthetic scripts/examples/import_social_jsonl.mjs and import_dry_run.mjs
+show the mapping and verify an idempotent retry and byte-identical text.
+
+For archived messages with known timestamps, record actual evidence with externalRef:
+{source, id} deduplicates retries across event families and commitments. Keep original
+message text in content, use channel and parentRef/threadRef for context, and keep
+summary short or let it derive from content. Content is limited to 1 MB UTF-8;
+keep larger raw archives in the source system. Inspect events by external reference,
+search scope "events", and use manage_event revise/delete to correct imports.
+See the tools guide for field details. Existing 0.5.x databases upgrade in place.
+
 Primary tools:
 - \`manage_contact\`
 - \`manage_identity\`
@@ -5247,6 +6130,14 @@ var managePromisesAndAgreementsSkill = defineAffinitySkill({
   description: "Track obligations explicitly from creation to resolution so open commitments remain actionable and trust consequences stay honest.",
   content: `# Manage Promises And Agreements
 
+CLI and MCP share epoch ms, ISO with Z/offset, YYYY-MM-DD, DD.MM.YYYY,
+today/yesterday/tomorrow and signed day offsets (+3d/-2d).
+Date-only values keep their day with UTC boundaries; keywords use the process
+local date. Read occurredOn/dueOn and review occursOn for calendar dates;
+*Iso fields stay UTC. Future events warn and count as contact only when their
+time and day arrive. Commitments and resolutions never reset recency/cadence.
+Radar explains overdue promises and drift (gap > 1.5 times cadence).
+
 Primary tools:
 - \`manage_commitment\`
 - \`review_affinity\`
@@ -5302,6 +6193,14 @@ var manageRecurringDatesAndRemindersSkill = defineAffinitySkill({
   description: "Use date anchors for recurring salience so important birthdays, anniversaries, renewals, and memorials feed review surfaces cleanly.",
   content: `# Manage Recurring Dates And Reminders
 
+CLI and MCP share epoch ms, ISO with Z/offset, YYYY-MM-DD, DD.MM.YYYY,
+today/yesterday/tomorrow and signed day offsets (+3d/-2d).
+Date-only values keep their day with UTC boundaries; keywords use the process
+local date. Read occurredOn/dueOn and review occursOn for calendar dates;
+*Iso fields stay UTC. Future events warn and count as contact only when their
+time and day arrive. Commitments and resolutions never reset recency/cadence.
+Radar explains overdue promises and drift (gap > 1.5 times cadence).
+
 Primary tools:
 - \`manage_date_anchor\`
 - \`review_affinity\`
@@ -5413,6 +6312,24 @@ var recordDirectEvidenceWellSkill = defineAffinitySkill({
   description: "Record direct owner-facing social evidence in a way that produces truthful mechanics, good moments, and useful future review surfaces.",
   content: `# Record Direct Evidence Well
 
+CLI and MCP share epoch ms, ISO with Z/offset, YYYY-MM-DD, DD.MM.YYYY,
+today/yesterday/tomorrow and signed day offsets (+3d/-2d). Date-only inputs
+preserve the calendar day at UTC midnight (UTC end of day for dueAt).
+Keywords use the process local date. Read occurredOn/dueOn and review occursOn
+for calendar dates; *Iso fields remain UTC. Future events carry future_event
+warnings and do not count for recency, cadence or drift until their time and day
+arrive. Commitments and resolutions never reset contact recency or cadence.
+
+Imported text and event maintenance:
+- Use externalRef: {source, id} for idempotent intake; retries return no_op and the existing id.
+- Store verbatim text in content (up to 1,048,576 UTF-8 bytes, empty allowed). Summary is optional when content exists; its derived label is at most 140 characters.
+- Use channel for the medium, parentRef or parentEventId for replies, and threadRef for the root. Event attributes use target {kind: "event", eventId} or {kind: "event", ref: {source, id}}. Unchanged values return no_op.
+- Inspect kind "event" by eventId or ref. Search scope "events" or "all" discovers event ids; default scope remains contacts.
+- Review journals/timelines with includeContent: true only when needed; CLI uses --with-content. Filter with channel. Review events.thread by ref for chronological context.
+- Use manage_event revise with patch: summary, content, occurredAt, significance, channel, type within the same kind, or externalRef only when absent. Unknown keys fail validation.
+- Use manage_event delete with confirm: true to remove incorrect evidence and recompute affected relationship scores.
+- Send large payloads through whole-payload stdin or @file rather than argv. For example, affinity event record < payload.json or affinity call record_event - < payload.json.
+
 Primary tools:
 - \`record_event\`
 - \`inspect_affinity_item\`
@@ -5471,6 +6388,17 @@ var recordObservationsAndReferralsSkill = defineAffinitySkill({
   description: "Capture third-party and referral truth without overclaiming intimacy, directness, or trust that the operator did not actually earn.",
   content: `# Record Observations And Referrals
 
+Likes, reposts and follows are ambient observations, not milestones. Record them
+with affectsBond:false. Like/follow/repost labels default to false across families;
+explicit true opts in. Observations with significance <=2 also default to false.
+They stay in journals but do not change affinity or meaningful-contact recency.
+provenance.ambient:true also suppresses effects. Use explicit owner and other
+participants, actor/recipient roles, and the correct directionality.
+Unanswered owner_initiated evidence contributes much less and does not reset
+radar recency. A relationship with only outbound activity gets no routine check-in
+or drift prompt. other_initiated evidence counts fully. Observations and follow-like
+milestones never derive breakthroughs; low-significance milestones derive no moment.
+
 Primary tools:
 - \`record_event\`
 - \`review_affinity\`
@@ -5580,6 +6508,19 @@ var reviewRadarProgressionAndGraphSkill = defineAffinitySkill({
   description: "Use the review surfaces to prioritize maintenance, understand progression readiness, and read the shape of the relationship graph without guessing from raw rows.",
   content: `# Review Radar, Progression, And Graph
 
+List reviews accept limit (default 50, maximum 250) and offset. Results include
+total and hasMore; continue paging while hasMore is true. Event type array flags
+accept JSON arrays, comma lists, or repeated --event-types flags; invalid types
+report allowed values with exit 2. Use skill --short for a compact CLI reference.
+
+CLI and MCP share epoch ms, ISO with Z/offset, YYYY-MM-DD, DD.MM.YYYY,
+today/yesterday/tomorrow and signed day offsets (+3d/-2d).
+Date-only values keep their day with UTC boundaries; keywords use the process
+local date. Read occurredOn/dueOn and review occursOn for calendar dates;
+*Iso fields stay UTC. Future events warn and count as contact only when their
+time and day arrive. Commitments and resolutions never reset recency/cadence.
+Radar explains overdue promises and drift (gap > 1.5 times cadence).
+
 Primary tools:
 - \`review_affinity\`
 - \`inspect_affinity_item\`
@@ -5680,6 +6621,9 @@ __export(tools_exports, {
   manageDuplicateDismissalTool: () => manageDuplicateDismissalTool,
   manageDuplicateDismissalToolHandler: () => manageDuplicateDismissalToolHandler,
   manageDuplicateDismissalToolName: () => manageDuplicateDismissalToolName,
+  manageEventTool: () => manageEventTool,
+  manageEventToolHandler: () => manageEventToolHandler,
+  manageEventToolName: () => manageEventToolName,
   manageIdentityTool: () => manageIdentityTool,
   manageIdentityToolHandler: () => manageIdentityToolHandler,
   manageIdentityToolName: () => manageIdentityToolName,
@@ -5730,37 +6674,8 @@ __export(tools_exports, {
 });
 
 // src/tools/parse_time_input.ts
-var timeInputForms = "epoch milliseconds integer, ISO 8601 date-time with Z/offset, YYYY-MM-DD, today, tomorrow, yesterday, +3d or -2d";
 function parseTimeInput(value, field = "time", now = Date.now()) {
-  const fail = () => {
-    throw new AffinityValidationError(`${field}: expected ${timeInputForms}`);
-  };
-  if (typeof value === "number")
-    return Number.isSafeInteger(value) && Number.isFinite(new Date(value).getTime()) ? value : fail();
-  if (typeof value !== "string") return fail();
-  const text = value.trim();
-  const relative = /^(?:today|tomorrow|yesterday|[+-]\d+d)$/.test(text);
-  let day;
-  if (relative) {
-    const offset = text === "today" ? 0 : text === "tomorrow" ? 1 : text === "yesterday" ? -1 : Number(text.slice(0, -1));
-    day = Math.floor(now / 864e5) * 864e5 + offset * 864e5;
-  } else if (/^\d{4}-\d{2}-\d{2}$/.test(text)) {
-    day = Date.parse(`${text}T00:00:00.000Z`);
-    if (!Number.isFinite(day) || new Date(day).toISOString().slice(0, 10) !== text)
-      return fail();
-  } else {
-    if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(?::\d{2}(?:\.\d+)?)?(?:Z|[+-]\d{2}:\d{2})$/.test(
-      text
-    ))
-      return fail();
-    const calendar = Date.parse(`${text.slice(0, 10)}T00:00:00Z`);
-    if (!Number.isFinite(calendar) || new Date(calendar).toISOString().slice(0, 10) !== text.slice(0, 10))
-      return fail();
-    const parsed = Date.parse(text);
-    return Number.isFinite(parsed) ? parsed : fail();
-  }
-  const result = day + (field.split(".").at(-1) === "dueAt" ? 86399999 : 0);
-  return Number.isSafeInteger(result) && Number.isFinite(new Date(result).getTime()) ? result : fail();
+  return parseCalendarTime(value, field, now).timestamp;
 }
 
 // src/tools/tool_metadata.ts
@@ -5844,6 +6759,39 @@ function oneOfSchema(schemas, description) {
   return schema;
 }
 
+// src/tools/event_metadata_schema.ts
+var externalRefSchema = objectSchema(
+  {
+    source: stringSchema("External source; trimmed and lowercased."),
+    id: stringSchema("Non-empty external id.")
+  },
+  ["source", "id"]
+);
+var eventMetadataSchema = {
+  affectsBond: booleanSchema(
+    "Whether evidence affects the relationship; defaults false for 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 = "search_affinity";
 var reviewAffinityToolName = "review_affinity";
@@ -5857,6 +6805,7 @@ var recordEventToolName = "record_event";
 var manageCommitmentToolName = "manage_commitment";
 var manageDateAnchorToolName = "manage_date_anchor";
 var manageAttributeToolName = "manage_attribute";
+var manageEventToolName = "manage_event";
 
 // src/tools/tool_ref.ts
 function contactState(value) {
@@ -5916,7 +6865,7 @@ function toEventEntityRef(value) {
   return {
     kind: "event",
     id: value.id,
-    title: value.summary,
+    title: deriveEventSummary(value.summary),
     subtitle: value.type,
     state: value.type
   };
@@ -5964,16 +6913,6 @@ function toReceiptEntityRefs(receipt) {
   });
 }
 
-// src/identities/normalize.ts
-function normalizeIdentityKey(type, value) {
-  const t = type.trim().toLowerCase();
-  const v = value.trim().toLowerCase();
-  if (t.length === 0 || v.length === 0) {
-    throw new AffinityValidationError("type and value must be non-empty");
-  }
-  return `${t}:${v}`;
-}
-
 // src/tools/tool_types.ts
 function withOptionalFields(result, options) {
   if (options.next && options.next.length > 0) {
@@ -6089,7 +7028,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 };
@@ -6114,9 +7053,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,
@@ -6267,13 +7210,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);
@@ -6312,27 +7263,32 @@ function affinityErrorCodeToToolCode(error) {
 }
 
 // src/tools/validate_tool_input.ts
-function validateToolInput(schema, value, path = "input", injectedNow = Date.now()) {
+function validateToolInput(schema, value, path = "input", injectedNow = Date.now(), strict = false) {
+  if (path.endsWith(".occurredAt") && value == null)
+    return "occurredAt is required (ISO, YYYY-MM-DD, epoch ms, today, +3d \u2026)";
+  const branches = schema.oneOf ?? schema.anyOf;
+  if (path.endsWith(".value") && branches?.some((b) => b.type === "string") && branches.some((b) => b.type === "null") && value !== null && typeof value !== "string")
+    return `attribute values are strings or null; pass "${String(value)}" to store it as text`;
   if (schema.anyOf || schema.oneOf) {
     const choices = schema.anyOf ?? schema.oneOf ?? [];
     return choices.some(
-      (choice) => validateToolInput(choice, value, path, injectedNow) === null
+      (choice) => validateToolInput(choice, value, path, injectedNow, strict) === null
     ) ? null : `${path}: invalid value`;
   }
   if (schema.type === "object") {
     if (value === null || typeof value !== "object" || Array.isArray(value))
       return `${path}: missing input or expected object`;
     const object = value;
-    if (path.endsWith(".patch") && schema.additionalProperties === false) {
+    if ((strict || path.endsWith(".patch")) && schema.additionalProperties === false) {
       for (const key of Object.keys(object)) {
         if (!Object.hasOwn(schema.properties ?? {}, key))
-          return key === "kind" && "name" in (schema.properties ?? {}) ? "kind cannot be changed after creation" : `${path}.${key}: unknown patch key; allowed keys: ${Object.keys(schema.properties ?? {}).join(", ")}`;
+          return key === "kind" && "name" in (schema.properties ?? {}) ? "kind cannot be changed after creation" : `${path}.${key}: unknown ${path.endsWith(".patch") ? "patch key" : "key"}; allowed keys: ${Object.keys(schema.properties ?? {}).join(", ")}`;
       }
     }
     if (object.action === "revise" && schema.properties?.patch && object.patch === void 0)
       return `${path}.patch: missing required field`;
     if (object.patch !== void 0 && !schema.properties?.patch)
-      return `${path}.patch: unknown patch key; allowed keys: none (use the action's named fields)`;
+      return `${path}.patch: unknown key; allowed keys: none (use the action's named fields)`;
     const referenceNow = object.now === void 0 ? injectedNow : (() => {
       try {
         return parseTimeInput(
@@ -6347,11 +7303,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;
         }
@@ -6366,8 +7332,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;
     }
@@ -6380,7 +7347,8 @@ function validateToolInput(schema, value, path = "input", injectedNow = Date.now
         schema.items ?? {},
         item,
         `${path}[${index}]`,
-        injectedNow
+        injectedNow,
+        strict
       );
       if (error) return error;
     }
@@ -6446,6 +7414,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,
@@ -6543,10 +7531,13 @@ var inspectAffinityItemTool = defineAffinityTool({
   inputSchema: objectSchema(
     {
       kind: enumSchema("What to inspect.", [
+        "event",
         "owner_profile",
         "contact_profile",
         "link"
       ]),
+      eventId: integerSchema("Exact event id."),
+      ref: externalRefSchema,
       contact: contactLocatorSchema(
         "Target contact. Required when kind=contact_profile. Provide contactId or identity."
       ),
@@ -6565,6 +7556,7 @@ var inspectAffinityItemTool = defineAffinityTool({
 // src/attributes/helpers.ts
 function clearedAttributePrimary(target) {
   return {
+    ...target.kind === "event" ? { eventId: target.eventId } : {},
     id: 0,
     contactId: target.kind === "contact" ? target.id : null,
     linkId: target.kind === "link" ? target.id : null,
@@ -6576,6 +7568,7 @@ function clearedAttributePrimary(target) {
 // src/attributes/mappers.ts
 function mapAttributeRowToAttributeRecord(row) {
   return {
+    ...row.event_id == null ? {} : { eventId: row.event_id },
     id: row.id,
     contactId: row.contact_id,
     linkId: row.link_id,
@@ -6585,49 +7578,26 @@ function mapAttributeRowToAttributeRecord(row) {
 }
 
 // src/attributes/queries.ts
+function attributeTargetSql(target) {
+  return {
+    column: target.kind === "event" ? "event_id" : target.kind === "contact" ? "contact_id" : "link_id",
+    id: target.kind === "event" ? target.eventId : target.id
+  };
+}
 function getAttributeRowById(db, id) {
-  const row = db.prepare(
-    `SELECT id, contact_id, link_id, name, value, created_at, updated_at, deleted_at
-       FROM attributes WHERE id = ?`
-  ).get(id);
-  if (row === void 0) {
-    return null;
-  }
-  return row;
+  return db.prepare("SELECT * FROM attributes WHERE id=?").get(id) ?? null;
 }
 function getLiveAttributeRow(db, target, name) {
-  if (target.kind === "contact") {
-    const row2 = db.prepare(
-      `SELECT id, contact_id, link_id, name, value, created_at, updated_at, deleted_at
-         FROM attributes
-         WHERE contact_id = ? AND name = ? AND deleted_at IS NULL`
-    ).get(target.id, name);
-    if (row2 === void 0) {
-      return null;
-    }
-    return row2;
-  }
-  const row = db.prepare(
-    `SELECT id, contact_id, link_id, name, value, created_at, updated_at, deleted_at
-       FROM attributes
-       WHERE link_id = ? AND name = ? AND deleted_at IS NULL`
-  ).get(target.id, name);
-  if (row === void 0) {
-    return null;
-  }
-  return row;
+  const t = attributeTargetSql(target);
+  return db.prepare(
+    `SELECT * FROM attributes WHERE ${t.column}=? AND name=? AND deleted_at IS NULL`
+  ).get(t.id, name) ?? null;
 }
 function listLiveAttributeIdsForTarget(db, target) {
-  if (target.kind === "contact") {
-    const rows2 = db.prepare(
-      "SELECT id FROM attributes WHERE contact_id = ? AND deleted_at IS NULL ORDER BY id"
-    ).all(target.id);
-    return rows2.map((row) => row.id);
-  }
-  const rows = db.prepare(
-    "SELECT id FROM attributes WHERE link_id = ? AND deleted_at IS NULL ORDER BY id"
-  ).all(target.id);
-  return rows.map((row) => row.id);
+  const t = attributeTargetSql(target);
+  return db.prepare(
+    `SELECT id FROM attributes WHERE ${t.column}=? AND deleted_at IS NULL ORDER BY id`
+  ).all(t.id).map((r) => r.id);
 }
 
 // src/attributes/receipts.ts
@@ -6649,6 +7619,8 @@ function normalizeAttributeValue(value) {
   if (value === null) {
     return null;
   }
+  if (typeof value !== "string")
+    throw new AffinityValidationError("attribute values are strings or null");
   const trimmed = value.trim();
   return trimmed.length === 0 ? null : trimmed;
 }
@@ -6677,6 +7649,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) {
@@ -6712,26 +7689,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), {
@@ -6761,6 +7726,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 = ?"
@@ -6776,27 +7746,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) {
@@ -6852,14 +7805,15 @@ function mutationToolResult(action, receipt, entitySummary, fields) {
     affectedLinks: receipt.affectedLinks,
     derivedEffects: receipt.derivedEffects
   };
-  const summary = changedCount === 0 ? `No ${entitySummary} changes were needed.` : describeChanges(receipt);
+  const summary = changedCount === 0 ? receipt.primary && typeof receipt.primary === "object" && "externalRef" in receipt.primary && "id" in receipt.primary ? `Event already recorded (#${receipt.primary.id}, ${receipt.primary.externalRef.source} ${receipt.primary.externalRef.id}).` : `No ${entitySummary} changes were needed.` : describeChanges(receipt);
   if (changedCount === 0) {
     return toolNoOp(summary, data, {
       entities: toReceiptEntityRefs(receipt)
     });
   }
   return toolSuccess(summary, data, {
-    entities: toReceiptEntityRefs(receipt)
+    entities: toReceiptEntityRefs(receipt),
+    warnings: receipt.warnings
   });
 }
 var PLURALS = { identity: "identities" };
@@ -6916,6 +7870,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) {
@@ -6975,7 +7953,7 @@ function manageAttributeToolHandler(db, rawInput) {
 }
 var manageAttributeTool = defineAffinityTool({
   name: manageAttributeToolName,
-  description: "Set, unset, or replace custom metadata attributes on contacts and links. For emails, phones, handles, and URLs use manage_identity instead \u2014 those are routing keys, not attributes.",
+  description: "Set, unset, or replace custom metadata attributes on contacts, links and events. For emails, phones, handles, and URLs use manage_identity instead \u2014 those are routing keys, not attributes.",
   whenToUse: "Use this for metadata such as tags, notes, or small labeled facts attached to a contact or link.",
   whenNotToUse: "Do not use this for core contact fields, identities, or direct relationship mechanics.",
   sideEffects: "writes_state",
@@ -6996,7 +7974,9 @@ var manageAttributeTool = defineAffinityTool({
       action: enumSchema("Operation to perform.", ["set", "unset", "replace"]),
       target: objectSchema(
         {
-          kind: enumSchema("Target kind.", ["contact", "link"]),
+          kind: enumSchema("Target kind.", ["contact", "link", "event"]),
+          eventId: integerSchema("Target event id; provide eventId or ref."),
+          ref: externalRefSchema,
           contact: contactLocatorSchema2(
             "Contact locator. Required when kind=contact. Provide contactId or identity."
           ),
@@ -7026,7 +8006,7 @@ var manageAttributeTool = defineAffinityTool({
       removedAt: integerSchema("Removal timestamp. Optional for action=unset.")
     },
     ["action"],
-    "Set, unset, or replace attributes on contacts and links."
+    "Set, unset, or replace attributes on contacts, links and events."
   ),
   handler: manageAttributeToolHandler
 });
@@ -7058,7 +8038,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",
@@ -7088,6 +8074,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(
@@ -7126,15 +8127,21 @@ var manageCommitmentTool = defineAffinityTool({
             "promise",
             "agreement"
           ]),
+          ...eventMetadataSchema,
           occurredAt: integerSchema(
             "When the commitment was made, Unix timestamp in milliseconds."
           ),
           summary: stringSchema("Commitment summary. Must be non-empty."),
           significance: integerSchema("Commitment significance from 1 to 10."),
           dueAt: integerSchema("Optional due timestamp."),
+          dueOn: stringSchema("Due calendar day."),
           participants: arraySchema(
             objectSchema(
               {
+                contact: objectSchema(
+                  { contactId: integerSchema("Contact id.") },
+                  ["contactId"]
+                ),
                 contactId: integerSchema(
                   "Participant contact id. The owner contact MUST be included."
                 ),
@@ -7147,13 +8154,7 @@ var manageCommitmentTool = defineAffinityTool({
           ),
           now: integerSchema("Optional timestamp override.")
         },
-        [
-          "commitmentType",
-          "occurredAt",
-          "summary",
-          "significance",
-          "participants"
-        ],
+        ["commitmentType", "occurredAt", "significance", "participants"],
         "Commitment payload. Required when action=record."
       ),
       commitmentEventId: integerSchema(
@@ -7168,6 +8169,19 @@ var manageCommitmentTool = defineAffinityTool({
           now: integerSchema("Optional timestamp."),
           resolvingEvent: objectSchema(
             {
+              occurredOn: stringSchema("Calendar day."),
+              provenance: {},
+              participants: arraySchema(
+                objectSchema(
+                  {
+                    contactId: integerSchema("Contact id."),
+                    role: stringSchema("Role."),
+                    directionality: stringSchema("Directionality.")
+                  },
+                  ["contactId", "role"]
+                ),
+                "Resolving participants."
+              ),
               type: stringSchema("Optional resolving event type."),
               occurredAt: integerSchema("Optional resolving event timestamp."),
               summary: stringSchema("Optional resolving event summary."),
@@ -7186,221 +8200,69 @@ var manageCommitmentTool = defineAffinityTool({
     "Record or resolve one commitment."
   ),
   handler: manageCommitmentToolHandler
-});
-
-// src/contacts/delete_contact.ts
-function deleteContact(db, locatorId, options) {
-  if (options?.confirm !== true)
-    throw new AffinityValidationError(
-      "delete is permanent; pass confirm: true"
-    );
-  return withTransaction(db, () => {
-    const contact = db.prepare("SELECT is_owner FROM contacts WHERE id = ?").get(locatorId);
-    if (!contact) throw new AffinityNotFoundError("contact not found");
-    if (contact.is_owner)
-      throw new AffinityStateError("The owner contact cannot be deleted");
-    const tables = [
-      "contacts",
-      "identities",
-      "attributes",
-      "links",
-      "events",
-      "event_participants",
-      "open_commitments",
-      "contact_merges",
-      "dismissed_duplicates",
-      "link_event_effects",
-      "upcoming_occurrences",
-      "link_rollups",
-      "contact_rollups"
-    ];
-    const before = new Map(
-      tables.map((table) => [
-        table,
-        db.prepare(`SELECT rowid AS row_id, * FROM ${table}`).all()
-      ])
-    );
-    db.prepare(
-      "DELETE FROM events WHERE id IN (SELECT p.event_id FROM event_participants p WHERE p.contact_id = ? AND NOT EXISTS (SELECT 1 FROM event_participants q JOIN contacts c ON c.id = q.contact_id WHERE q.event_id = p.event_id AND q.contact_id != ? AND c.is_owner = 0))"
-    ).run(locatorId, locatorId);
-    db.prepare(
-      "DELETE FROM contact_merges WHERE winner_contact_id = ? OR loser_contact_id = ?"
-    ).run(locatorId, locatorId);
-    db.prepare(
-      "DELETE FROM dismissed_duplicates WHERE left_id = ? OR right_id = ?"
-    ).run(locatorId, locatorId);
-    db.prepare(
-      "UPDATE contacts SET merged_into_contact_id = NULL WHERE merged_into_contact_id = ?"
-    ).run(locatorId);
-    db.prepare("DELETE FROM contacts WHERE id = ?").run(locatorId);
-    const now = Date.now();
-    const affectedLinks = db.prepare(
-      "SELECT id FROM links WHERE removed_at IS NULL AND is_structural = 0"
-    ).all().map((row) => row.id);
-    refreshAllBridgeScores(db, now);
-    for (const id of affectedLinks) refreshLinkRollup(db, id, now);
-    for (const row of db.prepare("SELECT id FROM contacts").all())
-      refreshContactRollup(db, Number(row.id), now);
-    const removed = tables.map((table) => {
-      const remaining = new Set(
-        db.prepare(`SELECT rowid AS row_id FROM ${table}`).all().map((row) => row.row_id)
-      );
-      const ids = (before.get(table) ?? []).filter((row) => !remaining.has(row.row_id)).map((row) => Number(row.id ?? row.event_id ?? row.row_id));
-      return { entity: table, count: ids.length, ids };
-    }).filter((item) => item.count > 0);
-    return { contactId: locatorId, removed, affectedLinks };
-  });
-}
-
-// 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/receipts.ts
-function buildIdentityMutationReceipt(primary, partial) {
-  const normalized = normalizeMutationReceiptPartial(partial);
-  return {
-    primary,
-    created: normalized.created,
-    updated: normalized.updated,
-    archived: normalized.archived,
-    removed: normalized.removed,
-    affectedLinks: normalized.affectedLinks,
-    derivedEffects: normalized.derivedEffects
-  };
-}
-
-// src/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);
-  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);
-    throw new AffinityConflictError(
-      `${normalizedKey.replace(":", " ")} already belongs to #${owner?.id} ${owner?.name}`
-    );
-  }
-}
-
-// src/identities/validate_identity_input.ts
-var identityTypes = [
-  "email",
-  "phone",
-  "url",
-  "website",
-  "handle",
-  "x",
-  "twitter",
-  "linkedin",
-  "github",
-  "mastodon",
-  "bluesky",
-  "telegram",
-  "whatsapp",
-  "signal",
-  "matrix",
-  "discord",
-  "slack",
-  "instagram",
-  "facebook",
-  "youtube",
-  "tiktok",
-  "address",
-  "other",
-  "account_id",
-  "alias"
-];
-function validateIdentityInput(type, value) {
-  const kind = type.toLowerCase();
-  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)`
-    );
-  if (!value.trim())
-    throw new AffinityValidationError("identity value must be non-empty");
-  if (kind === "email" && !/^[^\s@]+@[^\s@.]+(?:\.[^\s@.]+)+$/.test(value))
-    throw new AffinityValidationError(
-      "email value must match local@domain.tld"
-    );
-  if (kind === "phone" && value.replace(/\D/g, "").length < 5)
-    throw new AffinityValidationError(
-      "phone value must contain at least 5 digits"
-    );
-  if (kind === "url" || kind === "website") {
-    try {
-      const url = new URL(value.includes("://") ? value : `https://${value}`);
-      if (!["http:", "https:"].includes(url.protocol) || !url.hostname || /\s/.test(value))
-        throw new Error();
-    } catch {
-      throw new AffinityValidationError(
-        "url/website value must be an http/https URL or bare domain"
-      );
-    }
-  }
-}
+});
 
-// src/identities/add_identity.ts
-function addIdentity(db, contactId, input) {
+// src/contacts/delete_contact.ts
+function deleteContact(db, locatorId, options) {
+  if (options?.confirm !== true)
+    throw new AffinityValidationError(
+      "delete is permanent; pass confirm: true"
+    );
   return withTransaction(db, () => {
-    const contact = getContactRowById(db, contactId);
-    if (!contact) {
-      throw new AffinityNotFoundError("contact not found");
-    }
-    if (contact.lifecycle_state === "merged") {
-      throw new AffinityStateError("merged contact is read-only");
-    }
-    const type = input.type.trim();
-    const value = input.value.trim();
-    if (type.length === 0 || value.length === 0) {
-      throw new AffinityValidationError("type and value must be non-empty");
-    }
-    validateIdentityInput(type, value);
-    const nk = normalizeIdentityKey(type, value);
-    assertNoIdentityCollision(db, nk);
-    const now = resolveNow(input.now);
-    const verified = input.verified ? 1 : 0;
-    const verifiedAt = verified === 1 ? now : null;
-    const result = db.prepare(
-      `INSERT INTO identities (contact_id, type, value, label, normalized_key, verified, verified_at, created_at, updated_at)
-         VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`
-    ).run(
-      contactId,
-      type,
-      value,
-      input.label ?? null,
-      nk,
-      verified,
-      verifiedAt,
-      now,
-      now
+    const contact = db.prepare("SELECT is_owner FROM contacts WHERE id = ?").get(locatorId);
+    if (!contact) throw new AffinityNotFoundError("contact not found");
+    if (contact.is_owner)
+      throw new AffinityStateError("The owner contact cannot be deleted");
+    const tables = [
+      "contacts",
+      "identities",
+      "attributes",
+      "links",
+      "events",
+      "event_participants",
+      "open_commitments",
+      "contact_merges",
+      "dismissed_duplicates",
+      "link_event_effects",
+      "upcoming_occurrences",
+      "link_rollups",
+      "contact_rollups"
+    ];
+    const before = new Map(
+      tables.map((table) => [
+        table,
+        db.prepare(`SELECT rowid AS row_id, * FROM ${table}`).all()
+      ])
     );
-    const id = Number(result.lastInsertRowid);
-    const row = getIdentityRowById(db, id);
-    if (!row) {
-      throw new AffinityInvariantError("inserted identity not found");
-    }
-    refreshContactRollup(db, contactId, now);
+    db.prepare(
+      "DELETE FROM events WHERE id IN (SELECT p.event_id FROM event_participants p WHERE p.contact_id = ? AND NOT EXISTS (SELECT 1 FROM event_participants q JOIN contacts c ON c.id = q.contact_id WHERE q.event_id = p.event_id AND q.contact_id != ? AND c.is_owner = 0))"
+    ).run(locatorId, locatorId);
+    db.prepare(
+      "DELETE FROM contact_merges WHERE winner_contact_id = ? OR loser_contact_id = ?"
+    ).run(locatorId, locatorId);
     db.prepare(
       "DELETE FROM dismissed_duplicates WHERE left_id = ? OR right_id = ?"
-    ).run(contactId, contactId);
-    return buildIdentityMutationReceipt(mapIdentityRowToIdentityRecord(row), {
-      created: [{ kind: "identity", id }]
-    });
+    ).run(locatorId, locatorId);
+    db.prepare(
+      "UPDATE contacts SET merged_into_contact_id = NULL WHERE merged_into_contact_id = ?"
+    ).run(locatorId);
+    db.prepare("DELETE FROM contacts WHERE id = ?").run(locatorId);
+    const now = Date.now();
+    const affectedLinks = db.prepare(
+      "SELECT id FROM links WHERE removed_at IS NULL AND is_structural = 0"
+    ).all().map((row) => row.id);
+    refreshAllBridgeScores(db, now);
+    for (const id of affectedLinks) refreshLinkRollup(db, id, now);
+    for (const row of db.prepare("SELECT id FROM contacts").all())
+      refreshContactRollup(db, Number(row.id), now);
+    const removed = tables.map((table) => {
+      const remaining = new Set(
+        db.prepare(`SELECT rowid AS row_id FROM ${table}`).all().map((row) => row.row_id)
+      );
+      const ids = (before.get(table) ?? []).filter((row) => !remaining.has(row.row_id)).map((row) => Number(row.id ?? row.event_id ?? row.row_id));
+      return { entity: table, count: ids.length, ids };
+    }).filter((item) => item.count > 0);
+    return { contactId: locatorId, removed, affectedLinks };
   });
 }
 
@@ -7408,27 +8270,20 @@ function addIdentity(db, contactId, input) {
 function createContactToolResult(db, input) {
   return withTransaction(db, () => {
     const receipt = createContact(db, input);
-    const identityOwners = /* @__PURE__ */ new Set();
-    for (const identity of input.identities ?? []) {
-      validateIdentityInput(identity.type.trim(), identity.value.trim());
-      const existing = db.prepare(
-        "SELECT contact_id FROM identities WHERE normalized_key = ? AND removed_at IS NULL"
-      ).get(normalizeIdentityKey(identity.type, identity.value));
-      if (existing) {
-        if (Number(existing.contact_id) !== receipt.primary.id)
-          identityOwners.add(Number(existing.contact_id));
-        continue;
-      }
-      const added = addIdentity(db, receipt.primary.id, identity);
-      receipt.created.push(...added.created);
-    }
     const result = mutationToolResult("create", receipt, "contact");
+    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})`,
@@ -7511,6 +8366,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",
@@ -7584,7 +8446,11 @@ var manageContactTool = defineAffinityTool({
               },
               ["type", "value"]
             ),
-            "Optional identities to attach. Identities already owned by another contact are left with that owner and reported as possible duplicates."
+            "Optional identities to attach. An identity owned by another live contact causes a conflict, or returns that contact when ifExists=return."
+          ),
+          ifExists: enumSchema(
+            "Identity collision policy; return attaches nothing.",
+            ["error", "return"]
           ),
           name: stringSchema("Contact name."),
           kind: enumSchema("Contact kind.", [
@@ -8003,7 +8869,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");
     }
@@ -8062,6 +8931,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).`
           ),
@@ -8158,6 +9031,10 @@ var manageIdentityTool = defineAffinityTool({
       ),
       input: objectSchema(
         {
+          ifExists: enumSchema(
+            "Return an existing identity on this contact without changes.",
+            ["error", "return"]
+          ),
           type: stringSchema(
             `Identity type: ${identityTypes.join(", ")}, or custom:<name> (lowercase a-z, 0-9, underscore or hyphen).`
           ),
@@ -8492,11 +9369,13 @@ var mergeContactsTool = defineAffinityTool({
 });
 
 // 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,
@@ -8514,12 +9393,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",
@@ -8599,6 +9484,7 @@ var recordEventTool = defineAffinityTool({
               "correction"
             ]
           ),
+          ...eventMetadataSchema,
           occurredAt: integerSchema(
             "When the event occurred, Unix timestamp in milliseconds."
           ),
@@ -8607,6 +9493,19 @@ var recordEventTool = defineAffinityTool({
           participants: arraySchema(
             objectSchema(
               {
+                contact: objectSchema(
+                  {
+                    contactId: integerSchema("Contact id."),
+                    identity: objectSchema(
+                      {
+                        type: stringSchema("Identity type."),
+                        value: stringSchema("Identity value.")
+                      },
+                      ["type", "value"]
+                    )
+                  },
+                  []
+                ),
                 contactId: integerSchema(
                   "Participant contact id. The owner contact MUST be included."
                 ),
@@ -8630,7 +9529,7 @@ var recordEventTool = defineAffinityTool({
           ),
           now: integerSchema("Optional timestamp override.")
         },
-        ["occurredAt", "summary", "significance", "participants"],
+        ["occurredAt", "significance", "participants"],
         "Event payload. Always required. Interaction events also require `type`."
       )
     },
@@ -8669,13 +9568,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)}`;
@@ -8704,6 +9630,8 @@ function summarizeCount(count, singular) {
 // src/tools/review_affinity_tool.ts
 function buildReadOptions(input) {
   return {
+    ...input.includeContent === void 0 ? {} : { includeContent: input.includeContent },
+    ...input.channel === void 0 ? {} : { channel: input.channel },
     ...input.now === void 0 ? {} : { now: input.now },
     ...input.limit === void 0 ? {} : { limit: input.limit },
     ...input.offset === void 0 ? {} : { offset: input.offset },
@@ -8840,7 +9768,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) {
@@ -8850,7 +9778,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) {
@@ -8866,6 +9794,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,
@@ -8903,6 +9832,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)
@@ -8917,6 +9849,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;
@@ -8942,12 +9909,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) {
@@ -9089,6 +10070,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 }
           },
@@ -9138,6 +10120,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"),
@@ -9149,7 +10139,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",
@@ -9195,15 +10185,21 @@ var reviewAffinityTool = defineAffinityTool({
     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",
@@ -9258,7 +10254,20 @@ var reviewAffinityTool = defineAffinityTool({
       includeArchived: booleanSchema("Whether archived links are included."),
       includeObserved: booleanSchema("Whether observed links are included."),
       eventTypes: arraySchema(
-        stringSchema("Event type."),
+        enumSchema("Event type.", [
+          "conversation",
+          "activity",
+          "gift",
+          "support",
+          "milestone",
+          "observation",
+          "conflict",
+          "correction",
+          "transaction",
+          "promise",
+          "agreement",
+          "date_anchor"
+        ]),
         "Optional event-type filter."
       ),
       momentKind: enumSchema("Optional moment kind filter.", [
@@ -9281,13 +10290,17 @@ var reviewAffinityTool = defineAffinityTool({
       ]),
       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"],
@@ -9298,6 +10311,9 @@ var reviewAffinityTool = defineAffinityTool({
 
 // 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)
@@ -9308,11 +10324,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,
       {
@@ -9326,9 +10384,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,
@@ -9364,6 +10428,11 @@ var searchAffinityTool = defineAffinityTool({
   outputDescription: "Returns compact contact hits, the original query, and the hit count.",
   inputSchema: objectSchema(
     {
+      scope: enumSchema("Search scope; defaults to contacts.", [
+        "contacts",
+        "events",
+        "all"
+      ]),
       query: stringSchema("Free-text or natural-key query."),
       kind: enumSchema("Optional contact kind filter.", [
         "human",
@@ -9402,6 +10471,268 @@ var searchAffinityTool = defineAffinityTool({
   handler: searchAffinityToolHandler
 });
 
+// src/events/event_replay.ts
+function replayEventLinks(db, linkIds, now) {
+  const eventIds = /* @__PURE__ */ new Set();
+  for (const linkId of linkIds) {
+    const saved = db.prepare("SELECT state_json FROM event_link_baselines WHERE link_id=?").get(linkId);
+    if (!saved) continue;
+    const baseline = JSON.parse(saved.state_json);
+    const effects = db.prepare(
+      "SELECT event_id, participant_json, provenance_json, created_at FROM link_event_effects WHERE link_id=? ORDER BY event_id"
+    ).all(linkId);
+    const overrides = db.prepare(
+      "SELECT after_event_id,state FROM event_link_state_changes WHERE link_id=? ORDER BY id"
+    ).all(linkId);
+    let overrideIndex = 0;
+    const applyOverrides = (beforeId) => {
+      while (overrideIndex < overrides.length && (overrides[overrideIndex]?.after_event_id ?? Number.POSITIVE_INFINITY) < beforeId) {
+        const override = overrides[overrideIndex];
+        if (override)
+          db.prepare("UPDATE links SET state=? WHERE id=?").run(
+            override.state,
+            linkId
+          );
+        overrideIndex++;
+      }
+    };
+    db.prepare("DELETE FROM link_event_effects WHERE link_id=?").run(linkId);
+    db.prepare(
+      "UPDATE links SET rank=?,affinity=?,trust=?,state=?,cadence_days=?,updated_at=? WHERE id=?"
+    ).run(
+      baseline.rank,
+      baseline.affinity,
+      baseline.trust,
+      baseline.state,
+      baseline.cadence_days,
+      now,
+      linkId
+    );
+    for (const effect of effects) {
+      eventIds.add(effect.event_id);
+      applyOverrides(effect.event_id);
+      if (!db.prepare("SELECT id FROM events WHERE id=? AND deleted_at IS NULL").get(effect.event_id))
+        continue;
+      const event = loadEventRecord(db, effect.event_id);
+      const link = db.prepare("SELECT from_contact_id,to_contact_id FROM links WHERE id=?").get(linkId);
+      const participant = effect.participant_json ? JSON.parse(effect.participant_json) : event.participants.find((p) => p.contactId === link.to_contact_id) ?? event.participants[0];
+      const provenance = db.prepare("SELECT provenance_json FROM events WHERE id=?").get(event.id);
+      applyEventEffectToLink(db, {
+        linkId,
+        eventId: event.id,
+        eventType: event.type,
+        occurredAt: event.occurredAt,
+        significance: event.significance,
+        participant,
+        provenance: provenance.provenance_json ? JSON.parse(provenance.provenance_json) : effect.provenance_json ? JSON.parse(effect.provenance_json) : void 0,
+        now: effect.created_at
+      });
+    }
+    applyOverrides(Number.POSITIVE_INFINITY);
+    refreshLinkRollup(db, linkId, now);
+  }
+  for (const eventId of eventIds)
+    db.prepare(
+      "UPDATE events SET moment_kind=COALESCE(declared_moment_kind,(SELECT moment_kind FROM link_event_effects WHERE event_id=events.id AND moment_kind IS NOT NULL ORDER BY link_id LIMIT 1)) WHERE id=?"
+    ).run(eventId);
+  refreshAllBridgeScores(db, now);
+}
+
+// src/events/manage_event.ts
+function requireEventTarget(db, target) {
+  const selector = typeof target === "number" ? { eventId: target } : target;
+  if (!selector || selector.eventId === void 0 === (selector.ref === void 0))
+    throw new AffinityValidationError("Provide exactly one of eventId or ref");
+  const event = selector.ref ? getEventByExternalRef(db, selector.ref.source, selector.ref.id) : getEventById(db, selector.eventId);
+  if (!event) throw new AffinityNotFoundError("event not found");
+  return event;
+}
+function affected(db, id) {
+  return db.prepare("SELECT link_id FROM link_event_effects WHERE event_id=?").all(id).map((r) => r.link_id);
+}
+function reviseEvent(db, target, patch) {
+  return withTransaction(db, () => {
+    const allowed = [
+      "summary",
+      "content",
+      "occurredAt",
+      "significance",
+      "channel",
+      "type",
+      "externalRef"
+    ];
+    for (const key of Object.keys(patch))
+      if (!allowed.includes(key))
+        throw new AffinityValidationError(
+          `unknown patch key ${key}; allowed keys: ${allowed.join(", ")}`
+        );
+    const event = requireEventTarget(db, target);
+    const next = { ...event, ...patch };
+    const { momentKind: _momentKind, ...metadata } = next;
+    validateEventMetadata(metadata);
+    Object.assign(next, metadata);
+    if (patch.summary !== void 0 && (typeof patch.summary !== "string" || !patch.summary.trim()))
+      throw new AffinityValidationError("summary must be non-empty");
+    if (patch.occurredAt !== void 0)
+      assertFiniteTimestamp(patch.occurredAt, "occurredAt");
+    if (!Number.isInteger(next.significance) || next.significance < 1 || next.significance > 10)
+      throw new AffinityValidationError(
+        "significance must be an integer from 1 to 10"
+      );
+    const interactions = [
+      "conversation",
+      "activity",
+      "gift",
+      "support",
+      "conflict",
+      "correction"
+    ];
+    if (next.type !== event.type && !(interactions.includes(event.type) && interactions.includes(next.type)) && !(["promise", "agreement"].includes(event.type) && ["promise", "agreement"].includes(next.type)))
+      throw new AffinityValidationError(
+        "type must stay within the same event kind"
+      );
+    if (patch.externalRef && event.externalRef)
+      throw new AffinityConflictError(
+        "externalRef can only be set when absent"
+      );
+    if (patch.externalRef && next.externalRef && getEventByExternalRef(db, next.externalRef.source, next.externalRef.id))
+      throw new AffinityConflictError(
+        "externalRef already belongs to an event"
+      );
+    const now = Date.now();
+    const links = affected(db, event.id);
+    db.prepare(
+      "UPDATE events SET summary=?,content=?,occurred_at=?,occurred_on=?,significance=?,channel=?,type=?,external_source=?,external_id=?,updated_at=? WHERE id=?"
+    ).run(
+      next.summary.trim(),
+      next.content ?? null,
+      next.occurredAt,
+      patch.occurredAt === void 0 ? event.occurredOn ?? null : new Date(next.occurredAt).toISOString().slice(0, 10),
+      next.significance,
+      next.channel ?? null,
+      next.type,
+      next.externalRef?.source ?? null,
+      next.externalRef?.id ?? null,
+      now,
+      event.id
+    );
+    if (patch.type && ["promise", "agreement"].includes(patch.type))
+      db.prepare(
+        "UPDATE open_commitments SET commitment_type=? WHERE event_id=?"
+      ).run(patch.type, event.id);
+    if (patch.significance !== void 0 || patch.type !== void 0 || patch.occurredAt !== void 0)
+      replayEventLinks(db, links, now);
+    return buildEventMutationReceipt(requireEventTarget(db, event.id), {
+      updated: [{ kind: "event", id: event.id }],
+      affectedLinks: links
+    });
+  });
+}
+function deleteEvent(db, target, options) {
+  return withTransaction(db, () => {
+    if (options?.confirm !== true)
+      throw new AffinityValidationError("deleteEvent requires confirm: true");
+    const event = requireEventTarget(db, target);
+    const links = affected(db, event.id);
+    for (const table of [
+      "event_participants",
+      "attributes",
+      "open_commitments",
+      "upcoming_occurrences",
+      "link_event_effects"
+    ])
+      db.prepare(`DELETE FROM ${table} WHERE event_id=?`).run(event.id);
+    db.prepare(
+      "UPDATE events SET parent_event_id=NULL WHERE parent_event_id=?"
+    ).run(event.id);
+    db.prepare("DELETE FROM events WHERE id=?").run(event.id);
+    replayEventLinks(db, links, Date.now());
+    return buildEventMutationReceipt(event, {
+      removed: [{ kind: "event", id: event.id }],
+      affectedLinks: links
+    });
+  });
+}
+
+// src/tools/manage_event_tool.ts
+function manageEventToolHandler(db, raw) {
+  const input = structuredClone(raw);
+  const error = validateToolInput(
+    manageEventTool.inputSchema,
+    input,
+    "input",
+    Date.now(),
+    true
+  );
+  if (error)
+    return toolFailure("protocol", "invalid_input", "Invalid input.", error);
+  return withToolHandling(() => {
+    const target = {
+      ...input.eventId === void 0 ? {} : { eventId: input.eventId },
+      ...input.ref === void 0 ? {} : { ref: input.ref }
+    };
+    return mutationToolResult(
+      input.action,
+      input.action === "revise" ? reviseEvent(db, target, input.patch ?? {}) : deleteEvent(db, target, { confirm: input.confirm === true }),
+      "event"
+    );
+  }, "Event management failed.");
+}
+var manageEventTool = defineAffinityTool({
+  name: manageEventToolName,
+  description: "Revise or delete one event by eventId or external reference. Delete requires confirm=true and recomputes affected relationships.",
+  whenToUse: "Correct imported event text or metadata, or remove an event.",
+  whenNotToUse: "Use record_event to capture new evidence.",
+  sideEffects: "writes_state",
+  readOnly: false,
+  supportsClarification: false,
+  targetKinds: ["event"],
+  inputDescriptions: {
+    action: "revise or delete",
+    eventId: "Exact event id",
+    ref: "External event reference",
+    patch: "Fields to revise",
+    confirm: "Required true for deletion"
+  },
+  outputDescription: "Event mutation receipt and affected links.",
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Action.", ["revise", "delete"]),
+      eventId: integerSchema("Event id; provide eventId or ref."),
+      ref: externalRefSchema,
+      confirm: booleanSchema("Must be true to delete."),
+      patch: objectSchema(
+        {
+          summary: stringSchema("Short non-empty label."),
+          content: stringSchema("Verbatim content, at most 1 MB UTF-8."),
+          occurredAt: integerSchema("Event timestamp."),
+          significance: integerSchema("Significance 1..10."),
+          channel: stringSchema("Channel, at most 40 characters."),
+          type: enumSchema("Type within the same event kind.", [
+            "conversation",
+            "activity",
+            "gift",
+            "support",
+            "conflict",
+            "correction",
+            "observation",
+            "milestone",
+            "transaction",
+            "promise",
+            "agreement",
+            "date_anchor"
+          ]),
+          externalRef: externalRefSchema
+        },
+        [],
+        "Fields to revise; externalRef may only be added when absent."
+      )
+    },
+    ["action"]
+  ),
+  handler: manageEventToolHandler
+});
+
 // src/tools/tool_registry.ts
 var affinityTools = [
   searchAffinityTool,
@@ -9415,7 +10746,8 @@ var affinityTools = [
   recordEventTool,
   manageCommitmentTool,
   manageDateAnchorTool,
-  manageAttributeTool
+  manageAttributeTool,
+  manageEventTool
 ];
 function listAffinityToolDefinitions() {
   return [...affinityTools];
@@ -9426,6 +10758,24 @@ function getAffinityToolByName(name) {
 
 // src/tools/tool_mapping.ts
 var affinityToolMappings = [
+  {
+    source: "getEventById",
+    tool: inspectAffinityItemToolName,
+    action: "event"
+  },
+  {
+    source: "getEventByExternalRef",
+    tool: inspectAffinityItemToolName,
+    action: "event"
+  },
+  {
+    source: "getEventThread",
+    tool: reviewAffinityToolName,
+    view: "events.thread"
+  },
+  { source: "searchEvents", tool: searchAffinityToolName },
+  { source: "reviseEvent", tool: "manage_event", action: "revise" },
+  { source: "deleteEvent", tool: "manage_event", action: "delete" },
   { source: "exportContact", tool: manageContactToolName, action: "export" },
   { source: "exportAffinity", tool: manageContactToolName, action: "export" },
   { source: "deleteContact", tool: manageContactToolName, action: "delete" },
@@ -9616,6 +10966,7 @@ __export(write_exports, {
   addIdentity: () => addIdentity,
   createContact: () => createContact,
   deleteContact: () => deleteContact,
+  deleteEvent: () => deleteEvent,
   dismissDuplicate: () => dismissDuplicate,
   mergeContacts: () => mergeContacts,
   overrideLinkState: () => overrideLinkState,
@@ -9632,6 +10983,7 @@ __export(write_exports, {
   reviseBond: () => reviseBond,
   reviseContact: () => reviseContact,
   reviseDateAnchor: () => reviseDateAnchor,
+  reviseEvent: () => reviseEvent,
   reviseIdentity: () => reviseIdentity,
   seedSocialLink: () => seedSocialLink,
   setAttribute: () => setAttribute,