@ghostpaw/affinity 0.1.3 → 0.1.5

package/dist/index.js

@@ -1452,8 +1452,8 @@ function searchContacts(db, query, filters, options) {
     GROUP BY c.id
   `;
   const rows = db.prepare(sql).all(
-    ...params,
     normalizedPattern,
+    ...params,
     pattern,
     pattern,
     normalizedPattern
@@ -4598,7 +4598,9 @@ Your second boundary is type of truth. Structural ties, owner-facing social link
 
 Your third boundary is between declared fact and derived mechanics. The system owns what it derives: Rank, hidden Affinity, Trust movement, Moments, drift, readiness, bridge significance, and Radar signals. You read those surfaces seriously, but you do not worship them or try to narratively override them. A score is a cue to inspect context, not permission to act blindly. Review surfaces help the operator notice, prioritize, and remember; they do not replace judgment.
 
-You also think in rhythms. Affinity is not only for dramatic relationship beats. Its value comes from maintenance: keeping identities clean, resolving duplicates carefully, recording direct evidence honestly, honoring commitments, tending important dates, and checking Radar before drift becomes neglect. Whether the operator is tending friendships, clients, collaborators, recruits, patients, referral networks, or AI-assisted memory, the mission is the same: cultivate a relationship graph that stays trustworthy, legible, and alive over time.`;
+You also think in rhythms. Affinity is not only for dramatic relationship beats. Its value comes from maintenance: keeping identities clean, resolving duplicates carefully, recording direct evidence honestly, honoring commitments, tending important dates, and checking Radar before drift becomes neglect. Whether the operator is tending friendships, clients, collaborators, recruits, patients, referral networks, or AI-assisted memory, the mission is the same: cultivate a relationship graph that stays trustworthy, legible, and alive over time.
+
+In practice, this means: search before you create, attach identities before you seed links, seed links before you record events, and anchor dates when they are mentioned \u2014 not later.`;
 var affinitySoulTraits = [
   {
     principle: "Honor evidence before narrative.",
@@ -4619,6 +4621,10 @@ var affinitySoulTraits = [
   {
     principle: "Protect relationship integrity over time.",
     provenance: "A good relationship memory is maintained, not merely captured. Clean identities, honest commitment resolution, careful merges, and recurring review keep the graph trustworthy across personal and business use cases."
+  },
+  {
+    principle: "Follow the operational protocol.",
+    provenance: "Search before you create \u2014 every time a person, company, or entity is mentioned, call search_affinity first; duplicates corrupt the entire graph. Attach identities (emails, phones, handles, URLs) with manage_identity, not manage_attribute \u2014 if it could locate a person, it is an identity. Seed links for every stated relationship on first mention with manage_relationship \u2014 do not wait for repeated evidence. Anchor recurring dates (birthdays, anniversaries, yearly events) immediately with manage_date_anchor \u2014 do not store them as attributes."
   }
 ];
 var affinitySoul = {
@@ -5849,48 +5855,38 @@ function affinityErrorCodeToToolCode(error) {
 
 // src/tools/inspect_affinity_item_tool.ts
 function contactLocatorSchema(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
+  return {
+    type: "object",
+    properties: {
+      contactId: integerSchema("Exact contact id."),
+      identity: objectSchema(
         {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"],
-            "Contact identity locator."
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value.")
         },
-        ["identity"]
+        ["type", "value"],
+        "Contact identity locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function linkLocatorSchema(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ linkId: integerSchema("Exact link id.") }, ["linkId"]),
-      objectSchema(
+  return {
+    type: "object",
+    properties: {
+      linkId: integerSchema("Exact link id."),
+      endpoints: objectSchema(
         {
-          endpoints: objectSchema(
-            {
-              fromContactId: integerSchema("From contact id."),
-              toContactId: integerSchema("To contact id.")
-            },
-            ["fromContactId", "toContactId"],
-            "Endpoint-based link locator."
-          )
+          fromContactId: integerSchema("From contact id."),
+          toContactId: integerSchema("To contact id.")
         },
-        ["endpoints"]
+        ["fromContactId", "toContactId"],
+        "Endpoint-based link locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function inspectAffinityItemToolHandler(db, input) {
   return withToolHandling(() => {
@@ -5983,32 +5979,23 @@ var inspectAffinityItemTool = defineAffinityTool({
     recentEventsLimit: "Optional recent-events cap for link detail."
   },
   outputDescription: "Returns one shaped detail object and dense entity references for the inspected item.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
-        {
-          kind: literalSchema("owner_profile"),
-          topLinksLimit: integerSchema("Optional top-links cap.")
-        },
-        ["kind"]
+  inputSchema: objectSchema(
+    {
+      kind: enumSchema("What to inspect.", [
+        "owner_profile",
+        "contact_profile",
+        "link"
+      ]),
+      contact: contactLocatorSchema(
+        "Target contact. Required when kind=contact_profile. Provide contactId or identity."
       ),
-      objectSchema(
-        {
-          kind: literalSchema("contact_profile"),
-          contact: contactLocatorSchema("Target contact."),
-          topLinksLimit: integerSchema("Optional top-links cap.")
-        },
-        ["kind", "contact"]
+      link: linkLocatorSchema(
+        "Target link. Required when kind=link. Provide linkId or endpoints."
       ),
-      objectSchema(
-        {
-          kind: literalSchema("link"),
-          link: linkLocatorSchema("Target link."),
-          recentEventsLimit: integerSchema("Optional recent-events cap.")
-        },
-        ["kind", "link"]
-      )
-    ],
+      topLinksLimit: integerSchema("Optional top-links cap."),
+      recentEventsLimit: integerSchema("Optional recent-events cap.")
+    },
+    ["kind"],
     "Inspect one exact affinity item."
   ),
   handler: inspectAffinityItemToolHandler
@@ -6320,49 +6307,38 @@ function mutationToolResult(action, receipt, entitySummary) {
 
 // src/tools/manage_attribute_tool.ts
 function contactLocatorSchema2(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
+  return {
+    type: "object",
+    properties: {
+      contactId: integerSchema("Exact contact id."),
+      identity: objectSchema(
         {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"]
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value.")
         },
-        ["identity"]
+        ["type", "value"],
+        "Contact identity locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function linkLocatorSchema2(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ linkId: integerSchema("Exact link id.") }, ["linkId"]),
-      objectSchema(
+  return {
+    type: "object",
+    properties: {
+      linkId: integerSchema("Exact link id."),
+      endpoints: objectSchema(
         {
-          endpoints: objectSchema(
-            {
-              fromContactId: integerSchema("From contact id."),
-              toContactId: integerSchema("To contact id."),
-              kind: stringSchema("Optional link kind."),
-              role: stringSchema("Optional link role."),
-              isStructural: booleanSchema("Optional structural discriminator.")
-            },
-            ["fromContactId", "toContactId"]
-          )
+          fromContactId: integerSchema("From contact id."),
+          toContactId: integerSchema("To contact id.")
         },
-        ["endpoints"]
+        ["fromContactId", "toContactId"],
+        "Endpoint-based link locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function resolveAttributeTarget(db, target) {
   if (target.kind === "contact") {
@@ -6408,7 +6384,7 @@ function manageAttributeToolHandler(db, input) {
 }
 var manageAttributeTool = defineAffinityTool({
   name: manageAttributeToolName,
-  description: "Set, unset, or replace attributes on contacts and links.",
+  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.",
   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",
@@ -6424,135 +6400,47 @@ var manageAttributeTool = defineAffinityTool({
     entries: "Replacement attribute set for the target."
   },
   outputDescription: "Returns the primary attribute plus the mutation receipt fields needed to understand what changed.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Operation to perform.", ["set", "unset", "replace"]),
+      target: objectSchema(
         {
-          action: literalSchema("set"),
-          target: oneOfSchema(
-            [
-              objectSchema(
-                {
-                  kind: literalSchema("contact"),
-                  contact: contactLocatorSchema2("Target contact.")
-                },
-                ["kind", "contact"]
-              ),
-              objectSchema(
-                {
-                  kind: literalSchema("link"),
-                  link: linkLocatorSchema2("Target link.")
-                },
-                ["kind", "link"]
-              )
-            ],
-            "Attribute target."
+          kind: enumSchema("Target kind.", ["contact", "link"]),
+          contact: contactLocatorSchema2(
+            "Contact locator. Required when kind=contact. Provide contactId or identity."
           ),
-          name: stringSchema("Attribute name."),
-          value: nullableStringSchema(
-            "Attribute value, or null for presence/tag semantics."
+          link: linkLocatorSchema2(
+            "Link locator. Required when kind=link. Provide linkId or endpoints."
           )
         },
-        ["action", "target", "name"]
+        ["kind"],
+        "Attribute target. Always required."
       ),
-      objectSchema(
-        {
-          action: literalSchema("unset"),
-          target: oneOfSchema(
-            [
-              objectSchema(
-                {
-                  kind: literalSchema("contact"),
-                  contact: contactLocatorSchema2("Target contact.")
-                },
-                ["kind", "contact"]
-              ),
-              objectSchema(
-                {
-                  kind: literalSchema("link"),
-                  link: linkLocatorSchema2("Target link.")
-                },
-                ["kind", "link"]
-              )
-            ],
-            "Attribute target."
-          ),
-          name: stringSchema("Attribute name."),
-          removedAt: integerSchema("Optional removal timestamp.")
-        },
-        ["action", "target", "name"]
+      name: stringSchema("Attribute name. Required when action=set or unset."),
+      value: nullableStringSchema(
+        "Attribute value. Required when action=set. Null for presence/tag semantics."
       ),
-      objectSchema(
-        {
-          action: literalSchema("replace"),
-          target: oneOfSchema(
-            [
-              objectSchema(
-                {
-                  kind: literalSchema("contact"),
-                  contact: contactLocatorSchema2("Target contact.")
-                },
-                ["kind", "contact"]
-              ),
-              objectSchema(
-                {
-                  kind: literalSchema("link"),
-                  link: linkLocatorSchema2("Target link.")
-                },
-                ["kind", "link"]
-              )
-            ],
-            "Attribute target."
-          ),
-          entries: arraySchema(
-            objectSchema(
-              {
-                name: stringSchema("Attribute name."),
-                value: nullableStringSchema(
-                  "Attribute value, or null for presence/tag semantics."
-                )
-              },
-              ["name"]
-            ),
-            "Replacement attribute entries."
-          )
-        },
-        ["action", "target", "entries"]
-      )
-    ],
-    "Manage attributes."
-  ),
-  handler: manageAttributeToolHandler
-});
-
-// src/tools/manage_commitment_tool.ts
-function commitmentInputSchema() {
-  return objectSchema(
-    {
-      commitmentType: enumSchema("Promise or agreement.", [
-        "promise",
-        "agreement"
-      ]),
-      occurredAt: integerSchema("When the commitment was made."),
-      summary: stringSchema("Commitment summary."),
-      significance: integerSchema("Commitment significance."),
-      dueAt: integerSchema("Optional due timestamp."),
-      participants: arraySchema(
+      entries: arraySchema(
         objectSchema(
           {
-            contactId: integerSchema("Participant contact id."),
-            role: stringSchema("Participant role."),
-            directionality: stringSchema("Optional directionality.")
+            name: stringSchema("Attribute name."),
+            value: nullableStringSchema(
+              "Attribute value, or null for presence/tag semantics."
+            )
           },
-          ["contactId", "role"]
+          ["name"]
         ),
-        "Participant list."
+        "Key-value map to replace all attributes. Required when action=replace."
       ),
-      now: integerSchema("Optional timestamp.")
+      removedAt: integerSchema("Removal timestamp. Optional for action=unset.")
     },
-    ["commitmentType", "occurredAt", "summary", "significance", "participants"]
-  );
-}
+    ["action"],
+    "Set, unset, or replace attributes on contacts and links."
+  ),
+  handler: manageAttributeToolHandler
+});
+
+// src/tools/manage_commitment_tool.ts
 function manageCommitmentToolHandler(db, input) {
   return withToolHandling(() => {
     if (input.action === "record") {
@@ -6591,75 +6479,62 @@ var manageCommitmentTool = defineAffinityTool({
     options: "Optional resolution metadata and resolving event data."
   },
   outputDescription: "Returns the commitment mutation receipt, including linked event creation and derived link effects.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
-        {
-          action: literalSchema("record"),
-          input: commitmentInputSchema()
-        },
-        ["action", "input"]
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Operation to perform.", ["record", "resolve"]),
+      input: {
+        type: "object",
+        description: "Commitment payload. Required when action=record."
+      },
+      commitmentEventId: integerSchema(
+        "Commitment event id. Required when action=resolve."
+      ),
+      resolution: enumSchema(
+        "How the commitment was resolved. Required when action=resolve.",
+        ["kept", "cancelled", "broken"]
       ),
-      objectSchema(
+      options: objectSchema(
         {
-          action: literalSchema("resolve"),
-          commitmentEventId: integerSchema("Commitment event id."),
-          resolution: enumSchema("Commitment resolution.", [
-            "kept",
-            "cancelled",
-            "broken"
-          ]),
-          options: objectSchema(
+          now: integerSchema("Optional timestamp."),
+          resolvingEvent: objectSchema(
             {
-              now: integerSchema("Optional timestamp."),
-              resolvingEvent: objectSchema(
-                {
-                  type: stringSchema("Optional resolving event type."),
-                  occurredAt: integerSchema(
-                    "Optional resolving event timestamp."
-                  ),
-                  summary: stringSchema("Optional resolving event summary."),
-                  significance: integerSchema(
-                    "Optional resolving event significance."
-                  )
-                },
-                []
+              type: stringSchema("Optional resolving event type."),
+              occurredAt: integerSchema("Optional resolving event timestamp."),
+              summary: stringSchema("Optional resolving event summary."),
+              significance: integerSchema(
+                "Optional resolving event significance."
               )
             },
             []
           )
         },
-        ["action", "commitmentEventId", "resolution"]
+        [],
+        "Optional metadata."
       )
-    ],
-    "Manage commitments."
+    },
+    ["action"],
+    "Record or resolve one commitment."
   ),
   handler: manageCommitmentToolHandler
 });
 
 // src/tools/manage_contact_tool.ts
 function contactLocatorSchema3(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
+  return {
+    type: "object",
+    properties: {
+      contactId: integerSchema("Exact contact id."),
+      identity: objectSchema(
         {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"],
-            "Contact identity locator."
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value.")
         },
-        ["identity"]
+        ["type", "value"],
+        "Contact identity locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function manageContactToolHandler(db, input) {
   return withToolHandling(() => {
@@ -6695,7 +6570,7 @@ function manageContactToolHandler(db, input) {
 }
 var manageContactTool = defineAffinityTool({
   name: manageContactToolName,
-  description: "Create a contact, revise one contact's core fields, or change lifecycle state.",
+  description: "Create a contact, revise one contact's core fields, or change lifecycle state. ALWAYS search_affinity first before creating \u2014 duplicates corrupt the graph.",
   whenToUse: "Use this for contact creation and lifecycle-safe contact maintenance.",
   whenNotToUse: "Do not use this for identities, links, attributes, or merges.",
   sideEffects: "writes_state",
@@ -6711,120 +6586,62 @@ var manageContactTool = defineAffinityTool({
     options: "Optional lifecycle metadata such as now and provenance."
   },
   outputDescription: "Returns the primary contact plus the mutation receipt fields needed to understand what changed.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Operation to perform.", [
+        "create",
+        "revise",
+        "set_lifecycle"
+      ]),
+      input: objectSchema(
         {
-          action: literalSchema("create"),
-          input: objectSchema(
-            {
-              name: stringSchema("Contact name."),
-              kind: enumSchema("Contact kind.", [
-                "human",
-                "group",
-                "company",
-                "team",
-                "pet",
-                "service",
-                "other"
-              ]),
-              now: integerSchema("Optional timestamp."),
-              bootstrapOwner: booleanSchema(
-                "Whether this contact should be the owner."
-              )
-            },
-            ["name", "kind"],
-            "New contact payload."
+          name: stringSchema("Contact name."),
+          kind: enumSchema("Contact kind.", [
+            "human",
+            "group",
+            "company",
+            "team",
+            "pet",
+            "service",
+            "other"
+          ]),
+          now: integerSchema("Optional timestamp."),
+          bootstrapOwner: booleanSchema(
+            "Whether this contact should be the owner."
           )
         },
-        ["action", "input"]
+        ["name", "kind"],
+        "New contact payload. Required when action=create."
       ),
-      objectSchema(
+      contact: contactLocatorSchema3(
+        "Target contact. Required when action=revise or set_lifecycle. Provide contactId or identity."
+      ),
+      patch: objectSchema(
         {
-          action: literalSchema("revise"),
-          contact: contactLocatorSchema3("Target contact."),
-          patch: objectSchema(
-            {
-              name: stringSchema("Optional replacement name.")
-            },
-            [],
-            "Allowed contact patch."
-          )
+          name: stringSchema("Optional replacement name.")
         },
-        ["action", "contact", "patch"]
+        [],
+        "Allowed contact patch. Required when action=revise."
+      ),
+      lifecycleState: enumSchema(
+        "Target lifecycle state. Required when action=set_lifecycle.",
+        ["active", "dormant", "merged", "lost"]
       ),
-      objectSchema(
+      options: objectSchema(
         {
-          action: literalSchema("set_lifecycle"),
-          contact: contactLocatorSchema3("Target contact."),
-          lifecycleState: enumSchema("Target lifecycle state.", [
-            "active",
-            "dormant",
-            "merged",
-            "lost"
-          ]),
-          options: objectSchema(
-            {
-              now: integerSchema("Optional timestamp.")
-            },
-            [],
-            "Optional lifecycle metadata."
-          )
+          now: integerSchema("Optional timestamp.")
         },
-        ["action", "contact", "lifecycleState"]
+        [],
+        "Optional lifecycle metadata."
       )
-    ],
+    },
+    ["action"],
     "Manage contacts."
   ),
   handler: manageContactToolHandler
 });
 
 // src/tools/manage_date_anchor_tool.ts
-function contactLocatorSchema4(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
-        {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"]
-          )
-        },
-        ["identity"]
-      )
-    ],
-    description
-  );
-}
-function linkLocatorSchema3(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ linkId: integerSchema("Exact link id.") }, ["linkId"]),
-      objectSchema(
-        {
-          endpoints: objectSchema(
-            {
-              fromContactId: integerSchema("From contact id."),
-              toContactId: integerSchema("To contact id."),
-              kind: stringSchema("Optional link kind."),
-              role: stringSchema("Optional link role."),
-              isStructural: booleanSchema("Optional structural discriminator.")
-            },
-            ["fromContactId", "toContactId"]
-          )
-        },
-        ["endpoints"]
-      )
-    ],
-    description
-  );
-}
 function resolveDateAnchorTarget(db, target) {
   if (target.kind === "contact") {
     const contact = resolveContactLocator(db, target.contact, "target.contact");
@@ -6871,7 +6688,7 @@ function manageDateAnchorToolHandler(db, input) {
 }
 var manageDateAnchorTool = defineAffinityTool({
   name: manageDateAnchorToolName,
-  description: "Add, revise, or remove recurring date anchors on contacts or links.",
+  description: "Add, revise, or remove recurring date anchors on contacts or links. Use this for birthdays, anniversaries, and yearly events \u2014 not manage_attribute.",
   whenToUse: "Use this for birthdays, anniversaries, renewals, memorials, and other recurring anchors.",
   whenNotToUse: "Do not use this for one-off events or relationship state changes.",
   sideEffects: "writes_state",
@@ -6887,102 +6704,34 @@ var manageDateAnchorTool = defineAffinityTool({
     removedAt: "Optional removal timestamp."
   },
   outputDescription: "Returns the date-anchor mutation receipt, including any recomputed upcoming occurrences.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
-        {
-          action: literalSchema("add"),
-          input: objectSchema(
-            {
-              target: oneOfSchema(
-                [
-                  objectSchema(
-                    {
-                      kind: literalSchema("contact"),
-                      contact: contactLocatorSchema4("Target contact.")
-                    },
-                    ["kind", "contact"]
-                  ),
-                  objectSchema(
-                    {
-                      kind: literalSchema("link"),
-                      link: linkLocatorSchema3("Target link.")
-                    },
-                    ["kind", "link"]
-                  )
-                ],
-                "Date-anchor target."
-              ),
-              recurrenceKind: enumSchema("Recurrence kind.", [
-                "birthday",
-                "anniversary",
-                "renewal",
-                "memorial",
-                "custom_yearly"
-              ]),
-              anchorMonth: integerSchema("Anchor month."),
-              anchorDay: integerSchema("Anchor day."),
-              summary: stringSchema("Summary."),
-              significance: integerSchema("Significance."),
-              now: integerSchema("Optional timestamp."),
-              force: booleanSchema(
-                "Whether duplicate checks should be bypassed."
-              )
-            },
-            [
-              "target",
-              "recurrenceKind",
-              "anchorMonth",
-              "anchorDay",
-              "summary",
-              "significance"
-            ]
-          )
-        },
-        ["action", "input"]
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Operation to perform.", ["add", "revise", "remove"]),
+      input: {
+        type: "object",
+        description: "Date anchor payload. Required when action=add."
+      },
+      anchorEventId: integerSchema(
+        "Anchor event id. Required when action=revise or remove."
       ),
-      objectSchema(
+      patch: {
+        type: "object",
+        description: "Anchor patch. Required when action=revise."
+      },
+      options: objectSchema(
         {
-          action: literalSchema("revise"),
-          anchorEventId: integerSchema("Anchor event id."),
-          patch: objectSchema(
-            {
-              recurrenceKind: enumSchema("Optional recurrence kind.", [
-                "birthday",
-                "anniversary",
-                "renewal",
-                "memorial",
-                "custom_yearly"
-              ]),
-              anchorMonth: integerSchema("Optional month."),
-              anchorDay: integerSchema("Optional day."),
-              summary: stringSchema("Optional summary."),
-              significance: integerSchema("Optional significance.")
-            },
-            []
-          ),
-          options: objectSchema(
-            {
-              now: integerSchema("Optional timestamp."),
-              force: booleanSchema(
-                "Whether duplicate checks should be bypassed."
-              )
-            },
-            []
-          )
+          now: integerSchema("Optional timestamp."),
+          force: booleanSchema("Whether duplicate checks should be bypassed.")
         },
-        ["action", "anchorEventId", "patch"]
+        [],
+        "Optional metadata."
       ),
-      objectSchema(
-        {
-          action: literalSchema("remove"),
-          anchorEventId: integerSchema("Anchor event id."),
-          removedAt: integerSchema("Optional removal timestamp.")
-        },
-        ["action", "anchorEventId"]
+      removedAt: integerSchema(
+        "Removal timestamp. Optional for action=remove."
       )
-    ],
-    "Manage date anchors."
+    },
+    ["action"],
+    "Add, revise, or remove recurring date anchors."
   ),
   handler: manageDateAnchorToolHandler
 });
@@ -7170,27 +6919,22 @@ function verifyIdentity(db, identityId, verifiedAt) {
 }
 
 // src/tools/manage_identity_tool.ts
-function contactLocatorSchema5(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
+function contactLocatorSchema4(description) {
+  return {
+    type: "object",
+    properties: {
+      contactId: integerSchema("Exact contact id."),
+      identity: objectSchema(
         {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"]
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value.")
         },
-        ["identity"]
+        ["type", "value"],
+        "Contact identity locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function manageIdentityToolHandler(db, input) {
   return withToolHandling(() => {
@@ -7229,7 +6973,7 @@ function manageIdentityToolHandler(db, input) {
 }
 var manageIdentityTool = defineAffinityTool({
   name: manageIdentityToolName,
-  description: "Add, revise, verify, or remove one routing identity on a contact.",
+  description: "Add, revise, verify, or remove one routing identity on a contact. Use this for emails, phone numbers, social handles, and URLs \u2014 anything that could locate a person. Do not use manage_attribute for these.",
   whenToUse: "Use this for contact identity management such as email, handle, or phone routing keys.",
   whenNotToUse: "Do not use this for contact core fields, links, or attributes.",
   sideEffects: "writes_state",
@@ -7246,107 +6990,90 @@ var manageIdentityTool = defineAffinityTool({
     removedAt: "Optional removal timestamp."
   },
   outputDescription: "Returns the primary identity plus the mutation receipt fields needed to understand what changed.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
-        {
-          action: literalSchema("add"),
-          contact: contactLocatorSchema5("Target contact."),
-          input: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value."),
-              label: stringSchema("Optional label."),
-              verified: booleanSchema("Whether the identity starts verified."),
-              now: integerSchema("Optional timestamp.")
-            },
-            ["type", "value"]
-          )
-        },
-        ["action", "contact", "input"]
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Operation to perform.", [
+        "add",
+        "revise",
+        "verify",
+        "remove"
+      ]),
+      contact: contactLocatorSchema4(
+        "Target contact. Required when action=add. Provide contactId or identity."
       ),
-      objectSchema(
+      input: objectSchema(
         {
-          action: literalSchema("revise"),
-          identityId: integerSchema("Identity id."),
-          patch: objectSchema(
-            {
-              type: stringSchema("Optional identity type."),
-              value: stringSchema("Optional identity value."),
-              label: stringSchema("Optional label.")
-            },
-            []
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value."),
+          label: stringSchema("Optional label."),
+          verified: booleanSchema("Whether the identity starts verified."),
+          now: integerSchema("Optional timestamp.")
         },
-        ["action", "identityId", "patch"]
+        ["type", "value"],
+        "New identity payload. Required when action=add."
       ),
-      objectSchema(
-        {
-          action: literalSchema("verify"),
-          identityId: integerSchema("Identity id."),
-          verifiedAt: integerSchema("Optional verification timestamp.")
-        },
-        ["action", "identityId"]
+      identityId: integerSchema(
+        "Identity id. Required when action=revise, verify, or remove."
       ),
-      objectSchema(
+      patch: objectSchema(
         {
-          action: literalSchema("remove"),
-          identityId: integerSchema("Identity id."),
-          removedAt: integerSchema("Optional removal timestamp.")
+          type: stringSchema("Optional identity type."),
+          value: stringSchema("Optional identity value."),
+          label: stringSchema("Optional label.")
         },
-        ["action", "identityId"]
+        [],
+        "Identity patch. Required when action=revise."
+      ),
+      verifiedAt: integerSchema(
+        "Verification timestamp. Optional for action=verify."
+      ),
+      removedAt: integerSchema(
+        "Removal timestamp. Optional for action=remove."
       )
-    ],
-    "Manage identities."
+    },
+    ["action"],
+    "Add, revise, verify, or remove one routing identity on a contact."
   ),
   handler: manageIdentityToolHandler
 });
 
 // src/tools/manage_relationship_tool.ts
-function contactLocatorSchema6(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
+function contactLocatorSchema5(description) {
+  return {
+    type: "object",
+    properties: {
+      contactId: integerSchema("Exact contact id."),
+      identity: objectSchema(
         {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"]
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value.")
         },
-        ["identity"]
+        ["type", "value"],
+        "Contact identity locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
-function linkLocatorSchema4(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ linkId: integerSchema("Exact link id.") }, ["linkId"]),
-      objectSchema(
+function linkLocatorSchema3(description) {
+  return {
+    type: "object",
+    properties: {
+      linkId: integerSchema("Exact link id."),
+      endpoints: objectSchema(
         {
-          endpoints: objectSchema(
-            {
-              fromContactId: integerSchema("From contact id."),
-              toContactId: integerSchema("To contact id."),
-              kind: stringSchema("Optional link kind."),
-              role: stringSchema("Optional link role."),
-              isStructural: booleanSchema("Optional structural discriminator.")
-            },
-            ["fromContactId", "toContactId"]
-          )
+          fromContactId: integerSchema("From contact id."),
+          toContactId: integerSchema("To contact id."),
+          kind: stringSchema("Optional link kind."),
+          role: stringSchema("Optional link role."),
+          isStructural: booleanSchema("Optional structural discriminator.")
         },
-        ["endpoints"]
+        ["fromContactId", "toContactId"],
+        "Endpoint-based link locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function manageRelationshipToolHandler(db, input) {
   return withToolHandling(() => {
@@ -7360,10 +7087,15 @@ function manageRelationshipToolHandler(db, input) {
         if (!to.ok) {
           return to.result;
         }
+        const merged = {
+          ...input.input,
+          ...input.kind !== void 0 && input.input?.kind === void 0 ? { kind: input.kind } : {},
+          ...input.role !== void 0 && input.input?.role === void 0 ? { role: input.role } : {}
+        };
         return mutationToolResult(
           "seed_social_link",
           seedSocialLink(db, {
-            ...input.input,
+            ...merged,
             fromContactId: from.value.id,
             toContactId: to.value.id
           }),
@@ -7401,10 +7133,15 @@ function manageRelationshipToolHandler(db, input) {
         if (!to.ok) {
           return to.result;
         }
+        const merged = {
+          ...input.input,
+          ...input.kind !== void 0 && input.input?.kind === void 0 ? { kind: input.kind } : {},
+          ...input.role !== void 0 && input.input?.role === void 0 ? { role: input.role } : {}
+        };
         return mutationToolResult(
           "set_structural_tie",
           setStructuralTie(db, {
-            ...input.input,
+            ...merged,
             fromContactId: from.value.id,
             toContactId: to.value.id
           }),
@@ -7427,7 +7164,7 @@ function manageRelationshipToolHandler(db, input) {
 }
 var manageRelationshipTool = defineAffinityTool({
   name: manageRelationshipToolName,
-  description: "Seed social links, revise bond and state, and manage structural ties.",
+  description: "Seed social links, revise bond and state, and manage structural ties. Seed a link as soon as a relationship is mentioned \u2014 do not wait for repeated evidence.",
   whenToUse: "Use this for direct relationship modeling and link-state changes.",
   whenNotToUse: "Do not use this for recording social evidence or resolving commitments.",
   sideEffects: "writes_state",
@@ -7438,7 +7175,9 @@ var manageRelationshipTool = defineAffinityTool({
     action: "Which relationship action to perform.",
     from: "Source contact locator for actions that create or set links.",
     to: "Destination contact locator for actions that create or set links.",
-    input: "Action-specific creation payload.",
+    input: "Action-specific creation payload (alternative to top-level kind/role).",
+    kind: "Link kind for seed_social_link or set_structural_tie. Can be passed here or inside input.",
+    role: "Optional role for seed_social_link or set_structural_tie. Can be passed here or inside input.",
     link: "Target link locator for existing-link actions.",
     bond: "Replacement bond text or null.",
     state: "Replacement link state.",
@@ -7446,144 +7185,76 @@ var manageRelationshipTool = defineAffinityTool({
     removedAt: "Optional structural-tie removal timestamp."
   },
   outputDescription: "Returns the primary link plus the mutation receipt fields needed to understand what changed.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
-        {
-          action: literalSchema("seed_social_link"),
-          from: contactLocatorSchema6("From contact."),
-          to: contactLocatorSchema6("To contact."),
-          input: objectSchema(
-            {
-              kind: enumSchema("Relational link kind.", [
-                "personal",
-                "family",
-                "professional",
-                "romantic",
-                "care",
-                "service",
-                "observed",
-                "other_relational"
-              ]),
-              role: stringSchema("Optional role."),
-              rank: integerSchema("Optional rank."),
-              affinity: numberSchema("Optional affinity score 0\u20131."),
-              trust: numberSchema("Optional trust score 0\u20131."),
-              state: enumSchema("Optional initial state.", [
-                "active",
-                "dormant",
-                "strained",
-                "broken",
-                "archived"
-              ]),
-              cadenceDays: integerSchema("Optional cadence days."),
-              bond: stringSchema("Optional bond."),
-              now: integerSchema("Optional timestamp.")
-            },
-            ["kind"]
-          )
-        },
-        ["action", "from", "to", "input"]
+  inputSchema: objectSchema(
+    {
+      action: enumSchema("Operation to perform.", [
+        "seed_social_link",
+        "revise_bond",
+        "override_state",
+        "set_structural_tie",
+        "remove_structural_tie"
+      ]),
+      from: contactLocatorSchema5(
+        "Source contact. Required when action=seed_social_link or set_structural_tie. Provide contactId or identity."
       ),
-      objectSchema(
-        {
-          action: literalSchema("revise_bond"),
-          link: linkLocatorSchema4("Target link."),
-          bond: nullableStringSchema(
-            "Replacement bond text, or null to clear."
-          ),
-          options: objectSchema(
-            { now: integerSchema("Optional timestamp.") },
-            []
-          )
-        },
-        ["action", "link", "bond"]
+      to: contactLocatorSchema5(
+        "Target contact. Required when action=seed_social_link or set_structural_tie. Provide contactId or identity."
       ),
-      objectSchema(
-        {
-          action: literalSchema("override_state"),
-          link: linkLocatorSchema4("Target link."),
-          state: enumSchema("Replacement link state.", [
-            "active",
-            "dormant",
-            "strained",
-            "broken",
-            "archived"
-          ]),
-          options: objectSchema(
-            { now: integerSchema("Optional timestamp.") },
-            []
-          )
-        },
-        ["action", "link", "state"]
+      kind: stringSchema(
+        "Link kind. Required for seed_social_link and set_structural_tie. Can be passed here or inside input."
       ),
-      objectSchema(
-        {
-          action: literalSchema("set_structural_tie"),
-          from: contactLocatorSchema6("From contact."),
-          to: contactLocatorSchema6("To contact."),
-          input: objectSchema(
-            {
-              kind: enumSchema("Structural link kind.", [
-                "works_at",
-                "manages",
-                "member_of",
-                "married_to",
-                "partner_of",
-                "parent_of",
-                "child_of",
-                "sibling_of",
-                "friend_of",
-                "client_of",
-                "vendor_of",
-                "reports_to",
-                "belongs_to",
-                "other_structural"
-              ]),
-              role: stringSchema("Optional role."),
-              now: integerSchema("Optional timestamp.")
-            },
-            ["kind"]
-          )
-        },
-        ["action", "from", "to", "input"]
+      role: stringSchema(
+        "Optional role for seed_social_link or set_structural_tie. Can be passed here or inside input."
       ),
-      objectSchema(
-        {
-          action: literalSchema("remove_structural_tie"),
-          link: linkLocatorSchema4("Target structural tie."),
-          removedAt: integerSchema("Optional removal timestamp.")
-        },
-        ["action", "link"]
+      input: {
+        type: "object",
+        description: "Full payload for seed_social_link or set_structural_tie. Alternative to top-level kind/role."
+      },
+      link: linkLocatorSchema3(
+        "Target link. Required when action=revise_bond, override_state, or remove_structural_tie. Provide linkId or endpoints."
+      ),
+      bond: nullableStringSchema(
+        "Bond text. Required when action=revise_bond. Null to clear."
+      ),
+      state: enumSchema("Link state. Required when action=override_state.", [
+        "active",
+        "dormant",
+        "strained",
+        "broken",
+        "archived"
+      ]),
+      options: objectSchema(
+        { now: integerSchema("Optional timestamp.") },
+        [],
+        "Optional metadata."
+      ),
+      removedAt: integerSchema(
+        "Removal timestamp. Optional for action=remove_structural_tie."
       )
-    ],
-    "Manage relationships."
+    },
+    ["action"],
+    "Seed social links, revise bond and state, and manage structural ties."
   ),
   handler: manageRelationshipToolHandler
 });
 
 // src/tools/merge_contacts_tool.ts
-function contactLocatorSchema7(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
+function contactLocatorSchema6(description) {
+  return {
+    type: "object",
+    properties: {
+      contactId: integerSchema("Exact contact id."),
+      identity: objectSchema(
         {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"]
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value.")
         },
-        ["identity"]
+        ["type", "value"],
+        "Contact identity locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function mergeContactsToolHandler(db, input) {
   return withToolHandling(() => {
@@ -7625,8 +7296,12 @@ var mergeContactsTool = defineAffinityTool({
   outputDescription: "Returns the merge receipt with rewired entities and affected-link information.",
   inputSchema: objectSchema(
     {
-      winner: contactLocatorSchema7("Winner contact."),
-      loser: contactLocatorSchema7("Loser contact."),
+      winner: contactLocatorSchema6(
+        "Winner contact. Provide contactId or identity."
+      ),
+      loser: contactLocatorSchema6(
+        "Loser contact. Provide contactId or identity."
+      ),
       reasonSummary: stringSchema("Optional merge reason."),
       now: integerSchema("Optional merge timestamp.")
     },
@@ -7637,57 +7312,6 @@ var mergeContactsTool = defineAffinityTool({
 });
 
 // src/tools/record_event_tool.ts
-var participantSchema = objectSchema(
-  {
-    contactId: integerSchema("Participant contact id."),
-    role: enumSchema("Participant role.", [
-      "actor",
-      "recipient",
-      "subject",
-      "observer",
-      "mentioned"
-    ]),
-    directionality: enumSchema("Optional participant directionality.", [
-      "owner_initiated",
-      "other_initiated",
-      "mutual",
-      "observed"
-    ])
-  },
-  ["contactId", "role"]
-);
-function interactionInputSchema() {
-  return objectSchema(
-    {
-      type: enumSchema("Interaction subtype.", [
-        "conversation",
-        "activity",
-        "gift",
-        "support",
-        "conflict",
-        "correction"
-      ]),
-      occurredAt: integerSchema("When the event occurred."),
-      summary: stringSchema("Event summary."),
-      significance: integerSchema("Event significance from 1 to 10."),
-      participants: arraySchema(participantSchema, "Participant list."),
-      now: integerSchema("Optional timestamp.")
-    },
-    ["type", "occurredAt", "summary", "significance", "participants"]
-  );
-}
-function socialEventInputSchema() {
-  return objectSchema(
-    {
-      occurredAt: integerSchema("When the event occurred."),
-      summary: stringSchema("Event summary."),
-      significance: integerSchema("Event significance from 1 to 10."),
-      participants: arraySchema(participantSchema, "Participant list."),
-      now: integerSchema("Optional timestamp.")
-    },
-    ["occurredAt", "summary", "significance", "participants"]
-  );
-}
 function recordEventToolHandler(db, input) {
   return withToolHandling(() => {
     switch (input.kind) {
@@ -7732,38 +7356,21 @@ var recordEventTool = defineAffinityTool({
     input: "The event payload for that family. Interaction events require a `type` subtype; the others do not."
   },
   outputDescription: "Returns the primary event plus the mutation receipt fields and any affected links or derived effects.",
-  inputSchema: oneOfSchema(
-    [
-      objectSchema(
-        {
-          kind: literalSchema("interaction"),
-          input: interactionInputSchema()
-        },
-        ["kind", "input"]
-      ),
-      objectSchema(
-        {
-          kind: literalSchema("observation"),
-          input: socialEventInputSchema()
-        },
-        ["kind", "input"]
-      ),
-      objectSchema(
-        {
-          kind: literalSchema("milestone"),
-          input: socialEventInputSchema()
-        },
-        ["kind", "input"]
-      ),
-      objectSchema(
-        {
-          kind: literalSchema("transaction"),
-          input: socialEventInputSchema()
-        },
-        ["kind", "input"]
-      )
-    ],
-    "Record one event."
+  inputSchema: objectSchema(
+    {
+      kind: enumSchema("Event kind.", [
+        "interaction",
+        "observation",
+        "milestone",
+        "transaction"
+      ]),
+      input: {
+        type: "object",
+        description: "Event payload. Shape depends on kind. Interaction events require a `type` subtype; others do not. Always required."
+      }
+    },
+    ["kind", "input"],
+    "Record one social event."
   ),
   handler: recordEventToolHandler
 });
@@ -7787,50 +7394,42 @@ function buildChartOptions(input) {
     ...input.contactIds === void 0 ? {} : { contactIds: input.contactIds }
   };
 }
-function contactLocatorSchema8(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ contactId: integerSchema("Exact contact id.") }, [
-        "contactId"
-      ]),
-      objectSchema(
+function contactLocatorSchema7(description) {
+  return {
+    type: "object",
+    properties: {
+      contactId: integerSchema("Exact contact id."),
+      identity: objectSchema(
         {
-          identity: objectSchema(
-            {
-              type: stringSchema("Identity type."),
-              value: stringSchema("Identity value.")
-            },
-            ["type", "value"]
-          )
+          type: stringSchema("Identity type."),
+          value: stringSchema("Identity value.")
         },
-        ["identity"]
+        ["type", "value"],
+        "Contact identity locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
-function linkLocatorSchema5(description) {
-  return oneOfSchema(
-    [
-      objectSchema({ linkId: integerSchema("Exact link id.") }, ["linkId"]),
-      objectSchema(
+function linkLocatorSchema4(description) {
+  return {
+    type: "object",
+    properties: {
+      linkId: integerSchema("Exact link id."),
+      endpoints: objectSchema(
         {
-          endpoints: objectSchema(
-            {
-              fromContactId: integerSchema("From contact id."),
-              toContactId: integerSchema("To contact id."),
-              kind: stringSchema("Optional link kind."),
-              role: stringSchema("Optional link role."),
-              isStructural: booleanSchema("Optional structural discriminator.")
-            },
-            ["fromContactId", "toContactId"]
-          )
+          fromContactId: integerSchema("From contact id."),
+          toContactId: integerSchema("To contact id."),
+          kind: stringSchema("Optional link kind."),
+          role: stringSchema("Optional link role."),
+          isStructural: booleanSchema("Optional structural discriminator.")
         },
-        ["endpoints"]
+        ["fromContactId", "toContactId"],
+        "Endpoint-based link locator."
       )
-    ],
+    },
     description
-  );
+  };
 }
 function validateReviewInput(input) {
   if (input.view === "events.contact_journal" || input.view === "events.moments" || input.view === "commitments.open" || input.view === "merges.history") {
@@ -8231,8 +7830,8 @@ var reviewAffinityTool = defineAffinityTool({
         "graph.chart",
         "merges.history"
       ]),
-      contact: contactLocatorSchema8("Optional target contact locator."),
-      link: linkLocatorSchema5("Optional target link locator."),
+      contact: contactLocatorSchema7("Optional target contact locator."),
+      link: linkLocatorSchema4("Optional target link locator."),
       contactIds: arraySchema(
         integerSchema("Contact id."),
         "Optional contact-id subset."