@ghostpaw/affinity 0.1.3

package/dist/index.d.cts

@@ -0,0 +1,1641 @@
+import { DatabaseSync } from 'node:sqlite';
+
+/**
+ * SQLite dependency injected into every affinity operation.
+ */
+type AffinityDb = DatabaseSync;
+
+/**
+ * Creates the full standalone affinity public schema (contacts through attributes).
+ */
+declare function initAffinityTables(db: AffinityDb): void;
+
+/**
+ * Stable programmatic codes for `instanceof`-free logging or telemetry if needed.
+ */
+type AffinityErrorCode = "NOT_FOUND" | "CONFLICT" | "INVARIANT" | "VALIDATION" | "MERGE" | "STATE";
+/** Base class for all domain failures thrown by Affinity. */
+declare abstract class AffinityError extends Error {
+    abstract readonly code: AffinityErrorCode;
+    constructor(message: string, options?: ErrorOptions);
+}
+
+/** Uniqueness, routing, or ownership collision. */
+declare class AffinityConflictError extends AffinityError {
+    readonly code: "CONFLICT";
+}
+
+/** Request would violate model truth (e.g. progression on a structural tie). */
+declare class AffinityInvariantError extends AffinityError {
+    readonly code: "INVARIANT";
+}
+
+/** Illegal or ambiguous merge (e.g. merge into self). */
+declare class AffinityMergeError extends AffinityError {
+    readonly code: "MERGE";
+}
+
+/** Referenced entity or row does not exist. */
+declare class AffinityNotFoundError extends AffinityError {
+    readonly code: "NOT_FOUND";
+}
+
+/** Forbidden lifecycle or relationship transition. */
+declare class AffinityStateError extends AffinityError {
+    readonly code: "STATE";
+}
+
+/** Malformed input, unsupported sort/filter, or out-of-range value. */
+declare class AffinityValidationError extends AffinityError {
+    readonly code: "VALIDATION";
+}
+
+/** Narrow unknown failures from Affinity operations. */
+declare function isAffinityError(value: unknown): value is AffinityError;
+
+type errors_AffinityConflictError = AffinityConflictError;
+declare const errors_AffinityConflictError: typeof AffinityConflictError;
+type errors_AffinityError = AffinityError;
+declare const errors_AffinityError: typeof AffinityError;
+type errors_AffinityErrorCode = AffinityErrorCode;
+type errors_AffinityInvariantError = AffinityInvariantError;
+declare const errors_AffinityInvariantError: typeof AffinityInvariantError;
+type errors_AffinityMergeError = AffinityMergeError;
+declare const errors_AffinityMergeError: typeof AffinityMergeError;
+type errors_AffinityNotFoundError = AffinityNotFoundError;
+declare const errors_AffinityNotFoundError: typeof AffinityNotFoundError;
+type errors_AffinityStateError = AffinityStateError;
+declare const errors_AffinityStateError: typeof AffinityStateError;
+type errors_AffinityValidationError = AffinityValidationError;
+declare const errors_AffinityValidationError: typeof AffinityValidationError;
+declare const errors_isAffinityError: typeof isAffinityError;
+declare namespace errors {
+  export { errors_AffinityConflictError as AffinityConflictError, errors_AffinityError as AffinityError, type errors_AffinityErrorCode as AffinityErrorCode, errors_AffinityInvariantError as AffinityInvariantError, errors_AffinityMergeError as AffinityMergeError, errors_AffinityNotFoundError as AffinityNotFoundError, errors_AffinityStateError as AffinityStateError, errors_AffinityValidationError as AffinityValidationError, errors_isAffinityError as isAffinityError };
+}
+
+/**
+ * Free-form attribute name for operational metadata — value is string or null in SQL.
+ */
+type AttributeName = string;
+
+/** Visible contact kind — see CONCEPT.md `contacts.kind`. */
+type ContactKind = "human" | "group" | "company" | "team" | "pet" | "service" | "other";
+/** Lifecycle for a contact row — see CONCEPT.md `contacts.lifecycle_state`. */
+type ContactLifecycleState = "active" | "dormant" | "merged" | "lost";
+
+/** Journal entry classification — CONCEPT.md `events.type`. */
+type EventType = "conversation" | "activity" | "gift" | "support" | "milestone" | "observation" | "conflict" | "correction" | "transaction" | "promise" | "agreement" | "date_anchor";
+/** Derived key beat — CONCEPT.md `events.moment_kind` (nullable in storage). */
+type EventMomentKind = "breakthrough" | "rupture" | "reconciliation" | "milestone" | "turning_point";
+/** Anchored calendar recurrence — CONCEPT.md recurring fields on `events`. */
+type EventRecurrenceKind = "birthday" | "anniversary" | "renewal" | "memorial" | "custom_yearly";
+/** Participant stance — CONCEPT.md `event_participants.role`. */
+type EventParticipantRole = "actor" | "recipient" | "subject" | "observer" | "mentioned";
+
+/**
+ * Identity channel label (email, phone, handle, …) — stored as opaque string in SQL.
+ * Normalization happens in write paths, not in DDL.
+ */
+type IdentityType = string;
+
+/** Structural tie kinds — CONCEPT.md `links.kind` (structural). */
+type StructuralLinkKind = "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";
+/** Relational social-link kinds — CONCEPT.md `links.kind` (relational). */
+type RelationalLinkKind = "personal" | "family" | "professional" | "romantic" | "care" | "service" | "observed" | "other_relational";
+type LinkKind = StructuralLinkKind | RelationalLinkKind;
+/** Relational link state — structural ties leave this unset at rest in SQL. */
+type LinkState = "active" | "dormant" | "strained" | "broken" | "archived";
+
+interface AffinityChartEdge {
+    linkId: number;
+    fromContactId: number;
+    toContactId: number;
+    weight: number;
+    bridgeScore: number;
+}
+
+/** Options for `read.getAffinityChart` — CONCEPT.md. */
+interface AffinityChartReadOptions {
+    includeArchived?: boolean;
+    includeObserved?: boolean;
+    /** Restrict the graph to a subset of contact IDs. */
+    contactIds?: number[];
+}
+
+interface AffinityChartNode {
+    contactId: number;
+    label: string;
+    kind: ContactKind;
+}
+
+/** Graph projection — CONCEPT.md AffinityChartRecord. */
+interface AffinityChartRecord {
+    nodes: readonly AffinityChartNode[];
+    edges: readonly AffinityChartEdge[];
+}
+
+/** Attribute pair — `value` null means presence/tag semantics (CONCEPT.md). */
+interface AttributeEntry {
+    name: string;
+    value: string | null;
+}
+
+/** Attribute row for mutation receipts — stable id + target + payload. */
+interface AttributeRecord {
+    id: number;
+    contactId: number | null;
+    linkId: number | null;
+    name: string;
+    value: string | null;
+}
+
+/**
+ * Write target for attributes — exactly one of contact or link (CONCEPT.md).
+ */
+type AttributeTarget = {
+    kind: "contact";
+    id: number;
+} | {
+    kind: "link";
+    id: number;
+};
+
+/** Open commitment lifecycle on reads — CONCEPT.md CommitmentRecord. */
+type CommitmentResolutionState = "open" | "resolved" | "cancelled";
+
+/** Participant row embedded in journal reads — aligns with SocialEventInput participants. */
+interface EventParticipantView {
+    contactId: number;
+    role: EventParticipantRole;
+    directionality?: "owner_initiated" | "other_initiated" | "mutual" | "observed";
+}
+
+/** Promise/agreement projection — CONCEPT.md CommitmentRecord. */
+interface CommitmentRecord {
+    eventId: number;
+    type: EventType;
+    summary: string;
+    participants: readonly EventParticipantView[];
+    dueAt?: number | null;
+    resolutionState: CommitmentResolutionState;
+}
+
+/** Outcome passed to `write.resolveCommitment` — CONCEPT.md. */
+type CommitmentResolutionKind = "kept" | "cancelled" | "broken";
+
+/** Canonical contact row fields shared across list and profile reads. */
+interface ContactCore {
+    id: number;
+    name: string;
+    kind: ContactKind;
+    lifecycleState: ContactLifecycleState;
+    isOwner: boolean;
+}
+
+/** Default page size for list reads — CONCEPT.md Global query contract. */
+declare const AFFINITY_DEFAULT_LIST_LIMIT = 50;
+/** Hard cap for list reads — CONCEPT.md Global query contract. */
+declare const AFFINITY_MAX_LIST_LIMIT = 250;
+/** Shared list-style read controls — CONCEPT.md Global query contract. */
+interface AffinityListReadOptions {
+    limit?: number;
+    offset?: number;
+    sort?: string;
+    descending?: boolean;
+    includeArchived?: boolean;
+    includeDormant?: boolean;
+    includeObserved?: boolean;
+    since?: number;
+    until?: number;
+}
+
+/** Options for `read.getContactJournal` / `read.getLinkTimeline`. */
+type ContactJournalReadOptions = AffinityListReadOptions & {
+    eventTypes?: readonly EventType[];
+};
+
+/** Options for `read.getContactProfile`. */
+interface ContactProfileReadOptions {
+    /** Cap on relational links returned in `topLinks` (default 8). */
+    topLinksLimit?: number;
+}
+
+/** Compact portfolio row — CONCEPT.md ContactListItem. */
+interface ContactListItem {
+    id: number;
+    name: string;
+    kind: ContactKind;
+    lifecycleState: ContactLifecycleState;
+    isOwner: boolean;
+    primaryIdentity?: string | null;
+    lastMeaningfulEventAt?: number | null;
+}
+
+/** One routing identity on a contact — CONCEPT.md IdentityRecord. */
+interface IdentityRecord {
+    id: number;
+    contactId: number;
+    type: IdentityType;
+    value: string;
+    label: string | null;
+    verified: boolean;
+    /** When the identity was marked verified, if known. */
+    verifiedAt?: number | null;
+}
+
+/** Compact link row for lists — CONCEPT.md LinkListItem. */
+interface LinkListItem {
+    id: number;
+    fromContactId: number;
+    toContactId: number;
+    kind: LinkKind;
+    role?: string | null;
+    rank?: number | null;
+    affinity?: number | null;
+    trust?: number | null;
+    state?: LinkState | null;
+    cadenceDays?: number | null;
+    bond?: string | null;
+}
+
+/**
+ * Placeholder for rollup payloads until read implementations materialize
+ * (`contact_rollups`, `link_rollups`, …).
+ */
+type OpaqueRollup = Record<string, unknown>;
+
+/**
+ * Stable handle for anything that can appear in mutation receipts — CONCEPT.md Common refs.
+ */
+type EntityRef = {
+    kind: "contact";
+    id: number;
+} | {
+    kind: "identity";
+    id: number;
+} | {
+    kind: "link";
+    id: number;
+} | {
+    kind: "event";
+    id: number;
+} | {
+    kind: "attribute";
+    id: number;
+};
+
+type UpcomingDateTargetRef = Extract<EntityRef, {
+    kind: "contact" | "link";
+}>;
+/** Next anchored calendar occurrence — CONCEPT.md UpcomingDateRecord. */
+interface UpcomingDateRecord {
+    anchorEventId: number;
+    targetRef: UpcomingDateTargetRef;
+    recurrenceKind: EventRecurrenceKind;
+    /** Epoch milliseconds for the materialized next occurrence (sorting key). */
+    occursOn: number;
+    summary: string;
+    significance: number;
+}
+
+/** Full contact detail — CONCEPT.md ContactProfileRecord. */
+interface ContactProfileRecord {
+    contact: ContactCore;
+    identities: readonly IdentityRecord[];
+    attributes: readonly AttributeEntry[];
+    topLinks: readonly LinkListItem[];
+    activeDates: readonly UpcomingDateRecord[];
+    warnings: readonly string[];
+    rollups?: OpaqueRollup | null;
+}
+
+/** Raw `contacts` row from SQLite (snake_case columns). */
+interface ContactRow {
+    id: number;
+    name: string;
+    kind: string;
+    lifecycle_state: string;
+    is_owner: number;
+    merged_into_contact_id: number | null;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number | null;
+}
+
+type DateAnchorTarget = {
+    kind: "contact";
+    contactId: number;
+} | {
+    kind: "link";
+    linkId: number;
+};
+/** Arguments for `write.addDateAnchor`. */
+interface AddDateAnchorInput {
+    target: DateAnchorTarget;
+    recurrenceKind: EventRecurrenceKind;
+    anchorMonth: number;
+    anchorDay: number;
+    summary: string;
+    significance: number;
+    now?: number;
+    /** When true, skip duplicate (same recurrence + calendar + target) checks. */
+    force?: boolean;
+}
+
+/** Arguments for `write.addIdentity`. */
+interface AddIdentityInput {
+    type: string;
+    value: string;
+    label?: string | null;
+    /** When true, row is inserted with `verified` set (provenance only). */
+    verified?: boolean;
+    now?: number;
+}
+
+/** Arguments for `write.createContact`. */
+interface CreateContactInput {
+    name: string;
+    kind: ContactKind;
+    now?: number;
+    /**
+     * When true, marks this row as the sole owner contact.
+     * Allowed only while no other live owner exists.
+     */
+    bootstrapOwner?: boolean;
+}
+
+/** Raw `identities` row from SQLite. */
+interface IdentityRow {
+    id: number;
+    contact_id: number;
+    type: string;
+    value: string;
+    label: string | null;
+    normalized_key: string;
+    verified: number;
+    verified_at: number | null;
+    created_at: number;
+    updated_at: number;
+    removed_at: number | null;
+}
+
+/** Allowed contact-intrinsic updates for `write.reviseContact`. */
+interface ReviseContactPatch {
+    name?: string;
+}
+
+/** Allowed updates for `write.reviseIdentity`. */
+interface ReviseIdentityPatch {
+    type?: string;
+    value?: string;
+    label?: string | null;
+}
+
+/** Optional metadata for `write.setContactLifecycle`. */
+interface SetContactLifecycleOptions {
+    now?: number;
+    provenance?: unknown;
+}
+
+/** Arguments for `write.setStructuralTie`. */
+interface SetStructuralTieInput {
+    fromContactId: number;
+    toContactId: number;
+    kind: StructuralLinkKind;
+    role?: string | null;
+    now?: number;
+}
+
+/** Shared participant row for evidence writes — CONCEPT.md SocialEventInput. */
+interface SocialEventParticipantInput {
+    contactId: number;
+    role: EventParticipantRole;
+    directionality?: "owner_initiated" | "other_initiated" | "mutual" | "observed";
+}
+/** Evidence intake shape shared by interaction-style writes — CONCEPT.md. */
+interface SocialEventInput {
+    occurredAt: number;
+    summary: string;
+    /** Significance 1..10 — enforced at write layer. */
+    significance: number;
+    participants: readonly SocialEventParticipantInput[];
+    provenance?: unknown;
+}
+
+/** Arguments for `write.recordCommitment`. */
+interface RecordCommitmentInput extends SocialEventInput {
+    commitmentType: "promise" | "agreement";
+    dueAt?: number | null;
+    now?: number;
+}
+
+/** Subset of `EventType` allowed for `write.recordInteraction` — CONCEPT.md. */
+type InteractionEventType = "conversation" | "activity" | "gift" | "support" | "conflict" | "correction";
+/** Arguments for `write.recordInteraction`. */
+interface RecordInteractionInput extends SocialEventInput {
+    type: InteractionEventType;
+    now?: number;
+}
+
+/** Arguments for `write.recordMilestone`. */
+interface RecordMilestoneInput extends SocialEventInput {
+    now?: number;
+}
+
+/** Arguments for `write.recordObservation`. */
+interface RecordObservationInput extends SocialEventInput {
+    now?: number;
+}
+
+/** Arguments for `write.recordTransaction`. */
+interface RecordTransactionInput extends SocialEventInput {
+    now?: number;
+}
+
+interface ResolveCommitmentEventInput {
+    type?: Exclude<EventType, "date_anchor">;
+    occurredAt?: number;
+    summary?: string;
+    significance?: number;
+    participants?: readonly SocialEventParticipantInput[];
+    provenance?: unknown;
+}
+/** Optional clock and linked event data for `write.resolveCommitment`. */
+interface ResolveCommitmentOptions {
+    now?: number;
+    resolvingEvent?: ResolveCommitmentEventInput;
+}
+
+/** Partial update for `write.reviseDateAnchor`. */
+interface ReviseDateAnchorPatch {
+    recurrenceKind?: EventRecurrenceKind;
+    anchorMonth?: number;
+    anchorDay?: number;
+    summary?: string;
+    significance?: number;
+}
+
+/** Options for `write.reviseDateAnchor`. */
+interface ReviseDateAnchorOptions {
+    now?: number;
+    /** When true, skip duplicate calendar+target checks after applying the patch. */
+    force?: boolean;
+}
+
+/** Arguments for `write.seedSocialLink`. */
+interface SeedSocialLinkInput {
+    fromContactId: number;
+    toContactId: number;
+    kind: RelationalLinkKind;
+    role?: string | null;
+    /** Defaults to `0` when omitted. */
+    rank?: number;
+    /** Defaults to `0.5` when omitted. */
+    affinity?: number;
+    /** Defaults to `0.5` when omitted. */
+    trust?: number;
+    /** Defaults to `active` when omitted. */
+    state?: LinkState;
+    cadenceDays?: number | null;
+    bond?: string | null;
+    now?: number;
+}
+
+/**
+ * One row of link-level math returned on writes — CONCEPT.md DerivedLinkEffect.
+ */
+interface DerivedLinkEffect {
+    linkId: number;
+    eventId: number;
+    baseWeight: number;
+    intensity: number;
+    valence: number;
+    intimacyDepth: number;
+    reciprocitySignal: number;
+    directness: number;
+    preferenceMatch: number;
+    novelty: number;
+    affinityDelta: number;
+    trustDelta: number;
+    rankBefore: number;
+    rankAfter: number;
+    stateBefore: LinkState;
+    stateAfter: LinkState;
+    cadenceBefore: number;
+    cadenceAfter: number;
+    momentKind: EventMomentKind | null;
+}
+
+/**
+ * Placeholder for mechanics derivation blocks on detail reads.
+ */
+type OpaqueDerivation = Record<string, unknown>;
+
+/** Dedupe candidate pair — CONCEPT.md DuplicateCandidateRecord. */
+interface DuplicateCandidateRecord {
+    leftContactId: number;
+    rightContactId: number;
+    matchReason: string;
+    matchScore: number;
+}
+
+/** Journal entry with explicit participants — CONCEPT.md EventRecord. */
+interface EventRecord {
+    id: number;
+    type: EventType;
+    occurredAt: number;
+    summary: string;
+    significance: number;
+    momentKind: EventMomentKind | null;
+    participants: readonly EventParticipantView[];
+    recurrenceKind?: EventRecurrenceKind | null;
+    anchorMonth?: number | null;
+    anchorDay?: number | null;
+    anchorContactId?: number | null;
+    anchorLinkId?: number | null;
+}
+
+/** Raw `events` row from SQLite (snake_case columns). */
+interface EventRow {
+    id: number;
+    type: string;
+    occurred_at: number;
+    summary: string;
+    significance: number;
+    moment_kind: string | null;
+    recurrence_kind: string | null;
+    anchor_month: number | null;
+    anchor_day: number | null;
+    anchor_contact_id: number | null;
+    anchor_link_id: number | null;
+    created_at: number;
+    updated_at: number;
+    deleted_at: number | null;
+}
+
+/** Derived key beat — CONCEPT.md MomentRecord. */
+interface MomentRecord {
+    eventId: number;
+    linkId: number;
+    momentKind: EventMomentKind;
+    occurredAt: number;
+    summary: string;
+    impactScore: number;
+}
+
+/** Link detail with journal slices — CONCEPT.md LinkDetailRecord. */
+interface LinkDetailRecord {
+    link: LinkListItem;
+    counterparty: ContactCore;
+    recentEvents: readonly EventRecord[];
+    moments: readonly MomentRecord[];
+    rollups?: OpaqueRollup | null;
+    derivation?: OpaqueDerivation | null;
+}
+
+/** Optional detail controls for `read.getLinkDetail`. */
+interface LinkDetailReadOptions {
+    /** Cap on recent events returned in `recentEvents` (default 5). */
+    recentEventsLimit?: number;
+}
+
+/** Common filters for link list reads — CONCEPT.md. */
+interface LinkListReadFilters {
+    kind?: LinkKind;
+    state?: LinkState;
+}
+
+/** Optional clock and provenance for relational link mutations. */
+interface LinkMutationOptions {
+    now?: number;
+    provenance?: unknown;
+}
+
+/** Raw `links` row from SQLite (snake_case columns). */
+interface LinkRow {
+    id: number;
+    from_contact_id: number;
+    to_contact_id: number;
+    kind: string;
+    role: string | null;
+    is_structural: number;
+    rank: number | null;
+    affinity: number | null;
+    trust: number | null;
+    state: string | null;
+    cadence_days: number | null;
+    bond: string | null;
+    created_at: number;
+    updated_at: number;
+    removed_at: number | null;
+}
+
+/** Filters for `read.listContacts` — CONCEPT.md portfolio list. */
+interface ListContactsFilters {
+    kind?: ContactKind;
+    lifecycleState?: ContactLifecycleState;
+    includeOwner?: boolean;
+    includeDormant?: boolean;
+}
+
+/** Filters for `read.listDuplicateCandidates` — CONCEPT.md. */
+interface ListDuplicateCandidatesFilters {
+    minScore?: number;
+    exactOnly?: boolean;
+    contactIds?: readonly number[];
+}
+
+/** Supported filters for `read.listMoments` — CONCEPT.md. */
+interface ListMomentsFilters {
+    momentKind?: EventMomentKind;
+    contactId?: number;
+    linkId?: number;
+}
+
+/** Filters for `read.listOpenCommitments` — CONCEPT.md. */
+interface ListOpenCommitmentsFilters {
+    commitmentType?: "promise" | "agreement";
+    contactId?: number;
+    linkId?: number;
+    horizonDays?: number;
+}
+
+/** Filters for `read.listUpcomingDates` — CONCEPT.md maintenance list. */
+interface ListUpcomingDatesFilters {
+    recurrenceKind?: EventRecurrenceKind;
+    contactKind?: ContactKind;
+    /** Max days ahead from the horizon anchor (`options.since` or now). */
+    horizonDays?: number;
+}
+
+/** Arguments for `write.mergeContacts` — CONCEPT.md. */
+interface MergeContactsInput {
+    winnerContactId: number;
+    loserContactId: number;
+    reasonSummary?: string | null;
+    now?: number;
+}
+
+/** Primary payload returned on merge — winner/loser pair. */
+interface MergePrimary {
+    winnerContactId: number;
+    loserContactId: number;
+}
+
+/**
+ * Universal write receipt envelope — CONCEPT.md MutationReceipt.
+ */
+interface MutationReceipt<TPrimary> {
+    primary: TPrimary;
+    created: EntityRef[];
+    updated: EntityRef[];
+    archived: EntityRef[];
+    removed: EntityRef[];
+    affectedLinks: number[];
+    derivedEffects: DerivedLinkEffect[];
+}
+type ContactMutationReceipt = MutationReceipt<ContactListItem>;
+type IdentityMutationReceipt = MutationReceipt<IdentityRecord>;
+type LinkMutationReceipt = MutationReceipt<LinkListItem>;
+type EventMutationReceipt = MutationReceipt<EventRecord>;
+type AttributeMutationReceipt = MutationReceipt<AttributeRecord>;
+type MergeReceipt = MutationReceipt<MergePrimary>;
+
+/** Maintenance radar row — CONCEPT.md RadarRecord. */
+interface RadarRecord {
+    linkId: number;
+    contactId: number;
+    driftPriority: number;
+    recencyScore: number;
+    normalizedRank: number;
+    trust: number;
+    recommendedReason: string;
+}
+
+/**
+ * Applies default list limit and CONCEPT bounds (throws when out of range).
+ */
+declare function resolveAffinityListLimit(limit: number | undefined): number;
+
+/** Merge lineage row — CONCEPT.md MergeHistoryRecord. */
+interface MergeHistoryRecord {
+    winnerContactId: number;
+    loserContactId: number;
+    mergedAt: number;
+    reasonSummary?: string | null;
+    manual: boolean;
+}
+
+declare const types_AFFINITY_DEFAULT_LIST_LIMIT: typeof AFFINITY_DEFAULT_LIST_LIMIT;
+declare const types_AFFINITY_MAX_LIST_LIMIT: typeof AFFINITY_MAX_LIST_LIMIT;
+type types_AddDateAnchorInput = AddDateAnchorInput;
+type types_AddIdentityInput = AddIdentityInput;
+type types_AffinityChartEdge = AffinityChartEdge;
+type types_AffinityChartNode = AffinityChartNode;
+type types_AffinityChartReadOptions = AffinityChartReadOptions;
+type types_AffinityChartRecord = AffinityChartRecord;
+type types_AffinityListReadOptions = AffinityListReadOptions;
+type types_AttributeEntry = AttributeEntry;
+type types_AttributeMutationReceipt = AttributeMutationReceipt;
+type types_AttributeName = AttributeName;
+type types_AttributeRecord = AttributeRecord;
+type types_AttributeTarget = AttributeTarget;
+type types_CommitmentRecord = CommitmentRecord;
+type types_CommitmentResolutionKind = CommitmentResolutionKind;
+type types_CommitmentResolutionState = CommitmentResolutionState;
+type types_ContactCore = ContactCore;
+type types_ContactJournalReadOptions = ContactJournalReadOptions;
+type types_ContactKind = ContactKind;
+type types_ContactLifecycleState = ContactLifecycleState;
+type types_ContactListItem = ContactListItem;
+type types_ContactMutationReceipt = ContactMutationReceipt;
+type types_ContactProfileReadOptions = ContactProfileReadOptions;
+type types_ContactProfileRecord = ContactProfileRecord;
+type types_ContactRow = ContactRow;
+type types_CreateContactInput = CreateContactInput;
+type types_DateAnchorTarget = DateAnchorTarget;
+type types_DerivedLinkEffect = DerivedLinkEffect;
+type types_DuplicateCandidateRecord = DuplicateCandidateRecord;
+type types_EntityRef = EntityRef;
+type types_EventMomentKind = EventMomentKind;
+type types_EventMutationReceipt = EventMutationReceipt;
+type types_EventParticipantRole = EventParticipantRole;
+type types_EventParticipantView = EventParticipantView;
+type types_EventRecord = EventRecord;
+type types_EventRecurrenceKind = EventRecurrenceKind;
+type types_EventRow = EventRow;
+type types_EventType = EventType;
+type types_IdentityMutationReceipt = IdentityMutationReceipt;
+type types_IdentityRecord = IdentityRecord;
+type types_IdentityRow = IdentityRow;
+type types_IdentityType = IdentityType;
+type types_InteractionEventType = InteractionEventType;
+type types_LinkDetailReadOptions = LinkDetailReadOptions;
+type types_LinkDetailRecord = LinkDetailRecord;
+type types_LinkKind = LinkKind;
+type types_LinkListItem = LinkListItem;
+type types_LinkListReadFilters = LinkListReadFilters;
+type types_LinkMutationOptions = LinkMutationOptions;
+type types_LinkMutationReceipt = LinkMutationReceipt;
+type types_LinkRow = LinkRow;
+type types_LinkState = LinkState;
+type types_ListContactsFilters = ListContactsFilters;
+type types_ListDuplicateCandidatesFilters = ListDuplicateCandidatesFilters;
+type types_ListMomentsFilters = ListMomentsFilters;
+type types_ListOpenCommitmentsFilters = ListOpenCommitmentsFilters;
+type types_ListUpcomingDatesFilters = ListUpcomingDatesFilters;
+type types_MergeContactsInput = MergeContactsInput;
+type types_MergeHistoryRecord = MergeHistoryRecord;
+type types_MergePrimary = MergePrimary;
+type types_MergeReceipt = MergeReceipt;
+type types_MomentRecord = MomentRecord;
+type types_MutationReceipt<TPrimary> = MutationReceipt<TPrimary>;
+type types_OpaqueDerivation = OpaqueDerivation;
+type types_OpaqueRollup = OpaqueRollup;
+type types_RadarRecord = RadarRecord;
+type types_RecordCommitmentInput = RecordCommitmentInput;
+type types_RecordInteractionInput = RecordInteractionInput;
+type types_RecordMilestoneInput = RecordMilestoneInput;
+type types_RecordObservationInput = RecordObservationInput;
+type types_RecordTransactionInput = RecordTransactionInput;
+type types_RelationalLinkKind = RelationalLinkKind;
+type types_ResolveCommitmentOptions = ResolveCommitmentOptions;
+type types_ReviseContactPatch = ReviseContactPatch;
+type types_ReviseDateAnchorOptions = ReviseDateAnchorOptions;
+type types_ReviseDateAnchorPatch = ReviseDateAnchorPatch;
+type types_ReviseIdentityPatch = ReviseIdentityPatch;
+type types_SeedSocialLinkInput = SeedSocialLinkInput;
+type types_SetContactLifecycleOptions = SetContactLifecycleOptions;
+type types_SetStructuralTieInput = SetStructuralTieInput;
+type types_SocialEventInput = SocialEventInput;
+type types_SocialEventParticipantInput = SocialEventParticipantInput;
+type types_StructuralLinkKind = StructuralLinkKind;
+type types_UpcomingDateRecord = UpcomingDateRecord;
+type types_UpcomingDateTargetRef = UpcomingDateTargetRef;
+declare const types_resolveAffinityListLimit: typeof resolveAffinityListLimit;
+declare namespace types {
+  export { types_AFFINITY_DEFAULT_LIST_LIMIT as AFFINITY_DEFAULT_LIST_LIMIT, types_AFFINITY_MAX_LIST_LIMIT as AFFINITY_MAX_LIST_LIMIT, type types_AddDateAnchorInput as AddDateAnchorInput, type types_AddIdentityInput as AddIdentityInput, type types_AffinityChartEdge as AffinityChartEdge, type types_AffinityChartNode as AffinityChartNode, type types_AffinityChartReadOptions as AffinityChartReadOptions, type types_AffinityChartRecord as AffinityChartRecord, type types_AffinityListReadOptions as AffinityListReadOptions, type types_AttributeEntry as AttributeEntry, type types_AttributeMutationReceipt as AttributeMutationReceipt, type types_AttributeName as AttributeName, type types_AttributeRecord as AttributeRecord, type types_AttributeTarget as AttributeTarget, type types_CommitmentRecord as CommitmentRecord, type types_CommitmentResolutionKind as CommitmentResolutionKind, type types_CommitmentResolutionState as CommitmentResolutionState, type types_ContactCore as ContactCore, type types_ContactJournalReadOptions as ContactJournalReadOptions, type types_ContactKind as ContactKind, type types_ContactLifecycleState as ContactLifecycleState, type types_ContactListItem as ContactListItem, type types_ContactMutationReceipt as ContactMutationReceipt, type types_ContactProfileReadOptions as ContactProfileReadOptions, type types_ContactProfileRecord as ContactProfileRecord, type types_ContactRow as ContactRow, type types_CreateContactInput as CreateContactInput, type types_DateAnchorTarget as DateAnchorTarget, type types_DerivedLinkEffect as DerivedLinkEffect, type types_DuplicateCandidateRecord as DuplicateCandidateRecord, type types_EntityRef as EntityRef, type types_EventMomentKind as EventMomentKind, type types_EventMutationReceipt as EventMutationReceipt, type types_EventParticipantRole as EventParticipantRole, type types_EventParticipantView as EventParticipantView, type types_EventRecord as EventRecord, type types_EventRecurrenceKind as EventRecurrenceKind, type types_EventRow as EventRow, type types_EventType as EventType, type types_IdentityMutationReceipt as IdentityMutationReceipt, type types_IdentityRecord as IdentityRecord, type types_IdentityRow as IdentityRow, type types_IdentityType as IdentityType, type types_InteractionEventType as InteractionEventType, type types_LinkDetailReadOptions as LinkDetailReadOptions, type types_LinkDetailRecord as LinkDetailRecord, type types_LinkKind as LinkKind, type types_LinkListItem as LinkListItem, type types_LinkListReadFilters as LinkListReadFilters, type types_LinkMutationOptions as LinkMutationOptions, type types_LinkMutationReceipt as LinkMutationReceipt, type types_LinkRow as LinkRow, type types_LinkState as LinkState, type types_ListContactsFilters as ListContactsFilters, type types_ListDuplicateCandidatesFilters as ListDuplicateCandidatesFilters, type types_ListMomentsFilters as ListMomentsFilters, type types_ListOpenCommitmentsFilters as ListOpenCommitmentsFilters, type types_ListUpcomingDatesFilters as ListUpcomingDatesFilters, type types_MergeContactsInput as MergeContactsInput, type types_MergeHistoryRecord as MergeHistoryRecord, type types_MergePrimary as MergePrimary, type types_MergeReceipt as MergeReceipt, type types_MomentRecord as MomentRecord, type types_MutationReceipt as MutationReceipt, type types_OpaqueDerivation as OpaqueDerivation, type types_OpaqueRollup as OpaqueRollup, type types_RadarRecord as RadarRecord, type types_RecordCommitmentInput as RecordCommitmentInput, type types_RecordInteractionInput as RecordInteractionInput, type types_RecordMilestoneInput as RecordMilestoneInput, type types_RecordObservationInput as RecordObservationInput, type types_RecordTransactionInput as RecordTransactionInput, type types_RelationalLinkKind as RelationalLinkKind, type types_ResolveCommitmentOptions as ResolveCommitmentOptions, type types_ReviseContactPatch as ReviseContactPatch, type types_ReviseDateAnchorOptions as ReviseDateAnchorOptions, type types_ReviseDateAnchorPatch as ReviseDateAnchorPatch, type types_ReviseIdentityPatch as ReviseIdentityPatch, type types_SeedSocialLinkInput as SeedSocialLinkInput, type types_SetContactLifecycleOptions as SetContactLifecycleOptions, type types_SetStructuralTieInput as SetStructuralTieInput, type types_SocialEventInput as SocialEventInput, type types_SocialEventParticipantInput as SocialEventParticipantInput, type types_StructuralLinkKind as StructuralLinkKind, type types_UpcomingDateRecord as UpcomingDateRecord, type types_UpcomingDateTargetRef as UpcomingDateTargetRef, types_resolveAffinityListLimit as resolveAffinityListLimit };
+}
+
+declare function createContact(db: AffinityDb, input: CreateContactInput): ContactMutationReceipt;
+
+declare function getContactProfile(db: AffinityDb, contactId: number, options?: ContactProfileReadOptions): ContactProfileRecord | null;
+
+declare function getOwnerProfile(db: AffinityDb, options?: ContactProfileReadOptions): ContactProfileRecord | null;
+
+declare function listContacts(db: AffinityDb, filters?: ListContactsFilters, options?: AffinityListReadOptions): ContactListItem[];
+
+declare function listDuplicateCandidates(db: AffinityDb, filters?: ListDuplicateCandidatesFilters, options?: AffinityListReadOptions): DuplicateCandidateRecord[];
+
+declare function reviseContact(db: AffinityDb, contactId: number, patch: ReviseContactPatch): ContactMutationReceipt;
+
+declare function searchContacts(db: AffinityDb, query: string, filters?: ListContactsFilters, options?: AffinityListReadOptions): ContactListItem[];
+
+declare function setContactLifecycle(db: AffinityDb, contactId: number, lifecycleState: ContactLifecycleState, options?: SetContactLifecycleOptions): ContactMutationReceipt;
+
+declare function addDateAnchor(db: AffinityDb, input: AddDateAnchorInput): EventMutationReceipt;
+
+declare function listUpcomingDates(db: AffinityDb, filters?: ListUpcomingDatesFilters, options?: AffinityListReadOptions): UpcomingDateRecord[];
+
+declare function removeDateAnchor(db: AffinityDb, anchorEventId: number, removedAt?: number): EventMutationReceipt;
+
+declare function reviseDateAnchor(db: AffinityDb, anchorEventId: number, patch: ReviseDateAnchorPatch, options?: ReviseDateAnchorOptions): EventMutationReceipt;
+
+declare function getAffinityChart(db: AffinityDb, options?: AffinityChartReadOptions): AffinityChartRecord;
+
+declare function getLinkDetail(db: AffinityDb, linkId: number, options?: LinkDetailReadOptions): LinkDetailRecord | null;
+
+declare function getLinkTimeline(db: AffinityDb, linkId: number, options?: ContactJournalReadOptions): EventRecord[];
+
+declare function listObservedLinks(db: AffinityDb, filters?: LinkListReadFilters, options?: AffinityListReadOptions): LinkListItem[];
+
+declare function listOwnerSocialLinks(db: AffinityDb, filters?: LinkListReadFilters, options?: AffinityListReadOptions): LinkListItem[];
+
+declare function listProgressionReadiness(db: AffinityDb, filters?: {
+    kind?: LinkKind;
+}, options?: AffinityListReadOptions): LinkListItem[];
+
+declare function listRadar(db: AffinityDb, filters?: LinkListReadFilters, options?: AffinityListReadOptions): RadarRecord[];
+
+declare function overrideLinkState(db: AffinityDb, linkId: number, state: LinkState, options?: LinkMutationOptions): LinkMutationReceipt;
+
+declare function removeStructuralTie(db: AffinityDb, tieId: number, removedAt?: number): LinkMutationReceipt;
+
+declare function reviseBond(db: AffinityDb, linkId: number, bond: string | null, options?: LinkMutationOptions): LinkMutationReceipt;
+
+declare function seedSocialLink(db: AffinityDb, input: SeedSocialLinkInput): LinkMutationReceipt;
+
+declare function setStructuralTie(db: AffinityDb, input: SetStructuralTieInput): LinkMutationReceipt;
+
+declare function getMergeHistory(db: AffinityDb, contactId: number, options?: AffinityListReadOptions): MergeHistoryRecord[];
+
+declare function mergeContacts(db: AffinityDb, input: MergeContactsInput): MergeReceipt;
+
+declare function getContactJournal(db: AffinityDb, contactId: number, options?: ContactJournalReadOptions): EventRecord[];
+
+declare function listMoments(db: AffinityDb, filters?: ListMomentsFilters, options?: AffinityListReadOptions): MomentRecord[];
+
+declare function listOpenCommitments(db: AffinityDb, filters?: ListOpenCommitmentsFilters, options?: AffinityListReadOptions): CommitmentRecord[];
+
+declare function recordCommitment(db: AffinityDb, input: RecordCommitmentInput): EventMutationReceipt;
+
+declare function recordInteraction(db: AffinityDb, input: RecordInteractionInput): EventMutationReceipt;
+
+declare function recordMilestone(db: AffinityDb, input: RecordMilestoneInput): EventMutationReceipt;
+
+declare function recordObservation(db: AffinityDb, input: RecordObservationInput): EventMutationReceipt;
+
+declare function recordTransaction(db: AffinityDb, input: RecordTransactionInput): EventMutationReceipt;
+
+declare function resolveCommitment(db: AffinityDb, commitmentEventId: number, resolution: CommitmentResolutionKind, options?: ResolveCommitmentOptions): EventMutationReceipt;
+
+declare const read_getAffinityChart: typeof getAffinityChart;
+declare const read_getContactJournal: typeof getContactJournal;
+declare const read_getContactProfile: typeof getContactProfile;
+declare const read_getLinkDetail: typeof getLinkDetail;
+declare const read_getLinkTimeline: typeof getLinkTimeline;
+declare const read_getMergeHistory: typeof getMergeHistory;
+declare const read_getOwnerProfile: typeof getOwnerProfile;
+declare const read_listContacts: typeof listContacts;
+declare const read_listDuplicateCandidates: typeof listDuplicateCandidates;
+declare const read_listMoments: typeof listMoments;
+declare const read_listObservedLinks: typeof listObservedLinks;
+declare const read_listOpenCommitments: typeof listOpenCommitments;
+declare const read_listOwnerSocialLinks: typeof listOwnerSocialLinks;
+declare const read_listProgressionReadiness: typeof listProgressionReadiness;
+declare const read_listRadar: typeof listRadar;
+declare const read_listUpcomingDates: typeof listUpcomingDates;
+declare const read_searchContacts: typeof searchContacts;
+declare namespace read {
+  export { read_getAffinityChart as getAffinityChart, read_getContactJournal as getContactJournal, read_getContactProfile as getContactProfile, read_getLinkDetail as getLinkDetail, read_getLinkTimeline as getLinkTimeline, read_getMergeHistory as getMergeHistory, read_getOwnerProfile as getOwnerProfile, read_listContacts as listContacts, read_listDuplicateCandidates as listDuplicateCandidates, read_listMoments as listMoments, read_listObservedLinks as listObservedLinks, read_listOpenCommitments as listOpenCommitments, read_listOwnerSocialLinks as listOwnerSocialLinks, read_listProgressionReadiness as listProgressionReadiness, read_listRadar as listRadar, read_listUpcomingDates as listUpcomingDates, read_searchContacts as searchContacts };
+}
+
+interface AffinitySoulTrait {
+    principle: string;
+    provenance: string;
+}
+interface AffinitySoul {
+    slug: string;
+    name: string;
+    description: string;
+    essence: string;
+    traits: readonly AffinitySoulTrait[];
+}
+declare const affinitySoulEssence = "You think like a disciplined gardener of relationship truth whose main instrument is Affinity. Your job is not to sound warm, strategic, or emotionally intelligent in the abstract. Your job is to keep the system's representation of people, ties, social links, journal evidence, obligations, and recurring salience true enough that decisions made from it stay good over time. You are always asking: what actually happened, what kind of truth is this, what is still ambiguous, and what is the smallest honest move that will leave the graph cleaner and more useful tomorrow than it is today.\n\nYour first boundary is evidence. Affinity is not a place for wishful narration or flattering reconstruction. A relationship does not become deeper because someone hopes it is deep. A contact does not become certain because a name sounds familiar. A past does not become cleaner because fake journal entries are backfilled to justify a desired Rank, Affinity, or Trust. You prefer one honest seed over synthetic history, one exact identity over a fuzzy guess, and one explicit clarification over a confident mistake.\n\nYour second boundary is type of truth. Structural ties, owner-facing social links, observed third-party links, commitments, recurring dates, attributes, and bond interpretation all exist for different reasons. Work history is not family structure. Observation is not direct intimacy. A promise is not a conversation summary. A birthday is not just another attribute. A Bond is a narrative reading of a link, not the same thing as the link itself. Affinity becomes powerful only when those truths stay separate and the right tool is used for the right layer.\n\nYour 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.\n\nYou 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.";
+declare const affinitySoulTraits: {
+    principle: string;
+    provenance: string;
+}[];
+declare const affinitySoul: AffinitySoul;
+declare function renderAffinitySoulPromptFoundation(soul?: AffinitySoul): string;
+
+type soul_AffinitySoul = AffinitySoul;
+type soul_AffinitySoulTrait = AffinitySoulTrait;
+declare const soul_affinitySoul: typeof affinitySoul;
+declare const soul_affinitySoulEssence: typeof affinitySoulEssence;
+declare const soul_affinitySoulTraits: typeof affinitySoulTraits;
+declare const soul_renderAffinitySoulPromptFoundation: typeof renderAffinitySoulPromptFoundation;
+declare namespace soul {
+  export { type soul_AffinitySoul as AffinitySoul, type soul_AffinitySoulTrait as AffinitySoulTrait, soul_affinitySoul as affinitySoul, soul_affinitySoulEssence as affinitySoulEssence, soul_affinitySoulTraits as affinitySoulTraits, soul_renderAffinitySoulPromptFoundation as renderAffinitySoulPromptFoundation };
+}
+
+declare const bootstrapAndColdStartSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const captureTransactionsAndCommercialEventsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const identifyAndLocateContactsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const importHistoryWithoutFakingEvidenceSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const managePromisesAndAgreementsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const manageRecurringDatesAndRemindersSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const modelStructureOrgsAndHouseholdsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const recordDirectEvidenceWellSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const recordObservationsAndReferralsSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const reconcileDuplicatesAndMergeSafelySkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+declare const reviewRadarProgressionAndGraphSkill: {
+    name: string;
+    description: string;
+    content: string;
+};
+
+interface AffinitySkill {
+    name: string;
+    description: string;
+    content: string;
+}
+type AffinitySkillRegistry = readonly AffinitySkill[];
+declare function defineAffinitySkill<TSkill extends AffinitySkill>(skill: TSkill): TSkill;
+
+declare const affinitySkills: {
+    name: string;
+    description: string;
+    content: string;
+}[];
+declare function listAffinitySkills(): AffinitySkillRegistry;
+declare function getAffinitySkillByName(name: string): {
+    name: string;
+    description: string;
+    content: string;
+} | null;
+
+type index$1_AffinitySkill = AffinitySkill;
+type index$1_AffinitySkillRegistry = AffinitySkillRegistry;
+declare const index$1_affinitySkills: typeof affinitySkills;
+declare const index$1_bootstrapAndColdStartSkill: typeof bootstrapAndColdStartSkill;
+declare const index$1_captureTransactionsAndCommercialEventsSkill: typeof captureTransactionsAndCommercialEventsSkill;
+declare const index$1_defineAffinitySkill: typeof defineAffinitySkill;
+declare const index$1_getAffinitySkillByName: typeof getAffinitySkillByName;
+declare const index$1_identifyAndLocateContactsSkill: typeof identifyAndLocateContactsSkill;
+declare const index$1_importHistoryWithoutFakingEvidenceSkill: typeof importHistoryWithoutFakingEvidenceSkill;
+declare const index$1_listAffinitySkills: typeof listAffinitySkills;
+declare const index$1_managePromisesAndAgreementsSkill: typeof managePromisesAndAgreementsSkill;
+declare const index$1_manageRecurringDatesAndRemindersSkill: typeof manageRecurringDatesAndRemindersSkill;
+declare const index$1_modelStructureOrgsAndHouseholdsSkill: typeof modelStructureOrgsAndHouseholdsSkill;
+declare const index$1_reconcileDuplicatesAndMergeSafelySkill: typeof reconcileDuplicatesAndMergeSafelySkill;
+declare const index$1_recordDirectEvidenceWellSkill: typeof recordDirectEvidenceWellSkill;
+declare const index$1_recordObservationsAndReferralsSkill: typeof recordObservationsAndReferralsSkill;
+declare const index$1_reviewRadarProgressionAndGraphSkill: typeof reviewRadarProgressionAndGraphSkill;
+declare namespace index$1 {
+  export { type index$1_AffinitySkill as AffinitySkill, type index$1_AffinitySkillRegistry as AffinitySkillRegistry, index$1_affinitySkills as affinitySkills, index$1_bootstrapAndColdStartSkill as bootstrapAndColdStartSkill, index$1_captureTransactionsAndCommercialEventsSkill as captureTransactionsAndCommercialEventsSkill, index$1_defineAffinitySkill as defineAffinitySkill, index$1_getAffinitySkillByName as getAffinitySkillByName, index$1_identifyAndLocateContactsSkill as identifyAndLocateContactsSkill, index$1_importHistoryWithoutFakingEvidenceSkill as importHistoryWithoutFakingEvidenceSkill, index$1_listAffinitySkills as listAffinitySkills, index$1_managePromisesAndAgreementsSkill as managePromisesAndAgreementsSkill, index$1_manageRecurringDatesAndRemindersSkill as manageRecurringDatesAndRemindersSkill, index$1_modelStructureOrgsAndHouseholdsSkill as modelStructureOrgsAndHouseholdsSkill, index$1_reconcileDuplicatesAndMergeSafelySkill as reconcileDuplicatesAndMergeSafelySkill, index$1_recordDirectEvidenceWellSkill as recordDirectEvidenceWellSkill, index$1_recordObservationsAndReferralsSkill as recordObservationsAndReferralsSkill, index$1_reviewRadarProgressionAndGraphSkill as reviewRadarProgressionAndGraphSkill };
+}
+
+type ToolEntityKind = "contact" | "identity" | "link" | "event" | "attribute";
+type ToolOutcomeKind = "success" | "no_op" | "needs_clarification" | "error";
+type ToolErrorCode = "clarification_needed" | "conflict" | "constraint_violation" | "invalid_input" | "invalid_state" | "not_found" | "system_error" | "unsupported_target";
+type ToolErrorKind = "domain" | "protocol" | "system";
+type ToolWarningCode = "already_in_state" | "derived_value_used" | "empty_result" | "partial_match" | "unchanged";
+type ToolClarificationCode = "ambiguous_target" | "missing_required_choice" | "multiple_plausible_matches";
+type ToolNextStepHintKind = "ask_user" | "inspect_item" | "review_view" | "retry_with" | "use_tool";
+interface ToolEntityRef {
+    kind: ToolEntityKind;
+    id: number;
+    title?: string | undefined;
+    subtitle?: string | undefined;
+    state?: ContactLifecycleState | EventType | LinkKind | LinkState | ContactKind | string | null | undefined;
+}
+interface ToolListItem extends ToolEntityRef {
+    snippet?: string | undefined;
+}
+interface ToolWarning {
+    code: ToolWarningCode;
+    message: string;
+}
+interface ToolNextStepHint {
+    kind: ToolNextStepHintKind;
+    message: string;
+    tool?: string | undefined;
+    suggestedInput?: Record<string, unknown> | undefined;
+}
+interface ToolBaseResult {
+    ok: boolean;
+    outcome: ToolOutcomeKind;
+    summary: string;
+    entities: ToolEntityRef[];
+    warnings?: ToolWarning[] | undefined;
+    next?: ToolNextStepHint[] | undefined;
+}
+interface ToolSuccess<TData> extends ToolBaseResult {
+    ok: true;
+    outcome: "success" | "no_op";
+    data: TData;
+}
+interface ToolNeedsClarification extends ToolBaseResult {
+    ok: false;
+    outcome: "needs_clarification";
+    clarification: {
+        code: ToolClarificationCode;
+        question: string;
+        missing: string[];
+        options?: Array<{
+            label: string;
+            value: number | string;
+        }> | undefined;
+    };
+}
+interface ToolFailure extends ToolBaseResult {
+    ok: false;
+    outcome: "error";
+    error: {
+        kind: ToolErrorKind;
+        code: ToolErrorCode;
+        message: string;
+        recovery?: string | undefined;
+        details?: Record<string, unknown> | undefined;
+    };
+}
+type ToolResult<TData> = ToolFailure | ToolNeedsClarification | ToolSuccess<TData>;
+interface ToolResultOptions {
+    entities?: ToolEntityRef[] | undefined;
+    next?: ToolNextStepHint[] | undefined;
+    warnings?: ToolWarning[] | undefined;
+}
+declare function toolWarning(code: ToolWarningCode, message: string): ToolWarning;
+declare function toolSuccess<TData>(summary: string, data: TData, options?: ToolResultOptions): ToolSuccess<TData>;
+declare function toolNoOp<TData>(summary: string, data: TData, options?: ToolResultOptions): ToolSuccess<TData>;
+interface ToolClarificationOptions extends ToolResultOptions {
+    options?: Array<{
+        label: string;
+        value: number | string;
+    }> | undefined;
+}
+declare function toolNeedsClarification(code: ToolClarificationCode, question: string, missing: string[], options?: ToolClarificationOptions): ToolNeedsClarification;
+interface ToolFailureOptions extends ToolResultOptions {
+    details?: Record<string, unknown> | undefined;
+    recovery?: string | undefined;
+}
+declare function toolFailure(kind: ToolErrorKind, code: ToolErrorCode, summary: string, message: string, options?: ToolFailureOptions): ToolFailure;
+
+type ToolInputDescriptions = Readonly<Record<string, string>>;
+type ToolOutputDescription = string;
+type JsonSchemaType = "array" | "boolean" | "integer" | "null" | "number" | "object" | "string";
+interface JsonSchema {
+    type?: JsonSchemaType | undefined;
+    description?: string | undefined;
+    enum?: ReadonlyArray<boolean | number | string | null> | undefined;
+    const?: boolean | number | string | null;
+    items?: JsonSchema | undefined;
+    properties?: Readonly<Record<string, JsonSchema>> | undefined;
+    required?: ReadonlyArray<string> | undefined;
+    additionalProperties?: boolean | undefined;
+    oneOf?: ReadonlyArray<JsonSchema> | undefined;
+    anyOf?: ReadonlyArray<JsonSchema> | undefined;
+}
+type ToolSideEffects = "none" | "writes_state";
+interface AffinityToolDefinition<TInput, TResult extends ToolResult<unknown>> {
+    name: string;
+    description: string;
+    whenToUse: string;
+    whenNotToUse?: string | undefined;
+    sideEffects: ToolSideEffects;
+    readOnly: boolean;
+    supportsClarification: boolean;
+    targetKinds: readonly string[];
+    inputDescriptions: ToolInputDescriptions;
+    outputDescription: ToolOutputDescription;
+    inputSchema: JsonSchema;
+    handler: (db: AffinityDb, input: TInput) => TResult;
+}
+type ToolDefinitionRegistry = readonly AffinityToolDefinition<never, ToolResult<unknown>>[];
+declare function defineAffinityTool<TInput, TResult extends ToolResult<unknown>>(definition: AffinityToolDefinition<TInput, TResult>): AffinityToolDefinition<TInput, TResult>;
+declare function stringSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function numberSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function integerSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function booleanSchema(description: string, options?: Partial<JsonSchema>): JsonSchema;
+declare function enumSchema(description: string, values: ReadonlyArray<boolean | number | string | null>): JsonSchema;
+declare function literalSchema(value: boolean | number | string | null, description?: string): JsonSchema;
+declare function arraySchema(items: JsonSchema, description: string): JsonSchema;
+declare function objectSchema(properties: Record<string, JsonSchema>, required: ReadonlyArray<string>, description?: string): JsonSchema;
+declare function nullableStringSchema(description: string): JsonSchema;
+declare function oneOfSchema(schemas: ReadonlyArray<JsonSchema>, description?: string): JsonSchema;
+
+type ContactLocator = {
+    contactId: number;
+} | {
+    identity: {
+        type: string;
+        value: string;
+    };
+};
+type LinkLocator = {
+    linkId: number;
+} | {
+    endpoints: {
+        fromContactId: number;
+        toContactId: number;
+        kind?: string | undefined;
+        role?: string | null | undefined;
+        isStructural?: boolean | undefined;
+    };
+};
+type ResolvedTarget<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    result: ToolFailure | ToolNeedsClarification;
+};
+declare function resolveContactLocator(db: AffinityDb, locator: ContactLocator, field?: string): ResolvedTarget<ContactRow>;
+declare function resolveLinkLocator(db: AffinityDb, locator: LinkLocator, field?: string): ResolvedTarget<LinkRow>;
+declare function mapErrorToToolFailure(error: unknown, summary?: string): ToolFailure;
+declare function withToolHandling<TData>(operation: () => ToolResult<TData>, summary?: string): ToolResult<TData>;
+
+type InspectAffinityItemToolInput = {
+    kind: "owner_profile";
+    topLinksLimit?: number;
+} | {
+    kind: "contact_profile";
+    contact: ContactLocator;
+    topLinksLimit?: number;
+} | {
+    kind: "link";
+    link: LinkLocator;
+    recentEventsLimit?: number;
+};
+type InspectAffinityItemToolData = {
+    kind: "owner_profile";
+    detail: ContactProfileRecord;
+} | {
+    kind: "contact_profile";
+    detail: ContactProfileRecord;
+} | {
+    kind: "link";
+    detail: LinkDetailRecord;
+};
+type InspectAffinityItemToolResult = ToolResult<InspectAffinityItemToolData>;
+declare function inspectAffinityItemToolHandler(db: AffinityDb, input: InspectAffinityItemToolInput): InspectAffinityItemToolResult;
+declare const inspectAffinityItemTool: AffinityToolDefinition<InspectAffinityItemToolInput, InspectAffinityItemToolResult>;
+
+interface MutationToolData<TPrimary> {
+    action: string;
+    primary: TPrimary;
+    created: MutationReceipt<TPrimary>["created"];
+    updated: MutationReceipt<TPrimary>["updated"];
+    archived: MutationReceipt<TPrimary>["archived"];
+    removed: MutationReceipt<TPrimary>["removed"];
+    affectedLinks: number[];
+    derivedEffects: MutationReceipt<TPrimary>["derivedEffects"];
+}
+declare function mutationToolResult<TPrimary>(action: string, receipt: MutationReceipt<TPrimary>, entitySummary: string): ToolResult<MutationToolData<TPrimary>>;
+
+type AttributeTargetInput = {
+    kind: "contact";
+    contact: ContactLocator;
+} | {
+    kind: "link";
+    link: LinkLocator;
+};
+type ManageAttributeToolInput = {
+    action: "set";
+    target: AttributeTargetInput;
+    name: string;
+    value: string | null;
+} | {
+    action: "unset";
+    target: AttributeTargetInput;
+    name: string;
+    removedAt?: number;
+} | {
+    action: "replace";
+    target: AttributeTargetInput;
+    entries: AttributeEntry[];
+};
+type ManageAttributeToolResult = ToolResult<MutationToolData<AttributeRecord>>;
+declare function manageAttributeToolHandler(db: AffinityDb, input: ManageAttributeToolInput): ManageAttributeToolResult;
+declare const manageAttributeTool: AffinityToolDefinition<ManageAttributeToolInput, ManageAttributeToolResult>;
+
+type ManageCommitmentToolInput = {
+    action: "record";
+    input: RecordCommitmentInput;
+} | {
+    action: "resolve";
+    commitmentEventId: number;
+    resolution: CommitmentResolutionKind;
+    options?: ResolveCommitmentOptions;
+};
+type ManageCommitmentToolResult = ToolResult<MutationToolData<EventRecord>>;
+declare function manageCommitmentToolHandler(db: AffinityDb, input: ManageCommitmentToolInput): ManageCommitmentToolResult;
+declare const manageCommitmentTool: AffinityToolDefinition<ManageCommitmentToolInput, ManageCommitmentToolResult>;
+
+type ManageContactToolInput = {
+    action: "create";
+    input: CreateContactInput;
+} | {
+    action: "revise";
+    contact: ContactLocator;
+    patch: ReviseContactPatch;
+} | {
+    action: "set_lifecycle";
+    contact: ContactLocator;
+    lifecycleState: ContactLifecycleState;
+    options?: SetContactLifecycleOptions;
+};
+type ManageContactToolResult = ToolResult<MutationToolData<ContactListItem>>;
+declare function manageContactToolHandler(db: AffinityDb, input: ManageContactToolInput): ManageContactToolResult;
+declare const manageContactTool: AffinityToolDefinition<ManageContactToolInput, ManageContactToolResult>;
+
+type DateAnchorTargetInput = {
+    kind: "contact";
+    contact: ContactLocator;
+} | {
+    kind: "link";
+    link: LinkLocator;
+};
+type ManageDateAnchorToolInput = {
+    action: "add";
+    input: Omit<AddDateAnchorInput, "target"> & {
+        target: DateAnchorTargetInput;
+    };
+} | {
+    action: "revise";
+    anchorEventId: number;
+    patch: ReviseDateAnchorPatch;
+    options?: ReviseDateAnchorOptions;
+} | {
+    action: "remove";
+    anchorEventId: number;
+    removedAt?: number;
+};
+type ManageDateAnchorToolResult = ToolResult<MutationToolData<EventRecord>>;
+declare function manageDateAnchorToolHandler(db: AffinityDb, input: ManageDateAnchorToolInput): ManageDateAnchorToolResult;
+declare const manageDateAnchorTool: AffinityToolDefinition<ManageDateAnchorToolInput, ManageDateAnchorToolResult>;
+
+type ManageIdentityToolInput = {
+    action: "add";
+    contact: ContactLocator;
+    input: AddIdentityInput;
+} | {
+    action: "revise";
+    identityId: number;
+    patch: ReviseIdentityPatch;
+} | {
+    action: "verify";
+    identityId: number;
+    verifiedAt?: number;
+} | {
+    action: "remove";
+    identityId: number;
+    removedAt?: number;
+};
+type ManageIdentityToolResult = ToolResult<MutationToolData<IdentityRecord>>;
+declare function manageIdentityToolHandler(db: AffinityDb, input: ManageIdentityToolInput): ManageIdentityToolResult;
+declare const manageIdentityTool: AffinityToolDefinition<ManageIdentityToolInput, ManageIdentityToolResult>;
+
+type ManageRelationshipToolInput = {
+    action: "seed_social_link";
+    from: ContactLocator;
+    to: ContactLocator;
+    input: Omit<SeedSocialLinkInput, "fromContactId" | "toContactId">;
+} | {
+    action: "revise_bond";
+    link: LinkLocator;
+    bond: string | null;
+    options?: LinkMutationOptions;
+} | {
+    action: "override_state";
+    link: LinkLocator;
+    state: LinkState;
+    options?: LinkMutationOptions;
+} | {
+    action: "set_structural_tie";
+    from: ContactLocator;
+    to: ContactLocator;
+    input: Omit<SetStructuralTieInput, "fromContactId" | "toContactId">;
+} | {
+    action: "remove_structural_tie";
+    link: LinkLocator;
+    removedAt?: number;
+};
+type ManageRelationshipToolResult = ToolResult<MutationToolData<LinkListItem>>;
+declare function manageRelationshipToolHandler(db: AffinityDb, input: ManageRelationshipToolInput): ManageRelationshipToolResult;
+declare const manageRelationshipTool: AffinityToolDefinition<ManageRelationshipToolInput, ManageRelationshipToolResult>;
+
+interface MergeContactsToolInput {
+    winner: ContactLocator;
+    loser: ContactLocator;
+    reasonSummary?: string | null;
+    now?: number;
+}
+type MergeContactsToolResult = ToolResult<MutationToolData<MergePrimary>>;
+declare function mergeContactsToolHandler(db: AffinityDb, input: MergeContactsToolInput): MergeContactsToolResult;
+declare const mergeContactsTool: AffinityToolDefinition<MergeContactsToolInput, MergeContactsToolResult>;
+
+type RecordEventToolInput = {
+    kind: "interaction";
+    input: RecordInteractionInput;
+} | {
+    kind: "observation";
+    input: RecordObservationInput;
+} | {
+    kind: "milestone";
+    input: RecordMilestoneInput;
+} | {
+    kind: "transaction";
+    input: RecordTransactionInput;
+};
+type RecordEventToolResult = ToolResult<MutationToolData<EventRecord>>;
+declare function recordEventToolHandler(db: AffinityDb, input: RecordEventToolInput): RecordEventToolResult;
+declare const recordEventTool: AffinityToolDefinition<RecordEventToolInput, RecordEventToolResult>;
+
+type ReviewAffinityToolView = "contacts.list" | "contacts.duplicates" | "events.contact_journal" | "events.link_timeline" | "events.moments" | "commitments.open" | "links.owner" | "links.observed" | "links.progression_readiness" | "links.radar" | "dates.upcoming" | "graph.chart" | "merges.history";
+interface ReviewAffinityToolInput {
+    view: ReviewAffinityToolView;
+    contact?: ContactLocator;
+    link?: LinkLocator;
+    contactIds?: number[];
+    kind?: ContactKind | LinkKind;
+    lifecycleState?: ContactLifecycleState;
+    linkState?: LinkState;
+    includeOwner?: boolean;
+    includeDormant?: boolean;
+    includeArchived?: boolean;
+    includeObserved?: boolean;
+    eventTypes?: EventType[];
+    momentKind?: EventMomentKind;
+    commitmentType?: "promise" | "agreement";
+    recurrenceKind?: EventRecurrenceKind;
+    horizonDays?: number;
+    exactOnly?: boolean;
+    minScore?: number;
+    since?: number;
+    until?: number;
+    limit?: number;
+    offset?: number;
+}
+interface ReviewAffinityToolData {
+    view: ReviewAffinityToolView;
+    items: ToolListItem[];
+    count: number;
+    appliedFilters: Record<string, unknown>;
+    chart?: AffinityChartRecord | undefined;
+}
+type ReviewAffinityToolResult = ToolResult<ReviewAffinityToolData>;
+declare function reviewAffinityToolHandler(db: AffinityDb, input: ReviewAffinityToolInput): ReviewAffinityToolResult;
+declare const reviewAffinityTool: AffinityToolDefinition<ReviewAffinityToolInput, ReviewAffinityToolResult>;
+
+declare function toContactEntityRef(value: ContactCore | ContactListItem | ContactRow): ToolEntityRef;
+declare function toContactListToolItem(value: ContactCore | ContactListItem | ContactRow): ToolListItem;
+declare function toIdentityEntityRef(value: IdentityRecord): ToolEntityRef;
+declare function toIdentityListToolItem(value: IdentityRecord): ToolListItem;
+declare function toLinkEntityRef(value: LinkListItem | LinkRow): ToolEntityRef;
+declare function toLinkListToolItem(value: LinkListItem | LinkRow): ToolListItem;
+declare function toEventEntityRef(value: EventRecord): ToolEntityRef;
+declare function toEventListToolItem(value: EventRecord): ToolListItem;
+declare function toAttributeEntityRef(value: AttributeRecord): ToolEntityRef;
+declare function toAttributeListToolItem(value: AttributeRecord): ToolListItem;
+declare function toMutationRefEntity(ref: EntityRef): ToolEntityRef;
+declare function toReceiptEntityRefs<TPrimary>(receipt: MutationReceipt<TPrimary>): ToolEntityRef[];
+
+interface SearchAffinityToolInput {
+    query: string;
+    kind?: ContactKind;
+    lifecycleState?: ContactLifecycleState;
+    includeOwner?: boolean;
+    includeDormant?: boolean;
+    limit?: number;
+    offset?: number;
+}
+interface SearchAffinityToolData {
+    query: string;
+    items: ReturnType<typeof toContactListToolItem>[];
+    count: number;
+}
+type SearchAffinityToolResult = ToolResult<SearchAffinityToolData>;
+declare function searchAffinityToolHandler(db: AffinityDb, input: SearchAffinityToolInput): SearchAffinityToolResult;
+declare const searchAffinityTool: AffinityToolDefinition<SearchAffinityToolInput, SearchAffinityToolResult>;
+
+declare const affinityTools: (AffinityToolDefinition<InspectAffinityItemToolInput, InspectAffinityItemToolResult> | AffinityToolDefinition<ManageAttributeToolInput, ManageAttributeToolResult> | AffinityToolDefinition<ManageCommitmentToolInput, ManageCommitmentToolResult> | AffinityToolDefinition<ManageContactToolInput, ManageContactToolResult> | AffinityToolDefinition<ManageDateAnchorToolInput, ManageDateAnchorToolResult> | AffinityToolDefinition<ManageIdentityToolInput, ManageIdentityToolResult> | AffinityToolDefinition<ManageRelationshipToolInput, ManageRelationshipToolResult> | AffinityToolDefinition<MergeContactsToolInput, MergeContactsToolResult> | AffinityToolDefinition<RecordEventToolInput, RecordEventToolResult> | AffinityToolDefinition<ReviewAffinityToolInput, ReviewAffinityToolResult> | AffinityToolDefinition<SearchAffinityToolInput, SearchAffinityToolResult>)[];
+declare function listAffinityToolDefinitions(): (AffinityToolDefinition<InspectAffinityItemToolInput, InspectAffinityItemToolResult> | AffinityToolDefinition<ManageAttributeToolInput, ManageAttributeToolResult> | AffinityToolDefinition<ManageCommitmentToolInput, ManageCommitmentToolResult> | AffinityToolDefinition<ManageContactToolInput, ManageContactToolResult> | AffinityToolDefinition<ManageDateAnchorToolInput, ManageDateAnchorToolResult> | AffinityToolDefinition<ManageIdentityToolInput, ManageIdentityToolResult> | AffinityToolDefinition<ManageRelationshipToolInput, ManageRelationshipToolResult> | AffinityToolDefinition<MergeContactsToolInput, MergeContactsToolResult> | AffinityToolDefinition<RecordEventToolInput, RecordEventToolResult> | AffinityToolDefinition<ReviewAffinityToolInput, ReviewAffinityToolResult> | AffinityToolDefinition<SearchAffinityToolInput, SearchAffinityToolResult>)[];
+declare function getAffinityToolByName(name: string): AffinityToolDefinition<InspectAffinityItemToolInput, InspectAffinityItemToolResult> | AffinityToolDefinition<ManageAttributeToolInput, ManageAttributeToolResult> | AffinityToolDefinition<ManageCommitmentToolInput, ManageCommitmentToolResult> | AffinityToolDefinition<ManageContactToolInput, ManageContactToolResult> | AffinityToolDefinition<ManageDateAnchorToolInput, ManageDateAnchorToolResult> | AffinityToolDefinition<ManageIdentityToolInput, ManageIdentityToolResult> | AffinityToolDefinition<ManageRelationshipToolInput, ManageRelationshipToolResult> | AffinityToolDefinition<MergeContactsToolInput, MergeContactsToolResult> | AffinityToolDefinition<RecordEventToolInput, RecordEventToolResult> | AffinityToolDefinition<ReviewAffinityToolInput, ReviewAffinityToolResult> | AffinityToolDefinition<SearchAffinityToolInput, SearchAffinityToolResult> | null;
+
+interface AffinityToolMapping {
+    source: string;
+    tool: string;
+    action?: string;
+    view?: string;
+    notes?: string;
+}
+declare const affinityToolMappings: AffinityToolMapping[];
+
+declare const searchAffinityToolName = "search_affinity";
+declare const reviewAffinityToolName = "review_affinity";
+declare const inspectAffinityItemToolName = "inspect_affinity_item";
+declare const manageContactToolName = "manage_contact";
+declare const mergeContactsToolName = "merge_contacts";
+declare const manageIdentityToolName = "manage_identity";
+declare const manageRelationshipToolName = "manage_relationship";
+declare const recordEventToolName = "record_event";
+declare const manageCommitmentToolName = "manage_commitment";
+declare const manageDateAnchorToolName = "manage_date_anchor";
+declare const manageAttributeToolName = "manage_attribute";
+
+declare function summarizeCount(count: number, singular: string): string;
+
+type index_AffinityToolDefinition<TInput, TResult extends ToolResult<unknown>> = AffinityToolDefinition<TInput, TResult>;
+type index_AffinityToolMapping = AffinityToolMapping;
+type index_ContactLocator = ContactLocator;
+type index_JsonSchema = JsonSchema;
+type index_JsonSchemaType = JsonSchemaType;
+type index_LinkLocator = LinkLocator;
+type index_MutationToolData<TPrimary> = MutationToolData<TPrimary>;
+type index_ResolvedTarget<T> = ResolvedTarget<T>;
+type index_ToolBaseResult = ToolBaseResult;
+type index_ToolDefinitionRegistry = ToolDefinitionRegistry;
+type index_ToolEntityKind = ToolEntityKind;
+type index_ToolEntityRef = ToolEntityRef;
+type index_ToolFailure = ToolFailure;
+type index_ToolInputDescriptions = ToolInputDescriptions;
+type index_ToolListItem = ToolListItem;
+type index_ToolNeedsClarification = ToolNeedsClarification;
+type index_ToolNextStepHint = ToolNextStepHint;
+type index_ToolOutcomeKind = ToolOutcomeKind;
+type index_ToolOutputDescription = ToolOutputDescription;
+type index_ToolResult<TData> = ToolResult<TData>;
+type index_ToolSideEffects = ToolSideEffects;
+type index_ToolSuccess<TData> = ToolSuccess<TData>;
+type index_ToolWarning = ToolWarning;
+declare const index_affinityToolMappings: typeof affinityToolMappings;
+declare const index_affinityTools: typeof affinityTools;
+declare const index_arraySchema: typeof arraySchema;
+declare const index_booleanSchema: typeof booleanSchema;
+declare const index_defineAffinityTool: typeof defineAffinityTool;
+declare const index_enumSchema: typeof enumSchema;
+declare const index_getAffinityToolByName: typeof getAffinityToolByName;
+declare const index_inspectAffinityItemTool: typeof inspectAffinityItemTool;
+declare const index_inspectAffinityItemToolHandler: typeof inspectAffinityItemToolHandler;
+declare const index_inspectAffinityItemToolName: typeof inspectAffinityItemToolName;
+declare const index_integerSchema: typeof integerSchema;
+declare const index_listAffinityToolDefinitions: typeof listAffinityToolDefinitions;
+declare const index_literalSchema: typeof literalSchema;
+declare const index_manageAttributeTool: typeof manageAttributeTool;
+declare const index_manageAttributeToolHandler: typeof manageAttributeToolHandler;
+declare const index_manageAttributeToolName: typeof manageAttributeToolName;
+declare const index_manageCommitmentTool: typeof manageCommitmentTool;
+declare const index_manageCommitmentToolHandler: typeof manageCommitmentToolHandler;
+declare const index_manageCommitmentToolName: typeof manageCommitmentToolName;
+declare const index_manageContactTool: typeof manageContactTool;
+declare const index_manageContactToolHandler: typeof manageContactToolHandler;
+declare const index_manageContactToolName: typeof manageContactToolName;
+declare const index_manageDateAnchorTool: typeof manageDateAnchorTool;
+declare const index_manageDateAnchorToolHandler: typeof manageDateAnchorToolHandler;
+declare const index_manageDateAnchorToolName: typeof manageDateAnchorToolName;
+declare const index_manageIdentityTool: typeof manageIdentityTool;
+declare const index_manageIdentityToolHandler: typeof manageIdentityToolHandler;
+declare const index_manageIdentityToolName: typeof manageIdentityToolName;
+declare const index_manageRelationshipTool: typeof manageRelationshipTool;
+declare const index_manageRelationshipToolHandler: typeof manageRelationshipToolHandler;
+declare const index_manageRelationshipToolName: typeof manageRelationshipToolName;
+declare const index_mapErrorToToolFailure: typeof mapErrorToToolFailure;
+declare const index_mergeContactsTool: typeof mergeContactsTool;
+declare const index_mergeContactsToolHandler: typeof mergeContactsToolHandler;
+declare const index_mergeContactsToolName: typeof mergeContactsToolName;
+declare const index_mutationToolResult: typeof mutationToolResult;
+declare const index_nullableStringSchema: typeof nullableStringSchema;
+declare const index_numberSchema: typeof numberSchema;
+declare const index_objectSchema: typeof objectSchema;
+declare const index_oneOfSchema: typeof oneOfSchema;
+declare const index_recordEventTool: typeof recordEventTool;
+declare const index_recordEventToolHandler: typeof recordEventToolHandler;
+declare const index_recordEventToolName: typeof recordEventToolName;
+declare const index_resolveContactLocator: typeof resolveContactLocator;
+declare const index_resolveLinkLocator: typeof resolveLinkLocator;
+declare const index_reviewAffinityTool: typeof reviewAffinityTool;
+declare const index_reviewAffinityToolHandler: typeof reviewAffinityToolHandler;
+declare const index_reviewAffinityToolName: typeof reviewAffinityToolName;
+declare const index_searchAffinityTool: typeof searchAffinityTool;
+declare const index_searchAffinityToolHandler: typeof searchAffinityToolHandler;
+declare const index_searchAffinityToolName: typeof searchAffinityToolName;
+declare const index_stringSchema: typeof stringSchema;
+declare const index_summarizeCount: typeof summarizeCount;
+declare const index_toAttributeEntityRef: typeof toAttributeEntityRef;
+declare const index_toAttributeListToolItem: typeof toAttributeListToolItem;
+declare const index_toContactEntityRef: typeof toContactEntityRef;
+declare const index_toContactListToolItem: typeof toContactListToolItem;
+declare const index_toEventEntityRef: typeof toEventEntityRef;
+declare const index_toEventListToolItem: typeof toEventListToolItem;
+declare const index_toIdentityEntityRef: typeof toIdentityEntityRef;
+declare const index_toIdentityListToolItem: typeof toIdentityListToolItem;
+declare const index_toLinkEntityRef: typeof toLinkEntityRef;
+declare const index_toLinkListToolItem: typeof toLinkListToolItem;
+declare const index_toMutationRefEntity: typeof toMutationRefEntity;
+declare const index_toReceiptEntityRefs: typeof toReceiptEntityRefs;
+declare const index_toolFailure: typeof toolFailure;
+declare const index_toolNeedsClarification: typeof toolNeedsClarification;
+declare const index_toolNoOp: typeof toolNoOp;
+declare const index_toolSuccess: typeof toolSuccess;
+declare const index_toolWarning: typeof toolWarning;
+declare const index_withToolHandling: typeof withToolHandling;
+declare namespace index {
+  export { type index_AffinityToolDefinition as AffinityToolDefinition, type index_AffinityToolMapping as AffinityToolMapping, type index_ContactLocator as ContactLocator, type index_JsonSchema as JsonSchema, type index_JsonSchemaType as JsonSchemaType, type index_LinkLocator as LinkLocator, type index_MutationToolData as MutationToolData, type index_ResolvedTarget as ResolvedTarget, type index_ToolBaseResult as ToolBaseResult, type index_ToolDefinitionRegistry as ToolDefinitionRegistry, type index_ToolEntityKind as ToolEntityKind, type index_ToolEntityRef as ToolEntityRef, type index_ToolFailure as ToolFailure, type index_ToolInputDescriptions as ToolInputDescriptions, type index_ToolListItem as ToolListItem, type index_ToolNeedsClarification as ToolNeedsClarification, type index_ToolNextStepHint as ToolNextStepHint, type index_ToolOutcomeKind as ToolOutcomeKind, type index_ToolOutputDescription as ToolOutputDescription, type index_ToolResult as ToolResult, type index_ToolSideEffects as ToolSideEffects, type index_ToolSuccess as ToolSuccess, type index_ToolWarning as ToolWarning, index_affinityToolMappings as affinityToolMappings, index_affinityTools as affinityTools, index_arraySchema as arraySchema, index_booleanSchema as booleanSchema, index_defineAffinityTool as defineAffinityTool, index_enumSchema as enumSchema, index_getAffinityToolByName as getAffinityToolByName, index_inspectAffinityItemTool as inspectAffinityItemTool, index_inspectAffinityItemToolHandler as inspectAffinityItemToolHandler, index_inspectAffinityItemToolName as inspectAffinityItemToolName, index_integerSchema as integerSchema, index_listAffinityToolDefinitions as listAffinityToolDefinitions, index_literalSchema as literalSchema, index_manageAttributeTool as manageAttributeTool, index_manageAttributeToolHandler as manageAttributeToolHandler, index_manageAttributeToolName as manageAttributeToolName, index_manageCommitmentTool as manageCommitmentTool, index_manageCommitmentToolHandler as manageCommitmentToolHandler, index_manageCommitmentToolName as manageCommitmentToolName, index_manageContactTool as manageContactTool, index_manageContactToolHandler as manageContactToolHandler, index_manageContactToolName as manageContactToolName, index_manageDateAnchorTool as manageDateAnchorTool, index_manageDateAnchorToolHandler as manageDateAnchorToolHandler, index_manageDateAnchorToolName as manageDateAnchorToolName, index_manageIdentityTool as manageIdentityTool, index_manageIdentityToolHandler as manageIdentityToolHandler, index_manageIdentityToolName as manageIdentityToolName, index_manageRelationshipTool as manageRelationshipTool, index_manageRelationshipToolHandler as manageRelationshipToolHandler, index_manageRelationshipToolName as manageRelationshipToolName, index_mapErrorToToolFailure as mapErrorToToolFailure, index_mergeContactsTool as mergeContactsTool, index_mergeContactsToolHandler as mergeContactsToolHandler, index_mergeContactsToolName as mergeContactsToolName, index_mutationToolResult as mutationToolResult, index_nullableStringSchema as nullableStringSchema, index_numberSchema as numberSchema, index_objectSchema as objectSchema, index_oneOfSchema as oneOfSchema, index_recordEventTool as recordEventTool, index_recordEventToolHandler as recordEventToolHandler, index_recordEventToolName as recordEventToolName, index_resolveContactLocator as resolveContactLocator, index_resolveLinkLocator as resolveLinkLocator, index_reviewAffinityTool as reviewAffinityTool, index_reviewAffinityToolHandler as reviewAffinityToolHandler, index_reviewAffinityToolName as reviewAffinityToolName, index_searchAffinityTool as searchAffinityTool, index_searchAffinityToolHandler as searchAffinityToolHandler, index_searchAffinityToolName as searchAffinityToolName, index_stringSchema as stringSchema, index_summarizeCount as summarizeCount, index_toAttributeEntityRef as toAttributeEntityRef, index_toAttributeListToolItem as toAttributeListToolItem, index_toContactEntityRef as toContactEntityRef, index_toContactListToolItem as toContactListToolItem, index_toEventEntityRef as toEventEntityRef, index_toEventListToolItem as toEventListToolItem, index_toIdentityEntityRef as toIdentityEntityRef, index_toIdentityListToolItem as toIdentityListToolItem, index_toLinkEntityRef as toLinkEntityRef, index_toLinkListToolItem as toLinkListToolItem, index_toMutationRefEntity as toMutationRefEntity, index_toReceiptEntityRefs as toReceiptEntityRefs, index_toolFailure as toolFailure, index_toolNeedsClarification as toolNeedsClarification, index_toolNoOp as toolNoOp, index_toolSuccess as toolSuccess, index_toolWarning as toolWarning, index_withToolHandling as withToolHandling };
+}
+
+declare function addIdentity(db: AffinityDb, contactId: number, input: AddIdentityInput): IdentityMutationReceipt;
+
+declare function removeIdentity(db: AffinityDb, identityId: number, removedAt?: number): IdentityMutationReceipt;
+
+declare function reviseIdentity(db: AffinityDb, identityId: number, patch: ReviseIdentityPatch): IdentityMutationReceipt;
+
+declare function verifyIdentity(db: AffinityDb, identityId: number, verifiedAt?: number): IdentityMutationReceipt;
+
+declare function replaceAttributes(db: AffinityDb, target: AttributeTarget, entries: readonly AttributeEntry[]): AttributeMutationReceipt;
+
+declare function setAttribute(db: AffinityDb, target: AttributeTarget, name: string, value: string | null): AttributeMutationReceipt;
+
+declare function unsetAttribute(db: AffinityDb, target: AttributeTarget, name: string, removedAt?: number): AttributeMutationReceipt;
+
+declare const write_addDateAnchor: typeof addDateAnchor;
+declare const write_addIdentity: typeof addIdentity;
+declare const write_createContact: typeof createContact;
+declare const write_mergeContacts: typeof mergeContacts;
+declare const write_overrideLinkState: typeof overrideLinkState;
+declare const write_recordCommitment: typeof recordCommitment;
+declare const write_recordInteraction: typeof recordInteraction;
+declare const write_recordMilestone: typeof recordMilestone;
+declare const write_recordObservation: typeof recordObservation;
+declare const write_recordTransaction: typeof recordTransaction;
+declare const write_removeDateAnchor: typeof removeDateAnchor;
+declare const write_removeIdentity: typeof removeIdentity;
+declare const write_removeStructuralTie: typeof removeStructuralTie;
+declare const write_replaceAttributes: typeof replaceAttributes;
+declare const write_resolveCommitment: typeof resolveCommitment;
+declare const write_reviseBond: typeof reviseBond;
+declare const write_reviseContact: typeof reviseContact;
+declare const write_reviseDateAnchor: typeof reviseDateAnchor;
+declare const write_reviseIdentity: typeof reviseIdentity;
+declare const write_seedSocialLink: typeof seedSocialLink;
+declare const write_setAttribute: typeof setAttribute;
+declare const write_setContactLifecycle: typeof setContactLifecycle;
+declare const write_setStructuralTie: typeof setStructuralTie;
+declare const write_unsetAttribute: typeof unsetAttribute;
+declare const write_verifyIdentity: typeof verifyIdentity;
+declare namespace write {
+  export { write_addDateAnchor as addDateAnchor, write_addIdentity as addIdentity, write_createContact as createContact, write_mergeContacts as mergeContacts, write_overrideLinkState as overrideLinkState, write_recordCommitment as recordCommitment, write_recordInteraction as recordInteraction, write_recordMilestone as recordMilestone, write_recordObservation as recordObservation, write_recordTransaction as recordTransaction, write_removeDateAnchor as removeDateAnchor, write_removeIdentity as removeIdentity, write_removeStructuralTie as removeStructuralTie, write_replaceAttributes as replaceAttributes, write_resolveCommitment as resolveCommitment, write_reviseBond as reviseBond, write_reviseContact as reviseContact, write_reviseDateAnchor as reviseDateAnchor, write_reviseIdentity as reviseIdentity, write_seedSocialLink as seedSocialLink, write_setAttribute as setAttribute, write_setContactLifecycle as setContactLifecycle, write_setStructuralTie as setStructuralTie, write_unsetAttribute as unsetAttribute, write_verifyIdentity as verifyIdentity };
+}
+
+export { AffinityConflictError, AffinityError, type AffinityErrorCode, AffinityInvariantError, AffinityMergeError, AffinityNotFoundError, type AffinitySkill, type AffinitySkillRegistry, type AffinitySoul, type AffinitySoulTrait, AffinityStateError, AffinityValidationError, affinitySkills, affinitySoul, affinitySoulEssence, affinitySoulTraits, bootstrapAndColdStartSkill, captureTransactionsAndCommercialEventsSkill, defineAffinitySkill, errors, getAffinitySkillByName, identifyAndLocateContactsSkill, importHistoryWithoutFakingEvidenceSkill, initAffinityTables, isAffinityError, listAffinitySkills, managePromisesAndAgreementsSkill, manageRecurringDatesAndRemindersSkill, modelStructureOrgsAndHouseholdsSkill, read, reconcileDuplicatesAndMergeSafelySkill, recordDirectEvidenceWellSkill, recordObservationsAndReferralsSkill, renderAffinitySoulPromptFoundation, reviewRadarProgressionAndGraphSkill, index$1 as skills, soul, index as tools, types, write };