@elizaos/plugin-personal-assistant 2.0.3-beta.5 → 2.0.3-beta.7

package/dist/lifeops/entities/merge.js

@@ -0,0 +1,17 @@
+import {
+  AUTO_MERGE_CONFIDENCE_THRESHOLD,
+  decideIdentityOutcome,
+  findIdentityMatches,
+  foldIdentity,
+  mergeEntities,
+  OVERRIDE_CONFIDENCE_DELTA
+} from "@elizaos/shared";
+export {
+  AUTO_MERGE_CONFIDENCE_THRESHOLD,
+  OVERRIDE_CONFIDENCE_DELTA,
+  decideIdentityOutcome,
+  findIdentityMatches,
+  foldIdentity,
+  mergeEntities
+};
+//# sourceMappingURL=merge.js.map

package/dist/lifeops/entities/merge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/entities/merge.ts"],"sourcesContent":["/**\n * Identity-merge engine for the EntityStore.\n *\n * Canonical home is `@elizaos/shared` (`knowledge-graph/merge.ts`). This\n * module re-exports the pure merge functions so the DB-backed `EntityStore`\n * and the rest of LifeOps keep importing from `./merge.js`.\n */\n\nexport {\n  AUTO_MERGE_CONFIDENCE_THRESHOLD,\n  decideIdentityOutcome,\n  findIdentityMatches,\n  foldIdentity,\n  type IdentityMatchInput,\n  type IdentityObserveOutcome,\n  mergeEntities,\n  OVERRIDE_CONFIDENCE_DELTA,\n} from \"@elizaos/shared\";\n"],"mappings":"AAQA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,EAGA;AAAA,EACA;AAAA,OACK;","names":[]}

package/dist/lifeops/entities/store.d.ts

@@ -0,0 +1,13 @@
+/**
+ * EntityStore re-export shim.
+ *
+ * The DB-backed `EntityStore` is now a runtime primitive owned by
+ * `@elizaos/agent` and surfaced through `KnowledgeGraphService`. This module
+ * re-exports it so the rest of LifeOps keeps importing from `./store.js`.
+ * New code should resolve the store via the runtime service:
+ *
+ *   resolveKnowledgeGraphService(runtime)?.getEntityStore(agentId)
+ */
+export { EntityStore } from "@elizaos/agent";
+export { AUTO_MERGE_CONFIDENCE_THRESHOLD } from "@elizaos/shared";
+//# sourceMappingURL=store.d.ts.map

package/dist/lifeops/entities/store.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../../src/lifeops/entities/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;;GASG;AAEH,OAAO,EAAE,WAAW,EAAE,MAAM,gBAAgB,CAAC;AAC7C,OAAO,EAAE,+BAA+B,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/lifeops/entities/store.js

@@ -0,0 +1,7 @@
+import { EntityStore } from "@elizaos/agent";
+import { AUTO_MERGE_CONFIDENCE_THRESHOLD } from "@elizaos/shared";
+export {
+  AUTO_MERGE_CONFIDENCE_THRESHOLD,
+  EntityStore
+};
+//# sourceMappingURL=store.js.map

package/dist/lifeops/entities/store.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/entities/store.ts"],"sourcesContent":["/**\n * EntityStore re-export shim.\n *\n * The DB-backed `EntityStore` is now a runtime primitive owned by\n * `@elizaos/agent` and surfaced through `KnowledgeGraphService`. This module\n * re-exports it so the rest of LifeOps keeps importing from `./store.js`.\n * New code should resolve the store via the runtime service:\n *\n *   resolveKnowledgeGraphService(runtime)?.getEntityStore(agentId)\n */\n\nexport { EntityStore } from \"@elizaos/agent\";\nexport { AUTO_MERGE_CONFIDENCE_THRESHOLD } from \"@elizaos/shared\";\n"],"mappings":"AAWA,SAAS,mBAAmB;AAC5B,SAAS,uCAAuC;","names":[]}

package/dist/lifeops/entities/types.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Entity types for the LifeOps knowledge graph.
+ *
+ * Canonical home is `@elizaos/shared` (`knowledge-graph/entity-types.ts`).
+ * This module re-exports the runtime-level primitives so the DB-backed
+ * `EntityStore` and the rest of LifeOps keep importing from `./types.js`.
+ */
+export { BUILT_IN_ENTITY_TYPES, type BuiltInEntityType, defaultEntityTypeRegistry, type Entity, type EntityAttribute, type EntityFilter, type EntityIdentity, type EntityIdentityAddedVia, type EntityResolveCandidate, type EntityState, EntityTypeRegistry, type EntityVisibility, SELF_ENTITY_ID, } from "@elizaos/shared";
+//# sourceMappingURL=types.d.ts.map

package/dist/lifeops/entities/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../src/lifeops/entities/types.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,EACL,qBAAqB,EACrB,KAAK,iBAAiB,EACtB,yBAAyB,EACzB,KAAK,MAAM,EACX,KAAK,eAAe,EACpB,KAAK,YAAY,EACjB,KAAK,cAAc,EACnB,KAAK,sBAAsB,EAC3B,KAAK,sBAAsB,EAC3B,KAAK,WAAW,EAChB,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,cAAc,GACf,MAAM,iBAAiB,CAAC"}

package/dist/lifeops/entities/types.js

@@ -0,0 +1,13 @@
+import {
+  BUILT_IN_ENTITY_TYPES,
+  defaultEntityTypeRegistry,
+  EntityTypeRegistry,
+  SELF_ENTITY_ID
+} from "@elizaos/shared";
+export {
+  BUILT_IN_ENTITY_TYPES,
+  EntityTypeRegistry,
+  SELF_ENTITY_ID,
+  defaultEntityTypeRegistry
+};
+//# sourceMappingURL=types.js.map

package/dist/lifeops/entities/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/entities/types.ts"],"sourcesContent":["/**\n * Entity types for the LifeOps knowledge graph.\n *\n * Canonical home is `@elizaos/shared` (`knowledge-graph/entity-types.ts`).\n * This module re-exports the runtime-level primitives so the DB-backed\n * `EntityStore` and the rest of LifeOps keep importing from `./types.js`.\n */\n\nexport {\n  BUILT_IN_ENTITY_TYPES,\n  type BuiltInEntityType,\n  defaultEntityTypeRegistry,\n  type Entity,\n  type EntityAttribute,\n  type EntityFilter,\n  type EntityIdentity,\n  type EntityIdentityAddedVia,\n  type EntityResolveCandidate,\n  type EntityState,\n  EntityTypeRegistry,\n  type EntityVisibility,\n  SELF_ENTITY_ID,\n} from \"@elizaos/shared\";\n"],"mappings":"AAQA;AAAA,EACE;AAAA,EAEA;AAAA,EAQA;AAAA,EAEA;AAAA,OACK;","names":[]}

package/dist/lifeops/entities/voice-attribution.d.ts

@@ -0,0 +1,70 @@
+/**
+ * Voice-attribution helpers: bind a voice-imprint observation to an
+ * Entity (creating one if no match), extract name claims from
+ * utterance text, and resolve pending relationships when a previously-
+ * named partner finally speaks.
+ *
+ * Read R2-speaker.md §7 for the "Jill scenario" semantics that this
+ * module exists to implement.
+ */
+import type { EntityStore } from "./store.js";
+import type { SELF_ENTITY_ID } from "./types.js";
+export declare function extractSelfNameClaim(text: string | null | undefined): string | null;
+interface PartnerClaim {
+    name: string;
+    label: string;
+    type: "partner_of";
+}
+export declare function extractPartnerClaim(text: string | null | undefined): PartnerClaim | null;
+export interface PendingRelationship {
+    type: "partner_of";
+    fromEntityId: typeof SELF_ENTITY_ID;
+    toName: string;
+    label: string;
+    evidenceId: string;
+    createdAt: string;
+}
+/**
+ * In-memory pending-relationship queue. The "Jill scenario" needs
+ * cross-utterance state: Shaw says "this is Jill, Jill is my wife"
+ * **before** Jill ever speaks, so we can't resolve the relationship
+ * until Jill is known. The queue lives in process memory; the engine
+ * persists it (when needed) by writing the source utterance evidence
+ * id into the relationship audit log on resolution.
+ */
+export declare class PendingRelationshipQueue {
+    private pending;
+    enqueue(claim: PendingRelationship): void;
+    resolveByName(name: string): PendingRelationship[];
+    all(): readonly PendingRelationship[];
+    size(): number;
+}
+/**
+ * Result of binding a voice-imprint observation to an Entity.
+ */
+export interface BindVoiceTurnResult {
+    entityId: string;
+    wasCreated: boolean;
+    resolvedClaimedName: string | null;
+    pendingRelationships: PendingRelationship[];
+}
+/**
+ * Bind a voice-imprint observation to an Entity. If the imprint match
+ * resolves to an existing entity, returns that entity's id. Otherwise
+ * tries to extract a self-name claim from the utterance; either way,
+ * runs through `EntityStore.observeIdentity` with `platform:"voice"`.
+ *
+ * Pending-relationship resolution is delegated to the caller — the
+ * caller pulls `result.pendingRelationships` and applies them.
+ */
+export declare function bindVoiceTurnToEntity(args: {
+    entityStore: EntityStore;
+    pendingQueue: PendingRelationshipQueue;
+    matchedEntityId: string | null;
+    utteranceText: string;
+    imprintClusterId: string;
+    evidenceIds: string[];
+    matchConfidence: number;
+}): Promise<BindVoiceTurnResult>;
+export {};
+//# sourceMappingURL=voice-attribution.d.ts.map

package/dist/lifeops/entities/voice-attribution.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-attribution.d.ts","sourceRoot":"","sources":["../../../src/lifeops/entities/voice-attribution.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAC9C,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,YAAY,CAAC;AAgCjD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC9B,MAAM,GAAG,IAAI,CAUf;AA0BD,UAAU,YAAY;IACpB,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,IAAI,EAAE,YAAY,CAAC;CACpB;AAyBD,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAC9B,YAAY,GAAG,IAAI,CAarB;AAED,MAAM,WAAW,mBAAmB;IAClC,IAAI,EAAE,YAAY,CAAC;IACnB,YAAY,EAAE,OAAO,cAAc,CAAC;IACpC,MAAM,EAAE,MAAM,CAAC;IACf,KAAK,EAAE,MAAM,CAAC;IACd,UAAU,EAAE,MAAM,CAAC;IACnB,SAAS,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;GAOG;AACH,qBAAa,wBAAwB;IACnC,OAAO,CAAC,OAAO,CAA6B;IAE5C,OAAO,CAAC,KAAK,EAAE,mBAAmB,GAAG,IAAI;IAUzC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,mBAAmB,EAAE;IASlD,GAAG,IAAI,SAAS,mBAAmB,EAAE;IAIrC,IAAI,IAAI,MAAM;CAGf;AAED;;GAEG;AACH,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,MAAM,CAAC;IACjB,UAAU,EAAE,OAAO,CAAC;IACpB,mBAAmB,EAAE,MAAM,GAAG,IAAI,CAAC;IACnC,oBAAoB,EAAE,mBAAmB,EAAE,CAAC;CAC7C;AAED;;;;;;;;GAQG;AACH,wBAAsB,qBAAqB,CAAC,IAAI,EAAE;IAChD,WAAW,EAAE,WAAW,CAAC;IACzB,YAAY,EAAE,wBAAwB,CAAC;IACvC,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,aAAa,EAAE,MAAM,CAAC;IACtB,gBAAgB,EAAE,MAAM,CAAC;IACzB,WAAW,EAAE,MAAM,EAAE,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;CACzB,GAAG,OAAO,CAAC,mBAAmB,CAAC,CAgC/B"}

package/dist/lifeops/entities/voice-attribution.js

@@ -0,0 +1,121 @@
+const NAME_PATTERN = "[A-Z][A-Za-z'.-]{1,40}(?:\\s+[A-Z][A-Za-z'.-]{1,40}){0,2}";
+const NAME_CLAIM_PATTERNS = [
+  new RegExp(`\\b[Mm]y\\s+name\\s+is\\s+(${NAME_PATTERN})\\b`),
+  new RegExp(`\\b[Ii]\\s+am\\s+(${NAME_PATTERN})\\b`),
+  new RegExp(`\\b[Ii]['\u2019]?m\\s+(${NAME_PATTERN})\\b`),
+  new RegExp(`\\b[Tt]his\\s+is\\s+(${NAME_PATTERN})\\b`),
+  new RegExp(`\\b[Ii]t['\u2019]?s\\s+(${NAME_PATTERN})\\b`)
+];
+function extractSelfNameClaim(text) {
+  if (!text) return null;
+  for (const pattern of NAME_CLAIM_PATTERNS) {
+    const m = pattern.exec(text);
+    if (m?.[1]) {
+      const cleaned = m[1].replace(/[.,;:!?]+$/, "").trim();
+      if (cleaned.length > 0) return cleaned;
+    }
+  }
+  return null;
+}
+const PARTNER_LABELS = [
+  "wife",
+  "husband",
+  "spouse",
+  "partner",
+  "girlfriend",
+  "boyfriend",
+  "fiance",
+  "fianc\xE9e",
+  "fianc\xE9"
+];
+const PARTNER_CLAIM_PATTERNS = [
+  {
+    pattern: new RegExp(
+      `\\b([A-Z][A-Za-z'.-]{1,40}(?:\\s+[A-Z][A-Za-z'.-]{1,40}){0,2})\\s+is\\s+my\\s+(${PARTNER_LABELS.join("|")})\\b`,
+      "i"
+    ),
+    nameGroup: 1,
+    labelGroup: 2
+  },
+  {
+    pattern: new RegExp(
+      `\\bthis\\s+is\\s+([A-Z][A-Za-z'.-]{1,40}(?:\\s+[A-Z][A-Za-z'.-]{1,40}){0,2})\\s*,\\s*my\\s+(${PARTNER_LABELS.join("|")})\\b`,
+      "i"
+    ),
+    nameGroup: 1,
+    labelGroup: 2
+  }
+];
+function extractPartnerClaim(text) {
+  if (!text) return null;
+  for (const { pattern, nameGroup, labelGroup } of PARTNER_CLAIM_PATTERNS) {
+    const m = pattern.exec(text);
+    if (m?.[nameGroup] && m[labelGroup]) {
+      const name = m[nameGroup].replace(/[.,;:!?]+$/, "").trim();
+      const label = m[labelGroup].toLowerCase();
+      if (name.length > 0) {
+        return { name, label, type: "partner_of" };
+      }
+    }
+  }
+  return null;
+}
+class PendingRelationshipQueue {
+  pending = [];
+  enqueue(claim) {
+    this.pending = this.pending.filter(
+      (p) => p.toName.toLowerCase() !== claim.toName.toLowerCase() || p.type !== claim.type
+    );
+    this.pending.push(claim);
+  }
+  resolveByName(name) {
+    const lower = name.toLowerCase();
+    const resolved = this.pending.filter(
+      (p) => p.toName.toLowerCase() === lower
+    );
+    this.pending = this.pending.filter((p) => p.toName.toLowerCase() !== lower);
+    return resolved;
+  }
+  all() {
+    return this.pending;
+  }
+  size() {
+    return this.pending.length;
+  }
+}
+async function bindVoiceTurnToEntity(args) {
+  if (args.matchedEntityId) {
+    const resolved = args.pendingQueue.resolveByName(
+      (await args.entityStore.get(args.matchedEntityId))?.preferredName ?? ""
+    );
+    return {
+      entityId: args.matchedEntityId,
+      wasCreated: false,
+      resolvedClaimedName: null,
+      pendingRelationships: resolved
+    };
+  }
+  const claimedName = extractSelfNameClaim(args.utteranceText);
+  const result = await args.entityStore.observeIdentity({
+    platform: "voice",
+    handle: args.imprintClusterId,
+    ...claimedName ? { displayName: claimedName } : {},
+    evidence: args.evidenceIds,
+    confidence: claimedName ? Math.max(0.7, args.matchConfidence) : 0.5,
+    suggestedType: "person"
+  });
+  const pendingRelationships = claimedName ? args.pendingQueue.resolveByName(claimedName) : [];
+  return {
+    entityId: result.entity.entityId,
+    wasCreated: result.mergedFrom === void 0,
+    resolvedClaimedName: claimedName,
+    pendingRelationships
+  };
+}
+export {
+  PendingRelationshipQueue,
+  bindVoiceTurnToEntity,
+  extractPartnerClaim,
+  extractSelfNameClaim
+};
+//# sourceMappingURL=voice-attribution.js.map

package/dist/lifeops/entities/voice-attribution.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/entities/voice-attribution.ts"],"sourcesContent":["/**\n * Voice-attribution helpers: bind a voice-imprint observation to an\n * Entity (creating one if no match), extract name claims from\n * utterance text, and resolve pending relationships when a previously-\n * named partner finally speaks.\n *\n * Read R2-speaker.md §7 for the \"Jill scenario\" semantics that this\n * module exists to implement.\n */\n\nimport type { EntityStore } from \"./store.js\";\nimport type { SELF_ENTITY_ID } from \"./types.js\";\n\n/**\n * Regex-first extractor of a self-name claim in an utterance.\n *\n * Covers:\n *   - \"I'm Jill\"           / \"I am Jill\"\n *   - \"My name is Jill\"\n *   - \"This is Jill\"\n *   - \"Hey there, I'm Jill\"\n *   - \"Hi, it's Jill\"\n *\n * Returns the captured name (untrimmed of trailing punctuation by\n * design — let the caller normalize) or `null` when the regex misses.\n * The R2 spec calls for an LLM fallback when the regex misses; that\n * fallback is wired in `voice-observer.ts` so this module stays\n * dependency-free for unit testing.\n */\n// Trigger phrases (\"my name is\", \"i'm\", \"this is\", ...) match common ASR\n// casing variants explicitly. The captured name stays anchored on an uppercase\n// first letter to filter lowercased noise; JavaScript RegExp does not support\n// scoped flag groups such as `(?-i:...)`.\nconst NAME_PATTERN =\n  \"[A-Z][A-Za-z'.-]{1,40}(?:\\\\s+[A-Z][A-Za-z'.-]{1,40}){0,2}\";\nconst NAME_CLAIM_PATTERNS: RegExp[] = [\n  new RegExp(`\\\\b[Mm]y\\\\s+name\\\\s+is\\\\s+(${NAME_PATTERN})\\\\b`),\n  new RegExp(`\\\\b[Ii]\\\\s+am\\\\s+(${NAME_PATTERN})\\\\b`),\n  new RegExp(`\\\\b[Ii]['’]?m\\\\s+(${NAME_PATTERN})\\\\b`),\n  new RegExp(`\\\\b[Tt]his\\\\s+is\\\\s+(${NAME_PATTERN})\\\\b`),\n  new RegExp(`\\\\b[Ii]t['’]?s\\\\s+(${NAME_PATTERN})\\\\b`),\n];\n\nexport function extractSelfNameClaim(\n  text: string | null | undefined,\n): string | null {\n  if (!text) return null;\n  for (const pattern of NAME_CLAIM_PATTERNS) {\n    const m = pattern.exec(text);\n    if (m?.[1]) {\n      const cleaned = m[1].replace(/[.,;:!?]+$/, \"\").trim();\n      if (cleaned.length > 0) return cleaned;\n    }\n  }\n  return null;\n}\n\n/**\n * Extract a \"<owner> says <name> is my <label>\" assertion.\n *\n * Covers:\n *   - \"Jill is my wife\"            → {name:\"Jill\", label:\"wife\"}\n *   - \"this is Jill, my wife\"      → {name:\"Jill\", label:\"wife\"}\n *   - \"Bob is my husband\"          → {name:\"Bob\",  label:\"husband\"}\n *   - \"Sam is my partner\"\n *\n * Returns the first match; multi-relationship sentences are rare\n * enough to warrant punting until we have a real classifier.\n */\nconst PARTNER_LABELS = [\n  \"wife\",\n  \"husband\",\n  \"spouse\",\n  \"partner\",\n  \"girlfriend\",\n  \"boyfriend\",\n  \"fiance\",\n  \"fiancée\",\n  \"fiancé\",\n];\n\ninterface PartnerClaim {\n  name: string;\n  label: string;\n  type: \"partner_of\";\n}\n\nconst PARTNER_CLAIM_PATTERNS: ReadonlyArray<{\n  pattern: RegExp;\n  nameGroup: number;\n  labelGroup: number;\n}> = [\n  {\n    pattern: new RegExp(\n      `\\\\b([A-Z][A-Za-z'.-]{1,40}(?:\\\\s+[A-Z][A-Za-z'.-]{1,40}){0,2})\\\\s+is\\\\s+my\\\\s+(${PARTNER_LABELS.join(\"|\")})\\\\b`,\n      \"i\",\n    ),\n    nameGroup: 1,\n    labelGroup: 2,\n  },\n  {\n    pattern: new RegExp(\n      `\\\\bthis\\\\s+is\\\\s+([A-Z][A-Za-z'.-]{1,40}(?:\\\\s+[A-Z][A-Za-z'.-]{1,40}){0,2})\\\\s*,\\\\s*my\\\\s+(${PARTNER_LABELS.join(\"|\")})\\\\b`,\n      \"i\",\n    ),\n    nameGroup: 1,\n    labelGroup: 2,\n  },\n];\n\nexport function extractPartnerClaim(\n  text: string | null | undefined,\n): PartnerClaim | null {\n  if (!text) return null;\n  for (const { pattern, nameGroup, labelGroup } of PARTNER_CLAIM_PATTERNS) {\n    const m = pattern.exec(text);\n    if (m?.[nameGroup] && m[labelGroup]) {\n      const name = m[nameGroup].replace(/[.,;:!?]+$/, \"\").trim();\n      const label = m[labelGroup].toLowerCase();\n      if (name.length > 0) {\n        return { name, label, type: \"partner_of\" };\n      }\n    }\n  }\n  return null;\n}\n\nexport interface PendingRelationship {\n  type: \"partner_of\";\n  fromEntityId: typeof SELF_ENTITY_ID;\n  toName: string;\n  label: string;\n  evidenceId: string;\n  createdAt: string;\n}\n\n/**\n * In-memory pending-relationship queue. The \"Jill scenario\" needs\n * cross-utterance state: Shaw says \"this is Jill, Jill is my wife\"\n * **before** Jill ever speaks, so we can't resolve the relationship\n * until Jill is known. The queue lives in process memory; the engine\n * persists it (when needed) by writing the source utterance evidence\n * id into the relationship audit log on resolution.\n */\nexport class PendingRelationshipQueue {\n  private pending: PendingRelationship[] = [];\n\n  enqueue(claim: PendingRelationship): void {\n    // De-dupe by (toName, type) — the most recent claim wins.\n    this.pending = this.pending.filter(\n      (p) =>\n        p.toName.toLowerCase() !== claim.toName.toLowerCase() ||\n        p.type !== claim.type,\n    );\n    this.pending.push(claim);\n  }\n\n  resolveByName(name: string): PendingRelationship[] {\n    const lower = name.toLowerCase();\n    const resolved = this.pending.filter(\n      (p) => p.toName.toLowerCase() === lower,\n    );\n    this.pending = this.pending.filter((p) => p.toName.toLowerCase() !== lower);\n    return resolved;\n  }\n\n  all(): readonly PendingRelationship[] {\n    return this.pending;\n  }\n\n  size(): number {\n    return this.pending.length;\n  }\n}\n\n/**\n * Result of binding a voice-imprint observation to an Entity.\n */\nexport interface BindVoiceTurnResult {\n  entityId: string;\n  wasCreated: boolean;\n  resolvedClaimedName: string | null;\n  pendingRelationships: PendingRelationship[];\n}\n\n/**\n * Bind a voice-imprint observation to an Entity. If the imprint match\n * resolves to an existing entity, returns that entity's id. Otherwise\n * tries to extract a self-name claim from the utterance; either way,\n * runs through `EntityStore.observeIdentity` with `platform:\"voice\"`.\n *\n * Pending-relationship resolution is delegated to the caller — the\n * caller pulls `result.pendingRelationships` and applies them.\n */\nexport async function bindVoiceTurnToEntity(args: {\n  entityStore: EntityStore;\n  pendingQueue: PendingRelationshipQueue;\n  matchedEntityId: string | null;\n  utteranceText: string;\n  imprintClusterId: string;\n  evidenceIds: string[];\n  matchConfidence: number;\n}): Promise<BindVoiceTurnResult> {\n  if (args.matchedEntityId) {\n    const resolved = args.pendingQueue.resolveByName(\n      (await args.entityStore.get(args.matchedEntityId))?.preferredName ?? \"\",\n    );\n    return {\n      entityId: args.matchedEntityId,\n      wasCreated: false,\n      resolvedClaimedName: null,\n      pendingRelationships: resolved,\n    };\n  }\n  const claimedName = extractSelfNameClaim(args.utteranceText);\n  const result = await args.entityStore.observeIdentity({\n    platform: \"voice\",\n    handle: args.imprintClusterId,\n    ...(claimedName ? { displayName: claimedName } : {}),\n    evidence: args.evidenceIds,\n    confidence: claimedName ? Math.max(0.7, args.matchConfidence) : 0.5,\n    suggestedType: \"person\",\n  });\n\n  const pendingRelationships = claimedName\n    ? args.pendingQueue.resolveByName(claimedName)\n    : [];\n\n  return {\n    entityId: result.entity.entityId,\n    wasCreated: result.mergedFrom === undefined,\n    resolvedClaimedName: claimedName,\n    pendingRelationships,\n  };\n}\n"],"mappings":"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","names":[]}

package/dist/lifeops/entities/voice-observer-bridge.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Runtime bridge: connect the core `VOICE_TURN_OBSERVED` event to the
+ * LifeOps `VoiceObserver` (the merge-engine path), and emit
+ * `VOICE_ENTITY_BOUND` back so the voice-profile owner can persist the
+ * binding.
+ *
+ * This is the production wiring that was missing: `VoiceObserver` and
+ * the merge engine (`EntityStore.observeIdentity`) existed and were
+ * tested, but nothing drove them at runtime. A voice/speaker-ID plugin
+ * (plugin-local-inference) emits `VOICE_TURN_OBSERVED`; this handler
+ * folds the turn into the entity + relationship graph and round-trips
+ * the resulting entity id via `VOICE_ENTITY_BOUND`.
+ *
+ * No plugin imports the other: the only shared surface is the core
+ * event seam. If plugin-local-inference is absent the emit is a no-op;
+ * if plugin-lifeops is absent the observation simply has no consumer.
+ */
+import { type IAgentRuntime, type VoiceTurnObservedPayload } from "@elizaos/core";
+import { VoiceObserver } from "./voice-observer.js";
+/** Test seam: override how the per-runtime observer is built. */
+export type VoiceObserverFactory = (runtime: IAgentRuntime) => Promise<VoiceObserver>;
+export declare function setVoiceObserverFactory(factory: VoiceObserverFactory | null): void;
+/**
+ * Handler for {@link EventType.VOICE_TURN_OBSERVED}. Folds the turn into
+ * the merge engine, then emits {@link EventType.VOICE_ENTITY_BOUND}.
+ *
+ * Errors are contained at this boundary: a failed ingest must not crash
+ * the producer's voice pipeline. We log and return without round-tripping
+ * (the producer keeps its profile unbound and can retry on the next turn).
+ */
+export declare function handleVoiceTurnObserved(payload: VoiceTurnObservedPayload): Promise<void>;
+//# sourceMappingURL=voice-observer-bridge.d.ts.map

package/dist/lifeops/entities/voice-observer-bridge.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-observer-bridge.d.ts","sourceRoot":"","sources":["../../../src/lifeops/entities/voice-observer-bridge.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAEH,OAAO,EAEL,KAAK,aAAa,EAElB,KAAK,wBAAwB,EAC9B,MAAM,eAAe,CAAC;AAEvB,OAAO,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AASpD,iEAAiE;AACjE,MAAM,MAAM,oBAAoB,GAAG,CACjC,OAAO,EAAE,aAAa,KACnB,OAAO,CAAC,aAAa,CAAC,CAAC;AAI5B,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,oBAAoB,GAAG,IAAI,GACnC,IAAI,CAEN;AAmBD;;;;;;;GAOG;AACH,wBAAsB,uBAAuB,CAC3C,OAAO,EAAE,wBAAwB,GAChC,OAAO,CAAC,IAAI,CAAC,CAsCf"}

package/dist/lifeops/entities/voice-observer-bridge.js

@@ -0,0 +1,68 @@
+import {
+  EventType,
+  logger
+} from "@elizaos/core";
+import { LifeOpsRepository } from "../repository.js";
+import { VoiceObserver } from "./voice-observer.js";
+const observersByRuntime = /* @__PURE__ */ new WeakMap();
+let observerFactoryOverride = null;
+function setVoiceObserverFactory(factory) {
+  observerFactoryOverride = factory;
+}
+function resolveObserver(runtime) {
+  const cached = observersByRuntime.get(runtime);
+  if (cached) return cached;
+  const built = observerFactoryOverride ? observerFactoryOverride(runtime) : (async () => {
+    const repository = new LifeOpsRepository(runtime);
+    const [entityStore, relationshipStore] = await Promise.all([
+      repository.entityStore(runtime.agentId),
+      repository.relationshipStore(runtime.agentId)
+    ]);
+    return new VoiceObserver({ entityStore, relationshipStore });
+  })();
+  observersByRuntime.set(runtime, built);
+  return built;
+}
+async function handleVoiceTurnObserved(payload) {
+  const { runtime } = payload;
+  let entityId;
+  let wasCreated;
+  let displayName;
+  try {
+    const observer = await resolveObserver(runtime);
+    const result = await observer.ingestTurn({
+      turnId: payload.turnId,
+      text: payload.text,
+      imprintClusterId: payload.imprintClusterId,
+      matchConfidence: payload.matchConfidence,
+      matchedEntityId: payload.matchedEntityId,
+      ...payload.observedAt ? { observedAt: payload.observedAt } : {},
+      ...payload.isOwner !== void 0 ? { isOwner: payload.isOwner } : {}
+    });
+    entityId = result.binding.entityId;
+    wasCreated = result.binding.wasCreated;
+    displayName = result.binding.resolvedClaimedName ?? void 0;
+  } catch (err) {
+    logger.error(
+      {
+        err,
+        turnId: payload.turnId,
+        imprintClusterId: payload.imprintClusterId
+      },
+      "[lifeops] VOICE_TURN_OBSERVED ingest failed"
+    );
+    return;
+  }
+  await runtime.emitEvent(EventType.VOICE_ENTITY_BOUND, {
+    runtime,
+    imprintClusterId: payload.imprintClusterId,
+    entityId,
+    wasCreated,
+    ...displayName ? { displayName } : {}
+  });
+}
+export {
+  handleVoiceTurnObserved,
+  setVoiceObserverFactory
+};
+//# sourceMappingURL=voice-observer-bridge.js.map

package/dist/lifeops/entities/voice-observer-bridge.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/entities/voice-observer-bridge.ts"],"sourcesContent":["/**\n * Runtime bridge: connect the core `VOICE_TURN_OBSERVED` event to the\n * LifeOps `VoiceObserver` (the merge-engine path), and emit\n * `VOICE_ENTITY_BOUND` back so the voice-profile owner can persist the\n * binding.\n *\n * This is the production wiring that was missing: `VoiceObserver` and\n * the merge engine (`EntityStore.observeIdentity`) existed and were\n * tested, but nothing drove them at runtime. A voice/speaker-ID plugin\n * (plugin-local-inference) emits `VOICE_TURN_OBSERVED`; this handler\n * folds the turn into the entity + relationship graph and round-trips\n * the resulting entity id via `VOICE_ENTITY_BOUND`.\n *\n * No plugin imports the other: the only shared surface is the core\n * event seam. If plugin-local-inference is absent the emit is a no-op;\n * if plugin-lifeops is absent the observation simply has no consumer.\n */\n\nimport {\n  EventType,\n  type IAgentRuntime,\n  logger,\n  type VoiceTurnObservedPayload,\n} from \"@elizaos/core\";\nimport { LifeOpsRepository } from \"../repository.js\";\nimport { VoiceObserver } from \"./voice-observer.js\";\n\n/**\n * One `VoiceObserver` per runtime so its in-memory pending-relationship\n * queue (the \"Jill scenario\" cross-utterance state) survives across\n * turns. Keyed weakly so it's collected with the runtime.\n */\nconst observersByRuntime = new WeakMap<IAgentRuntime, Promise<VoiceObserver>>();\n\n/** Test seam: override how the per-runtime observer is built. */\nexport type VoiceObserverFactory = (\n  runtime: IAgentRuntime,\n) => Promise<VoiceObserver>;\n\nlet observerFactoryOverride: VoiceObserverFactory | null = null;\n\nexport function setVoiceObserverFactory(\n  factory: VoiceObserverFactory | null,\n): void {\n  observerFactoryOverride = factory;\n}\n\nfunction resolveObserver(runtime: IAgentRuntime): Promise<VoiceObserver> {\n  const cached = observersByRuntime.get(runtime);\n  if (cached) return cached;\n  const built = observerFactoryOverride\n    ? observerFactoryOverride(runtime)\n    : (async () => {\n        const repository = new LifeOpsRepository(runtime);\n        const [entityStore, relationshipStore] = await Promise.all([\n          repository.entityStore(runtime.agentId),\n          repository.relationshipStore(runtime.agentId),\n        ]);\n        return new VoiceObserver({ entityStore, relationshipStore });\n      })();\n  observersByRuntime.set(runtime, built);\n  return built;\n}\n\n/**\n * Handler for {@link EventType.VOICE_TURN_OBSERVED}. Folds the turn into\n * the merge engine, then emits {@link EventType.VOICE_ENTITY_BOUND}.\n *\n * Errors are contained at this boundary: a failed ingest must not crash\n * the producer's voice pipeline. We log and return without round-tripping\n * (the producer keeps its profile unbound and can retry on the next turn).\n */\nexport async function handleVoiceTurnObserved(\n  payload: VoiceTurnObservedPayload,\n): Promise<void> {\n  const { runtime } = payload;\n  let entityId: string;\n  let wasCreated: boolean;\n  let displayName: string | undefined;\n  try {\n    const observer = await resolveObserver(runtime);\n    const result = await observer.ingestTurn({\n      turnId: payload.turnId,\n      text: payload.text,\n      imprintClusterId: payload.imprintClusterId,\n      matchConfidence: payload.matchConfidence,\n      matchedEntityId: payload.matchedEntityId,\n      ...(payload.observedAt ? { observedAt: payload.observedAt } : {}),\n      ...(payload.isOwner !== undefined ? { isOwner: payload.isOwner } : {}),\n    });\n    entityId = result.binding.entityId;\n    wasCreated = result.binding.wasCreated;\n    displayName = result.binding.resolvedClaimedName ?? undefined;\n  } catch (err) {\n    logger.error(\n      {\n        err,\n        turnId: payload.turnId,\n        imprintClusterId: payload.imprintClusterId,\n      },\n      \"[lifeops] VOICE_TURN_OBSERVED ingest failed\",\n    );\n    return;\n  }\n\n  await runtime.emitEvent(EventType.VOICE_ENTITY_BOUND, {\n    runtime,\n    imprintClusterId: payload.imprintClusterId,\n    entityId,\n    wasCreated,\n    ...(displayName ? { displayName } : {}),\n  });\n}\n"],"mappings":"AAkBA;AAAA,EACE;AAAA,EAEA;AAAA,OAEK;AACP,SAAS,yBAAyB;AAClC,SAAS,qBAAqB;AAO9B,MAAM,qBAAqB,oBAAI,QAA+C;AAO9E,IAAI,0BAAuD;AAEpD,SAAS,wBACd,SACM;AACN,4BAA0B;AAC5B;AAEA,SAAS,gBAAgB,SAAgD;AACvE,QAAM,SAAS,mBAAmB,IAAI,OAAO;AAC7C,MAAI,OAAQ,QAAO;AACnB,QAAM,QAAQ,0BACV,wBAAwB,OAAO,KAC9B,YAAY;AACX,UAAM,aAAa,IAAI,kBAAkB,OAAO;AAChD,UAAM,CAAC,aAAa,iBAAiB,IAAI,MAAM,QAAQ,IAAI;AAAA,MACzD,WAAW,YAAY,QAAQ,OAAO;AAAA,MACtC,WAAW,kBAAkB,QAAQ,OAAO;AAAA,IAC9C,CAAC;AACD,WAAO,IAAI,cAAc,EAAE,aAAa,kBAAkB,CAAC;AAAA,EAC7D,GAAG;AACP,qBAAmB,IAAI,SAAS,KAAK;AACrC,SAAO;AACT;AAUA,eAAsB,wBACpB,SACe;AACf,QAAM,EAAE,QAAQ,IAAI;AACpB,MAAI;AACJ,MAAI;AACJ,MAAI;AACJ,MAAI;AACF,UAAM,WAAW,MAAM,gBAAgB,OAAO;AAC9C,UAAM,SAAS,MAAM,SAAS,WAAW;AAAA,MACvC,QAAQ,QAAQ;AAAA,MAChB,MAAM,QAAQ;AAAA,MACd,kBAAkB,QAAQ;AAAA,MAC1B,iBAAiB,QAAQ;AAAA,MACzB,iBAAiB,QAAQ;AAAA,MACzB,GAAI,QAAQ,aAAa,EAAE,YAAY,QAAQ,WAAW,IAAI,CAAC;AAAA,MAC/D,GAAI,QAAQ,YAAY,SAAY,EAAE,SAAS,QAAQ,QAAQ,IAAI,CAAC;AAAA,IACtE,CAAC;AACD,eAAW,OAAO,QAAQ;AAC1B,iBAAa,OAAO,QAAQ;AAC5B,kBAAc,OAAO,QAAQ,uBAAuB;AAAA,EACtD,SAAS,KAAK;AACZ,WAAO;AAAA,MACL;AAAA,QACE;AAAA,QACA,QAAQ,QAAQ;AAAA,QAChB,kBAAkB,QAAQ;AAAA,MAC5B;AAAA,MACA;AAAA,IACF;AACA;AAAA,EACF;AAEA,QAAM,QAAQ,UAAU,UAAU,oBAAoB;AAAA,IACpD;AAAA,IACA,kBAAkB,QAAQ;AAAA,IAC1B;AAAA,IACA;AAAA,IACA,GAAI,cAAc,EAAE,YAAY,IAAI,CAAC;AAAA,EACvC,CAAC;AACH;","names":[]}

package/dist/lifeops/entities/voice-observer.d.ts

@@ -0,0 +1,72 @@
+/**
+ * High-level voice-attribution observer that wires a voice turn into
+ * the LifeOps entity + relationship graph.
+ *
+ * Implements the R2-speaker.md §7.3 "Jill scenario" semantics:
+ *   - Match-or-create an Entity from the imprint cluster.
+ *   - On a self-name claim ("I'm Jill" / "hey there, I'm Jill"), use
+ *     that name as the entity's preferredName via observeIdentity.
+ *   - On an owner-relationship claim ("Jill is my wife"), queue a
+ *     pending `partner_of` row that resolves the first time Jill is
+ *     observed via voice and her name is known.
+ *
+ * The observer is intentionally stateful — the pending-relationship
+ * queue lives on the instance. The engine constructs one observer per
+ * runtime; tests construct one per scenario.
+ */
+import type { RelationshipStore } from "../relationships/store.js";
+import type { EntityStore } from "./store.js";
+import { type BindVoiceTurnResult, PendingRelationshipQueue } from "./voice-attribution.js";
+export interface VoiceObserverDeps {
+    entityStore: EntityStore;
+    relationshipStore: RelationshipStore;
+}
+/** One ingested voice turn. */
+export interface VoiceTurnObservation {
+    /** Stable utterance id (transcriber turn id is fine). */
+    turnId: string;
+    /** Recognized text. */
+    text: string;
+    /** Imprint cluster id from the voice profile store. */
+    imprintClusterId: string;
+    /** Confidence of the imprint match (0..1). */
+    matchConfidence: number;
+    /** Matched entity if the imprint had a binding, else null. */
+    matchedEntityId: string | null;
+    /** When the turn was observed. */
+    observedAt?: string;
+    /** True if this turn was spoken by the OWNER. */
+    isOwner?: boolean;
+}
+export interface VoiceTurnIngestResult {
+    binding: BindVoiceTurnResult;
+    /** Relationship rows produced for this turn (resolved or new). */
+    relationshipIds: string[];
+    /** Partner claims queued for later resolution (typically when isOwner=true). */
+    queuedPartnerClaims: number;
+}
+/**
+ * `VoiceObserver` — single instance per runtime. Holds the pending
+ * relationships queue across utterances.
+ */
+export declare class VoiceObserver {
+    private readonly deps;
+    private readonly pendingQueue;
+    constructor(deps: VoiceObserverDeps);
+    get pendingRelationshipsCount(): number;
+    /**
+     * Ingest one voice turn. Side effects:
+     *   - `EntityStore.observeIdentity({ platform:"voice", ... })` may
+     *     create or merge an entity row.
+     *   - When the speaker is the OWNER and the utterance contains an
+     *     ownership-relationship claim ("X is my wife"), the queue is
+     *     bumped — the row lands later, when X first speaks.
+     *   - When the speaker is *not* the OWNER and their self-name claim
+     *     matches a previously-queued partner claim, the pending
+     *     relationship is realized via `RelationshipStore.observe`.
+     */
+    ingestTurn(turn: VoiceTurnObservation): Promise<VoiceTurnIngestResult>;
+    /** Test utility: peek at the pending queue. */
+    peekPending(): ReturnType<PendingRelationshipQueue["all"]>;
+}
+//# sourceMappingURL=voice-observer.d.ts.map

package/dist/lifeops/entities/voice-observer.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"voice-observer.d.ts","sourceRoot":"","sources":["../../../src/lifeops/entities/voice-observer.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,KAAK,EAAE,iBAAiB,EAAE,MAAM,2BAA2B,CAAC;AACnE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAC;AAE9C,OAAO,EACL,KAAK,mBAAmB,EAGxB,wBAAwB,EACzB,MAAM,wBAAwB,CAAC;AAEhC,MAAM,WAAW,iBAAiB;IAChC,WAAW,EAAE,WAAW,CAAC;IACzB,iBAAiB,EAAE,iBAAiB,CAAC;CACtC;AAED,+BAA+B;AAC/B,MAAM,WAAW,oBAAoB;IACnC,yDAAyD;IACzD,MAAM,EAAE,MAAM,CAAC;IACf,uBAAuB;IACvB,IAAI,EAAE,MAAM,CAAC;IACb,uDAAuD;IACvD,gBAAgB,EAAE,MAAM,CAAC;IACzB,8CAA8C;IAC9C,eAAe,EAAE,MAAM,CAAC;IACxB,8DAA8D;IAC9D,eAAe,EAAE,MAAM,GAAG,IAAI,CAAC;IAC/B,kCAAkC;IAClC,UAAU,CAAC,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,mBAAmB,CAAC;IAC7B,kEAAkE;IAClE,eAAe,EAAE,MAAM,EAAE,CAAC;IAC1B,gFAAgF;IAChF,mBAAmB,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,qBAAa,aAAa;IAGZ,OAAO,CAAC,QAAQ,CAAC,IAAI;IAFjC,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAkC;gBAElC,IAAI,EAAE,iBAAiB;IAEpD,IAAI,yBAAyB,IAAI,MAAM,CAEtC;IAED;;;;;;;;;;OAUG;IACG,UAAU,CAAC,IAAI,EAAE,oBAAoB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IA4E5E,+CAA+C;IAC/C,WAAW,IAAI,UAAU,CAAC,wBAAwB,CAAC,KAAK,CAAC,CAAC;CAG3D"}

package/dist/lifeops/entities/voice-observer.js

@@ -0,0 +1,97 @@
+import { SELF_ENTITY_ID } from "./types.js";
+import {
+  bindVoiceTurnToEntity,
+  extractPartnerClaim,
+  PendingRelationshipQueue
+} from "./voice-attribution.js";
+class VoiceObserver {
+  constructor(deps) {
+    this.deps = deps;
+  }
+  deps;
+  pendingQueue = new PendingRelationshipQueue();
+  get pendingRelationshipsCount() {
+    return this.pendingQueue.size();
+  }
+  /**
+   * Ingest one voice turn. Side effects:
+   *   - `EntityStore.observeIdentity({ platform:"voice", ... })` may
+   *     create or merge an entity row.
+   *   - When the speaker is the OWNER and the utterance contains an
+   *     ownership-relationship claim ("X is my wife"), the queue is
+   *     bumped — the row lands later, when X first speaks.
+   *   - When the speaker is *not* the OWNER and their self-name claim
+   *     matches a previously-queued partner claim, the pending
+   *     relationship is realized via `RelationshipStore.observe`.
+   */
+  async ingestTurn(turn) {
+    const binding = await bindVoiceTurnToEntity({
+      entityStore: this.deps.entityStore,
+      pendingQueue: this.pendingQueue,
+      matchedEntityId: turn.matchedEntityId,
+      utteranceText: turn.text,
+      imprintClusterId: turn.imprintClusterId,
+      evidenceIds: [turn.turnId],
+      matchConfidence: turn.matchConfidence
+    });
+    const relationshipIds = [];
+    for (const pending of binding.pendingRelationships) {
+      const rel = await this.deps.relationshipStore.observe({
+        fromEntityId: pending.fromEntityId,
+        toEntityId: binding.entityId,
+        type: pending.type,
+        metadataPatch: { label: pending.label },
+        evidence: [pending.evidenceId, turn.turnId],
+        confidence: 0.7,
+        source: "extraction",
+        occurredAt: turn.observedAt
+      });
+      relationshipIds.push(rel.relationshipId);
+    }
+    let queuedPartnerClaims = 0;
+    if (turn.isOwner) {
+      const claim = extractPartnerClaim(turn.text);
+      if (claim) {
+        const candidates = await this.deps.entityStore.resolve({
+          name: claim.name,
+          type: "person"
+        });
+        const exact = candidates.find(
+          (c) => c.entity.preferredName.toLowerCase() === claim.name.toLowerCase() && c.entity.entityId !== SELF_ENTITY_ID
+        );
+        if (exact) {
+          const rel = await this.deps.relationshipStore.observe({
+            fromEntityId: SELF_ENTITY_ID,
+            toEntityId: exact.entity.entityId,
+            type: "partner_of",
+            metadataPatch: { label: claim.label },
+            evidence: [turn.turnId],
+            confidence: 0.7,
+            source: "extraction",
+            occurredAt: turn.observedAt
+          });
+          relationshipIds.push(rel.relationshipId);
+        } else {
+          this.pendingQueue.enqueue({
+            type: "partner_of",
+            fromEntityId: SELF_ENTITY_ID,
+            toName: claim.name,
+            label: claim.label,
+            evidenceId: turn.turnId,
+            createdAt: turn.observedAt ?? (/* @__PURE__ */ new Date()).toISOString()
+          });
+          queuedPartnerClaims += 1;
+        }
+      }
+    }
+    return { binding, relationshipIds, queuedPartnerClaims };
+  }
+  /** Test utility: peek at the pending queue. */
+  peekPending() {
+    return this.pendingQueue.all();
+  }
+}
+export {
+  VoiceObserver
+};
+//# sourceMappingURL=voice-observer.js.map

package/dist/lifeops/entities/voice-observer.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../src/lifeops/entities/voice-observer.ts"],"sourcesContent":["/**\n * High-level voice-attribution observer that wires a voice turn into\n * the LifeOps entity + relationship graph.\n *\n * Implements the R2-speaker.md §7.3 \"Jill scenario\" semantics:\n *   - Match-or-create an Entity from the imprint cluster.\n *   - On a self-name claim (\"I'm Jill\" / \"hey there, I'm Jill\"), use\n *     that name as the entity's preferredName via observeIdentity.\n *   - On an owner-relationship claim (\"Jill is my wife\"), queue a\n *     pending `partner_of` row that resolves the first time Jill is\n *     observed via voice and her name is known.\n *\n * The observer is intentionally stateful — the pending-relationship\n * queue lives on the instance. The engine constructs one observer per\n * runtime; tests construct one per scenario.\n */\n\nimport type { RelationshipStore } from \"../relationships/store.js\";\nimport type { EntityStore } from \"./store.js\";\nimport { SELF_ENTITY_ID } from \"./types.js\";\nimport {\n  type BindVoiceTurnResult,\n  bindVoiceTurnToEntity,\n  extractPartnerClaim,\n  PendingRelationshipQueue,\n} from \"./voice-attribution.js\";\n\nexport interface VoiceObserverDeps {\n  entityStore: EntityStore;\n  relationshipStore: RelationshipStore;\n}\n\n/** One ingested voice turn. */\nexport interface VoiceTurnObservation {\n  /** Stable utterance id (transcriber turn id is fine). */\n  turnId: string;\n  /** Recognized text. */\n  text: string;\n  /** Imprint cluster id from the voice profile store. */\n  imprintClusterId: string;\n  /** Confidence of the imprint match (0..1). */\n  matchConfidence: number;\n  /** Matched entity if the imprint had a binding, else null. */\n  matchedEntityId: string | null;\n  /** When the turn was observed. */\n  observedAt?: string;\n  /** True if this turn was spoken by the OWNER. */\n  isOwner?: boolean;\n}\n\nexport interface VoiceTurnIngestResult {\n  binding: BindVoiceTurnResult;\n  /** Relationship rows produced for this turn (resolved or new). */\n  relationshipIds: string[];\n  /** Partner claims queued for later resolution (typically when isOwner=true). */\n  queuedPartnerClaims: number;\n}\n\n/**\n * `VoiceObserver` — single instance per runtime. Holds the pending\n * relationships queue across utterances.\n */\nexport class VoiceObserver {\n  private readonly pendingQueue = new PendingRelationshipQueue();\n\n  constructor(private readonly deps: VoiceObserverDeps) {}\n\n  get pendingRelationshipsCount(): number {\n    return this.pendingQueue.size();\n  }\n\n  /**\n   * Ingest one voice turn. Side effects:\n   *   - `EntityStore.observeIdentity({ platform:\"voice\", ... })` may\n   *     create or merge an entity row.\n   *   - When the speaker is the OWNER and the utterance contains an\n   *     ownership-relationship claim (\"X is my wife\"), the queue is\n   *     bumped — the row lands later, when X first speaks.\n   *   - When the speaker is *not* the OWNER and their self-name claim\n   *     matches a previously-queued partner claim, the pending\n   *     relationship is realized via `RelationshipStore.observe`.\n   */\n  async ingestTurn(turn: VoiceTurnObservation): Promise<VoiceTurnIngestResult> {\n    // Step 1: bind the imprint to an entity (create or match).\n    const binding = await bindVoiceTurnToEntity({\n      entityStore: this.deps.entityStore,\n      pendingQueue: this.pendingQueue,\n      matchedEntityId: turn.matchedEntityId,\n      utteranceText: turn.text,\n      imprintClusterId: turn.imprintClusterId,\n      evidenceIds: [turn.turnId],\n      matchConfidence: turn.matchConfidence,\n    });\n\n    // Step 2: realize any pending relationships the binding resolved.\n    const relationshipIds: string[] = [];\n    for (const pending of binding.pendingRelationships) {\n      const rel = await this.deps.relationshipStore.observe({\n        fromEntityId: pending.fromEntityId,\n        toEntityId: binding.entityId,\n        type: pending.type,\n        metadataPatch: { label: pending.label },\n        evidence: [pending.evidenceId, turn.turnId],\n        confidence: 0.7,\n        source: \"extraction\",\n        occurredAt: turn.observedAt,\n      });\n      relationshipIds.push(rel.relationshipId);\n    }\n\n    // Step 3: if the OWNER speaks an ownership-relationship claim,\n    // queue it for later resolution. We don't resolve it on the\n    // owner's turn because we don't yet know which entity the named\n    // person is.\n    let queuedPartnerClaims = 0;\n    if (turn.isOwner) {\n      const claim = extractPartnerClaim(turn.text);\n      if (claim) {\n        // Try eager resolution — the owner might be referring to a\n        // person we've already heard speak (named via self-claim).\n        const candidates = await this.deps.entityStore.resolve({\n          name: claim.name,\n          type: \"person\",\n        });\n        const exact = candidates.find(\n          (c) =>\n            c.entity.preferredName.toLowerCase() === claim.name.toLowerCase() &&\n            c.entity.entityId !== SELF_ENTITY_ID,\n        );\n        if (exact) {\n          const rel = await this.deps.relationshipStore.observe({\n            fromEntityId: SELF_ENTITY_ID,\n            toEntityId: exact.entity.entityId,\n            type: \"partner_of\",\n            metadataPatch: { label: claim.label },\n            evidence: [turn.turnId],\n            confidence: 0.7,\n            source: \"extraction\",\n            occurredAt: turn.observedAt,\n          });\n          relationshipIds.push(rel.relationshipId);\n        } else {\n          this.pendingQueue.enqueue({\n            type: \"partner_of\",\n            fromEntityId: SELF_ENTITY_ID,\n            toName: claim.name,\n            label: claim.label,\n            evidenceId: turn.turnId,\n            createdAt: turn.observedAt ?? new Date().toISOString(),\n          });\n          queuedPartnerClaims += 1;\n        }\n      }\n    }\n\n    return { binding, relationshipIds, queuedPartnerClaims };\n  }\n\n  /** Test utility: peek at the pending queue. */\n  peekPending(): ReturnType<PendingRelationshipQueue[\"all\"]> {\n    return this.pendingQueue.all();\n  }\n}\n"],"mappings":"AAmBA,SAAS,sBAAsB;AAC/B;AAAA,EAEE;AAAA,EACA;AAAA,EACA;AAAA,OACK;AAqCA,MAAM,cAAc;AAAA,EAGzB,YAA6B,MAAyB;AAAzB;AAAA,EAA0B;AAAA,EAA1B;AAAA,EAFZ,eAAe,IAAI,yBAAyB;AAAA,EAI7D,IAAI,4BAAoC;AACtC,WAAO,KAAK,aAAa,KAAK;AAAA,EAChC;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EAaA,MAAM,WAAW,MAA4D;AAE3E,UAAM,UAAU,MAAM,sBAAsB;AAAA,MAC1C,aAAa,KAAK,KAAK;AAAA,MACvB,cAAc,KAAK;AAAA,MACnB,iBAAiB,KAAK;AAAA,MACtB,eAAe,KAAK;AAAA,MACpB,kBAAkB,KAAK;AAAA,MACvB,aAAa,CAAC,KAAK,MAAM;AAAA,MACzB,iBAAiB,KAAK;AAAA,IACxB,CAAC;AAGD,UAAM,kBAA4B,CAAC;AACnC,eAAW,WAAW,QAAQ,sBAAsB;AAClD,YAAM,MAAM,MAAM,KAAK,KAAK,kBAAkB,QAAQ;AAAA,QACpD,cAAc,QAAQ;AAAA,QACtB,YAAY,QAAQ;AAAA,QACpB,MAAM,QAAQ;AAAA,QACd,eAAe,EAAE,OAAO,QAAQ,MAAM;AAAA,QACtC,UAAU,CAAC,QAAQ,YAAY,KAAK,MAAM;AAAA,QAC1C,YAAY;AAAA,QACZ,QAAQ;AAAA,QACR,YAAY,KAAK;AAAA,MACnB,CAAC;AACD,sBAAgB,KAAK,IAAI,cAAc;AAAA,IACzC;AAMA,QAAI,sBAAsB;AAC1B,QAAI,KAAK,SAAS;AAChB,YAAM,QAAQ,oBAAoB,KAAK,IAAI;AAC3C,UAAI,OAAO;AAGT,cAAM,aAAa,MAAM,KAAK,KAAK,YAAY,QAAQ;AAAA,UACrD,MAAM,MAAM;AAAA,UACZ,MAAM;AAAA,QACR,CAAC;AACD,cAAM,QAAQ,WAAW;AAAA,UACvB,CAAC,MACC,EAAE,OAAO,cAAc,YAAY,MAAM,MAAM,KAAK,YAAY,KAChE,EAAE,OAAO,aAAa;AAAA,QAC1B;AACA,YAAI,OAAO;AACT,gBAAM,MAAM,MAAM,KAAK,KAAK,kBAAkB,QAAQ;AAAA,YACpD,cAAc;AAAA,YACd,YAAY,MAAM,OAAO;AAAA,YACzB,MAAM;AAAA,YACN,eAAe,EAAE,OAAO,MAAM,MAAM;AAAA,YACpC,UAAU,CAAC,KAAK,MAAM;AAAA,YACtB,YAAY;AAAA,YACZ,QAAQ;AAAA,YACR,YAAY,KAAK;AAAA,UACnB,CAAC;AACD,0BAAgB,KAAK,IAAI,cAAc;AAAA,QACzC,OAAO;AACL,eAAK,aAAa,QAAQ;AAAA,YACxB,MAAM;AAAA,YACN,cAAc;AAAA,YACd,QAAQ,MAAM;AAAA,YACd,OAAO,MAAM;AAAA,YACb,YAAY,KAAK;AAAA,YACjB,WAAW,KAAK,eAAc,oBAAI,KAAK,GAAE,YAAY;AAAA,UACvD,CAAC;AACD,iCAAuB;AAAA,QACzB;AAAA,MACF;AAAA,IACF;AAEA,WAAO,EAAE,SAAS,iBAAiB,oBAAoB;AAAA,EACzD;AAAA;AAAA,EAGA,cAA2D;AACzD,WAAO,KAAK,aAAa,IAAI;AAAA,EAC/B;AACF;","names":[]}