@hraness/peopleblade 0.2.2 → 0.3.0

package/README.md

@@ -15,7 +15,7 @@ Installation includes the pinned runtime dependencies Zod 4.4.3 and Effect 3.22.
 ## Install
 
 ```bash
-bun add --global @hraness/peopleblade@0.2.2
+bun add --global @hraness/peopleblade@0.3.0
 peopleblade --version
 peopleblade init
 peopleblade stats --json
@@ -40,19 +40,20 @@ token remains available.
 ### Optional Ghostget-backed sources
 
 The package does not install Ghostget, browser automation, KB, native model runtimes,
-or provider credentials. Beeper, Google, and WhatsApp live sync commands delegate
-through a separately reviewed `ghostget` executable on `PATH` (or the absolute
-`PEOPLEBLADE_GHOSTGET_EXECUTABLE` path). PeopleBlade bundles only the pinned Ghostget
-0.17.1 client validators needed to fence requests and receipts; it does not bundle
-or silently download Ghostget's execution runtime.
+or provider credentials. Beeper, Google, and WhatsApp live sync commands and the
+LinkedIn Contact-info read delegate through a separately reviewed `ghostget`
+executable on `PATH` (or the absolute `PEOPLEBLADE_GHOSTGET_EXECUTABLE` path).
+PeopleBlade bundles only the pinned Ghostget 0.17.3 client validators needed to
+fence requests and receipts; it does not bundle or silently download Ghostget's
+execution runtime.
 
 `PEOPLEBLADE_WRENCH_EXECUTABLE` remains a compatibility alias for the explicit
 path. When both variables are set, they must name the same executable. The
-bridge still requires exact Ghostget 0.17.1 before invoking a provider operation.
+bridge still requires exact Ghostget 0.17.3 before invoking a provider operation.
 
-PeopleBlade 0.2.2 contains the reviewed Ghostget-backed Beeper, Google, and WhatsApp
+PeopleBlade 0.3.0 contains the reviewed Ghostget-backed Beeper, Google, and WhatsApp
 live sync commands. Running them requires the separately installed public
-`@hraness/ghostget` 0.17.1 package. Beeper support is bounded to account-aware
+`@hraness/ghostget` 0.17.3 package. Beeper support is bounded to account-aware
 `contacts.list@3` reads, `contacts.search@1`, `messaging.search@2`, and the separate
 body-free interaction exporter. `contacts.search@1` executes the official Beeper
 CLI 0.6.2 executable pinned by Ghostget; `contacts.list@3` and `messaging.search@2`
@@ -62,13 +63,41 @@ only. See
 [peopleblade.com/sources](https://peopleblade.com/sources) for the complete provider
 guide. A database previously synced by PeopleBlade 0.1.1 through Wrench 0.16.7
 must run `peopleblade beeper rebind --auth beeper-main --confirm --json` once after
-installing Ghostget 0.17.1. The command appends reviewed metadata for the same source
+installing Ghostget 0.17.3. The command appends reviewed metadata for the same source
 identity only after both complete account inventories match. Do not force-bind
 Ghostget unless its authenticated Desktop target changed. PeopleBlade calls no
 Beeper interface directly and exposes none of Ghostget's Beeper send or action
 operations. Archive imports, Apple Contacts, iMessage, notes, identity review,
 backups, and optional PeopleBlade cloud commands do not require Ghostget.
 
+### LinkedIn Contact info through Ghostget
+
+```bash
+peopleblade linkedin contact-info --person-id ID [--account KEY] [--auth ID]
+```
+
+`linkedin contact-info` reads the Contact info panel (email, phone numbers,
+websites, birthday, and connected-since date) of one first-degree LinkedIn
+connection that `linkedin import` already imported from the official LinkedIn
+data export. The command records the read as exact, provider-attributed evidence
+for that person; repeating an identical read changes nothing.
+
+The read runs through Ghostget, Wrench's renamed successor, published as the
+`@hraness/ghostget` package. The package does not install Ghostget. The command
+delegates to a separately installed `ghostget` executable on `PATH` (or the
+absolute `PEOPLEBLADE_GHOSTGET_EXECUTABLE` path) and refuses any executable
+that does not report exactly version 0.17.3. It needs a Ghostget path-backed
+auth binding for a signed-in LinkedIn browser profile; the default binding id
+is `linkedin-main`, and `--auth ID` selects another. Beeper, Google, and
+WhatsApp delegate through the same `ghostget` executable.
+
+Each command reads one bounded profile. It never lists connections, reads
+messages or feeds, or sends invitations, and it fails without writing anything
+when the profile belongs to the account owner or is not a first-degree
+connection. PeopleBlade bundles only the pinned Ghostget 0.17.3 client
+validators that fence the request and receipt; it does not bundle or download
+Ghostget's execution runtime or browser automation.
+
 ## Browse and edit locally
 
 ```bash

package/THIRD_PARTY_NOTICES.md

@@ -1,8 +1,8 @@
 # Third-party notices
 
 The PeopleBlade CLI bundle includes reviewed client-boundary code from
-`@hraness/ghostget` 0.17.1 (commit
-`b74ae2ac594bcf07c3def71dc4bb2e5a98c826dd`) and message-bundle contract code
+`@hraness/ghostget` 0.17.3 (commit
+`67b53cc1917bb09a48b22042cc988c3afbc0aaf8`) and message-bundle contract code
 from `@hraness/message-like-me` 0.7.0. Those portions are provided under the
 following license. The PeopleBlade CLI package has its own MIT grant in
 `LICENSE`; this notice preserves the attribution for the bundled portions.

package/dist/cli.ts

@@ -3,7 +3,7 @@
 import { accessSync, constants, realpathSync } from "node:fs";
 import { isAbsolute, resolve } from "node:path";
 
-const reviewedGhostgetVersion = "0.17.1";
+const reviewedGhostgetVersion = "0.17.3";
 const canonicalConfigured = process.env.PEOPLEBLADE_GHOSTGET_EXECUTABLE;
 const legacyConfigured = process.env.PEOPLEBLADE_WRENCH_EXECUTABLE;
 if (

package/dist/peopleblade.js

@@ -4313,9 +4313,9 @@ var peoplebladeCapabilities = Object.freeze({
     { id: "apple-contacts", command: "contacts sync", status: "supported", transport: "local-database", requirement: "macOS Contacts access" },
     { id: "imessage", command: "imessage sync", status: "supported", transport: "local-metadata", requirement: "macOS Messages access; no message bodies" },
     { id: "google-contacts", command: "google sync", status: "supported", transport: "ghostget", requirement: "Reviewed Gmail/People contacts.list and contact scopes" },
-    { id: "beeper", command: "beeper sync", status: "supported", transport: "ghostget", requirement: "Ghostget 0.17.1, Beeper adapter 2.4.0, CLI 0.6.2; body-free relationships require macOS arm64" },
+    { id: "beeper", command: "beeper sync", status: "supported", transport: "ghostget", requirement: "Ghostget 0.17.3, Beeper adapter 2.4.0, CLI 0.6.2; body-free relationships require macOS arm64" },
     { id: "whatsapp", command: "whatsapp sync", status: "supported", transport: "ghostget", requirement: "Reviewed linked-device contacts.list v2" },
-    { id: "linkedin", command: "linkedin import", status: "supported", transport: "official-archive", requirement: "Owner-selected official ZIP; no authenticated browser collection" },
+    { id: "linkedin", command: "linkedin import", status: "supported", transport: "official-archive", requirement: "Owner-selected official ZIP; connection lists are not collected from a signed-in browser" },
     { id: "instagram", command: "instagram import", status: "supported", transport: "official-archive", requirement: "Owner-selected JSON ZIP and exact owner username" },
     { id: "x-archive", command: "x import", status: "bounded", transport: "official-archive", requirement: "Owner-selected ZIP; unresolved IDs remain inert" },
     { id: "x-live", command: "x mutuals sync", status: "blocked", transport: "unavailable", requirement: "A reviewed bounded Ghostget mutuals capability is not yet available" },
@@ -4323,9 +4323,10 @@ var peoplebladeCapabilities = Object.freeze({
   ],
   enrichment: [
     { id: "local-anchors", priority: 1, status: "supported", commands: ["identity audit", "identity suggest", "identity decide"], paid: false, boundary: "Exact source evidence first; joins require reversible evidence-bound decisions" },
-    { id: "manual-public-research", priority: 2, status: "supported", commands: ["research prepare", "research apply"], paid: false, boundary: "Agent or human supplies cited public evidence; PeopleBlade performs no provider calls" },
-    { id: "cloud-professional-research", priority: 3, status: "optional", commands: ["cloud enrich --person-id ID", "cloud enrich --confirm TOKEN"], paid: true, boundary: "Exa exact profiles or bounded search, then cited model extraction; device-bound preview approval required" },
-    { id: "cloud-email-fallback", priority: 4, status: "optional", commands: ["cloud enrich --person-id ID"], paid: true, boundary: "Hunter is a separately configured narrow fallback, not a substitute for identity evidence" }
+    { id: "linkedin-contact-info", priority: 2, status: "supported", commands: ["linkedin contact-info --person-id ID"], paid: false, boundary: "Reviewed Ghostget linkedin-web contacts.read for one exact first-degree connection already imported from the official export; signed-in browser profile, one bounded read, no connect, message, or feed access" },
+    { id: "manual-public-research", priority: 3, status: "supported", commands: ["research prepare", "research apply"], paid: false, boundary: "Agent or human supplies cited public evidence; PeopleBlade performs no provider calls" },
+    { id: "cloud-professional-research", priority: 4, status: "optional", commands: ["cloud enrich --person-id ID", "cloud enrich --confirm TOKEN"], paid: true, boundary: "Exa exact profiles or bounded search, then cited model extraction; device-bound preview approval required" },
+    { id: "cloud-email-fallback", priority: 5, status: "optional", commands: ["cloud enrich --person-id ID"], paid: true, boundary: "Hunter is a separately configured narrow fallback, not a substitute for identity evidence" }
   ],
   interfaces: {
     workspace: { command: "ui [--port N]", availability: "included-in-this-build", binding: "127.0.0.1", defaultPort: "random", authentication: "per-process capability file", remoteAssets: false, noteUpload: false },
@@ -13697,8 +13698,8 @@ function invokeCapabilitySync(request, options = {}) {
   return parsed.live;
 }
 
-// node_modules/@hraness/ghostget/dist/index-471pfpgn.js
-var GHOSTGET_VERSION = "0.17.1";
+// node_modules/@hraness/ghostget/dist/index-rxvsqb3f.js
+var GHOSTGET_VERSION = "0.17.3";
 
 // node_modules/@hraness/ghostget/dist/beeper-client.js
 import { spawnSync as spawnSync2 } from "child_process";
@@ -18683,8 +18684,8 @@ function projectBeeperContactInteractions(summary2, coordinates) {
 // src/local/providers/beeper-compatibility.ts
 var BEEPER_GHOSTGET_COMPATIBILITY = Object.freeze({
   ghostget: Object.freeze({
-    version: "0.17.1",
-    commit: "b74ae2ac594bcf07c3def71dc4bb2e5a98c826dd"
+    version: "0.17.3",
+    commit: "67b53cc1917bb09a48b22042cc988c3afbc0aaf8"
   }),
   adapter: Object.freeze({
     id: "beeper-local",
@@ -18721,6 +18722,22 @@ var BEEPER_GHOSTGET_COMPATIBILITY = Object.freeze({
     commit: "b9c1714410139c2139b597338cd002d785653e85"
   })
 });
+var PREVIOUS_GHOSTGET_0171_BEEPER_SOURCE_BINDING_METADATA = Object.freeze({
+  transport: "local-cli",
+  wrenchVersion: "0.17.1",
+  wrenchCommit: "b74ae2ac594bcf07c3def71dc4bb2e5a98c826dd",
+  adapterId: "beeper-local",
+  adapterVersion: "2.4.0",
+  adapterSha256: "2714af7e821b799c1d0b57106e8e193cb9787e5a6da37e1269f4aae0710a4ddc",
+  cliId: "beeper-cli",
+  cliVersion: "0.6.2",
+  cliCommit: "a416af06023449a87312dc11e54643fd9dc94b8c",
+  contracts: Object.freeze({
+    contactsList: "8048565547c2a09078528d0a35f7a0c3a2e8850b17b075dc572e8b59115fcb57",
+    contactsSearch: "e57cdcc9012ed5fb8f956e16a2368e95adf0a6b8bb404f903e64df85061b1ca1",
+    messagingSearch: "2fc54d139a54d19c31a82237e4b417994e12679db3da5fd71ec9265e3622b0bf"
+  })
+});
 var PREVIOUS_WRENCH_0168_BEEPER_SOURCE_BINDING_METADATA = Object.freeze({
   transport: "local-cli",
   wrenchVersion: "0.16.8",
@@ -19292,8 +19309,11 @@ function classifyReviewedBeeperPredecessor(value, currentMetadata) {
   if (encoded === canonicalJson(PREVIOUS_WRENCH_0168_BEEPER_SOURCE_BINDING_METADATA)) {
     return "wrench-0.16.8-beeper-2.4";
   }
-  if (encoded === currentMetadata)
+  if (encoded === canonicalJson(PREVIOUS_GHOSTGET_0171_BEEPER_SOURCE_BINDING_METADATA)) {
     return "ghostget-0.17.1-beeper-2.4";
+  }
+  if (encoded === currentMetadata)
+    return "ghostget-0.17.3-beeper-2.4";
   return null;
 }
 function assertStoredRealmInventory(database, sourceBindingId, accounts, storedSha256) {
@@ -19372,7 +19392,7 @@ function rebindBeeperSource(database, options = {}) {
   if (predecessor === null) {
     throw new Error("Beeper rebind source coordinates are not a reviewed predecessor.");
   }
-  const metadataOnly = sameIdentity && (predecessor === "peopleblade-0.1.0-wrench-0.15-beeper-2.0" || predecessor === "wrench-0.16.7-beeper-2.4" || predecessor === "wrench-0.16.8-beeper-2.4");
+  const metadataOnly = sameIdentity && (predecessor === "peopleblade-0.1.0-wrench-0.15-beeper-2.0" || predecessor === "wrench-0.16.7-beeper-2.4" || predecessor === "wrench-0.16.8-beeper-2.4" || predecessor === "ghostget-0.17.1-beeper-2.4");
   if (sameIdentity && !metadataOnly) {
     throw new Error("Beeper metadata-only rebind requires an exact reviewed same-identity predecessor.");
   }
@@ -24589,6 +24609,9 @@ function linkedInAccountKey(value) {
   }
   return key;
 }
+function canonicalLinkedInProfileUrl(value, label) {
+  return profileUrl(value, label);
+}
 function ownerProfile(messages, supplied) {
   const explicit = supplied === undefined ? null : profileUrl(supplied, "LinkedIn archive owner profile URL");
   if (supplied !== undefined && explicit === null)
@@ -24993,6 +25016,342 @@ function linkedInStatsAll(database) {
     WHERE account.provider='linkedin' ORDER BY account.account_key`, MODE7).map((row) => ({ ...row, remote_set_complete: false }));
 }
 
+// src/local/providers/linkedin-contact-info.ts
+var LINKEDIN_CONTACT_INFO_ADAPTER_ID = "linkedin-web";
+var LINKEDIN_CONTACT_INFO_OPERATION_ID = "contacts.read";
+var LINKEDIN_CONTACT_INFO_ADAPTER_VERSION = "1.23.0";
+var LINKEDIN_CONTACT_INFO_CONTRACT_SHA256 = "8f80c234ca2b7706a49a5000012a11da78a36d38f3023c21854a240e16a13f43";
+var DEFAULT_LINKEDIN_AUTH = "linkedin-main";
+var PROVIDER11 = "linkedin";
+var MODE8 = "ghostget-contact-info";
+var RECORD_KIND = "contact-info";
+var OBSERVATION_BASIS2 = "linkedin-contact-info";
+var OBSERVATION_PRIORITY2 = 720;
+var MAX_PHONES = 8;
+var MAX_WEBSITES = 8;
+var EMAIL5 = /^(?=[\x21-\x7E]+$)[^@\s]+@[^@\s]+\.[^@\s]+$/u;
+var PHONE = /^\+?[0-9][0-9 .\-()]{6,30}[0-9]$/u;
+var VIEWER_SUBJECT = /^urn:li:fsd_profile:[0-9]{1,32}$/u;
+var PROFILE_URN = /^urn:li:fsd_profile:[A-Za-z0-9_-]{1,256}$/u;
+var VANITY = /^[A-Za-z0-9%._-]{1,1024}$/u;
+var DATE = /^[0-9]{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])$/u;
+var BIRTHDAY = /^(?:[0-9]{4}-)?(?:0[1-9]|1[0-2])-(?:0[1-9]|[12][0-9]|3[01])$/u;
+var AUTH_ID3 = /^[a-z0-9][a-z0-9._:-]{0,255}$/u;
+function getRow9(database, sql, ...bindings) {
+  return database.query(sql).get(...bindings);
+}
+function allRows7(database, sql, ...bindings) {
+  return database.query(sql).all(...bindings);
+}
+function run8(database, sql, ...bindings) {
+  return database.run(sql, bindings);
+}
+function insertedId9(value) {
+  return Number(value.lastInsertRowid);
+}
+function record6(value, label) {
+  if (value === null || typeof value !== "object" || Array.isArray(value))
+    throw new Error(`${label} must be an object`);
+  return value;
+}
+function exact4(value, keys, label) {
+  const actual = Object.keys(value).sort();
+  const expected = [...keys].sort();
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new Error(`${label} changed its reviewed shape`);
+  }
+}
+function text6(value, label, maximum) {
+  if (typeof value !== "string")
+    throw new Error(`${label} must be a string`);
+  const normalized = value.normalize("NFC");
+  if (normalized.length < 1 || Buffer.byteLength(normalized, "utf8") > maximum || /[\u0000-\u001F\u007F-\u009F]/u.test(normalized))
+    throw new Error(`${label} is invalid`);
+  return normalized;
+}
+function optionalText3(value, label, maximum) {
+  return value === null ? null : text6(value, label, maximum);
+}
+function timestamp6(value, label) {
+  const parsed = text6(value, label, 64);
+  const milliseconds2 = Date.parse(parsed);
+  if (!Number.isFinite(milliseconds2) || new Date(milliseconds2).toISOString() !== parsed) {
+    throw new Error(`${label} must be a canonical UTC timestamp`);
+  }
+  return parsed;
+}
+function boundedList(value, label, maximum) {
+  if (!Array.isArray(value) || value.length > maximum)
+    throw new Error(`${label} exceeded its reviewed bound`);
+  const items = value.map((item, index) => text6(item, `${label}[${index}]`, 2048));
+  if (new Set(items).size !== items.length)
+    throw new Error(`${label} contains duplicates`);
+  return items;
+}
+function website(value, label) {
+  let parsed;
+  try {
+    parsed = new URL(value);
+  } catch (error) {
+    throw new Error(`${label} is not an absolute URL`, { cause: error });
+  }
+  if (parsed.protocol !== "https:" && parsed.protocol !== "http:" || parsed.username !== "" || parsed.password !== "")
+    throw new Error(`${label} must be a plain web URL`);
+  return parsed.href;
+}
+function normalizedWebsite(value) {
+  const parsed = new URL(value);
+  parsed.hash = "";
+  const path = parsed.pathname.length > 1 && parsed.pathname.endsWith("/") ? parsed.pathname.slice(0, -1) : parsed.pathname;
+  return `${parsed.protocol}//${parsed.host.toLowerCase()}${path}${parsed.search}`;
+}
+function normalizedEmail3(value, label) {
+  if (!EMAIL5.test(value) || Buffer.byteLength(value, "utf8") > 320)
+    throw new Error(`${label} is not an email address`);
+  return value.toLowerCase();
+}
+function parseFields(value, label) {
+  const parsed = record6(value, label);
+  exact4(parsed, ["email", "profileUrl", "connectedSince", "phones", "websites", "birthday"], label);
+  const email2 = optionalText3(parsed.email, `${label}.email`, 320);
+  if (email2 !== null)
+    normalizedEmail3(email2, `${label}.email`);
+  const profileUrl2 = optionalText3(parsed.profileUrl, `${label}.profileUrl`, 4096);
+  if (profileUrl2 !== null && canonicalLinkedInProfileUrl(profileUrl2, `${label}.profileUrl`) === null) {
+    throw new Error(`${label}.profileUrl is invalid`);
+  }
+  const connectedSince = optionalText3(parsed.connectedSince, `${label}.connectedSince`, 10);
+  if (connectedSince !== null && !DATE.test(connectedSince))
+    throw new Error(`${label}.connectedSince is invalid`);
+  const phones = boundedList(parsed.phones, `${label}.phones`, MAX_PHONES);
+  for (const [index, phone] of phones.entries()) {
+    if (!PHONE.test(phone))
+      throw new Error(`${label}.phones[${index}] is invalid`);
+  }
+  const websites = boundedList(parsed.websites, `${label}.websites`, MAX_WEBSITES).map((item, index) => website(item, `${label}.websites[${index}]`));
+  const birthday2 = optionalText3(parsed.birthday, `${label}.birthday`, 10);
+  if (birthday2 !== null && !BIRTHDAY.test(birthday2))
+    throw new Error(`${label}.birthday is invalid`);
+  return Object.freeze({ email: email2, profileUrl: profileUrl2, connectedSince, phones, websites, birthday: birthday2 });
+}
+function projectLinkedInContactInfo(value, expectedProfileUrl) {
+  const output = record6(value, "Ghostget LinkedIn contact output");
+  exact4(output, ["schemaVersion", "provider", "profile", "viewer", "observedAt", "completeness", "contact"], "contact output");
+  if (output.schemaVersion !== 1 || output.provider !== PROVIDER11)
+    throw new Error("Ghostget LinkedIn contact semantics drifted");
+  const profile = record6(output.profile, "contact output.profile");
+  exact4(profile, ["vanity", "profileUrn", "url", "relationship"], "contact output.profile");
+  const vanity = text6(profile.vanity, "contact output.profile.vanity", 1024);
+  if (!VANITY.test(vanity))
+    throw new Error("Ghostget LinkedIn profile vanity is invalid");
+  const profileUrn = text6(profile.profileUrn, "contact output.profile.profileUrn", 300);
+  if (!PROFILE_URN.test(profileUrn))
+    throw new Error("Ghostget LinkedIn profile URN is invalid");
+  const url = canonicalLinkedInProfileUrl(text6(profile.url, "contact output.profile.url", 4096), "contact output.profile.url");
+  if (url === null || url !== expectedProfileUrl) {
+    throw new Error("Ghostget LinkedIn contact output does not bind the requested profile");
+  }
+  if (profile.relationship !== "first-degree")
+    throw new Error("Ghostget LinkedIn contact output is not a first-degree read");
+  const viewer = record6(output.viewer, "contact output.viewer");
+  exact4(viewer, ["subject"], "contact output.viewer");
+  const viewerSubject = text6(viewer.subject, "contact output.viewer.subject", 64);
+  if (!VIEWER_SUBJECT.test(viewerSubject))
+    throw new Error("Ghostget LinkedIn viewer subject is invalid");
+  const observedAt = timestamp6(output.observedAt, "contact output.observedAt");
+  if (output.completeness !== "complete" && output.completeness !== "partial") {
+    throw new Error("Ghostget LinkedIn contact completeness is invalid");
+  }
+  const contact = parseFields(output.contact, "contact output.contact");
+  const hasAny = contact.email !== null || contact.connectedSince !== null || contact.phones.length > 0 || contact.websites.length > 0 || contact.birthday !== null;
+  if (hasAny !== (output.completeness === "complete")) {
+    throw new Error("Ghostget LinkedIn contact completeness disagrees with its fields");
+  }
+  return Object.freeze({
+    profileUrl: url,
+    vanity,
+    profileUrn,
+    relationship: "first-degree",
+    viewerSubject,
+    observedAt,
+    completeness: output.completeness,
+    contact
+  });
+}
+function authId2(value) {
+  const parsed = (value ?? DEFAULT_LINKEDIN_AUTH).trim();
+  if (!AUTH_ID3.test(parsed))
+    throw new Error("Ghostget auth ID is invalid");
+  return parsed;
+}
+function envelope(value, input, auth) {
+  return validatePeopleBladeGhostgetInvocation(value, {
+    adapterId: LINKEDIN_CONTACT_INFO_ADAPTER_ID,
+    operationId: LINKEDIN_CONTACT_INFO_OPERATION_ID,
+    authId: auth,
+    input
+  }, {
+    adapterVersion: LINKEDIN_CONTACT_INFO_ADAPTER_VERSION,
+    authKind: "browser-profile",
+    transport: "web-session-api",
+    contractSha256: LINKEDIN_CONTACT_INFO_CONTRACT_SHA256,
+    finalOrigin: "https://www.linkedin.com"
+  });
+}
+function storedResultFromJson(value) {
+  const parsed = record6(JSON.parse(value), "stored LinkedIn contact-info result");
+  exact4(parsed, [
+    "account_key",
+    "person_id",
+    "provider_resource_id",
+    "profile_url",
+    "vanity",
+    "observed_at",
+    "completeness",
+    "connected_since",
+    "email_recorded",
+    "phones_recorded",
+    "phones_unresolved",
+    "websites_recorded",
+    "birthday_recorded"
+  ], "stored LinkedIn contact-info result");
+  return parsed;
+}
+function metadata3(value) {
+  return record6(JSON.parse(value), "LinkedIn resource metadata");
+}
+function readLinkedInContactInfo(database, options) {
+  const account = linkedInAccountKey(options.accountKey);
+  const auth = authId2(options.authId);
+  if (!Number.isSafeInteger(options.personId) || options.personId < 1)
+    throw new Error("person ID is invalid");
+  const resources = allRows7(database, `SELECT id,person_id,profile_url,resource_id,metadata_json FROM provider_resources
+     WHERE provider=? AND account_key=? AND resource_type='profile' AND active=1 AND person_id=?
+     ORDER BY id`, PROVIDER11, account, options.personId);
+  if (resources.length === 0) {
+    throw new Error("This person has no active LinkedIn profile in that account; import the official LinkedIn export first");
+  }
+  if (resources.length > 1) {
+    throw new Error("This person has more than one active LinkedIn profile in that account; review its identity decisions first");
+  }
+  const resource = resources[0];
+  const profileUrl2 = canonicalLinkedInProfileUrl(resource.profile_url ?? resource.resource_id, "stored LinkedIn profile URL");
+  if (profileUrl2 === null)
+    throw new Error("stored LinkedIn profile resource lacks an exact profile URL");
+  const owner = getRow9(database, "SELECT owner_key FROM archive_accounts WHERE provider=? AND account_key=?", PROVIDER11, account);
+  if (owner !== null && owner.owner_key === profileUrl2) {
+    throw new Error("Contact info is read for connections, not the account owner's own profile");
+  }
+  const input = Object.freeze({ profile_url: profileUrl2 });
+  const invocation = callPeopleBladeGhostget({
+    adapterId: LINKEDIN_CONTACT_INFO_ADAPTER_ID,
+    operationId: LINKEDIN_CONTACT_INFO_OPERATION_ID,
+    authId: auth,
+    input
+  }, options.invoke);
+  const parsed = envelope(invocation, input, auth);
+  const projection2 = projectLinkedInContactInfo(parsed.output, profileUrl2);
+  const sourceSha256 = sha256(canonicalJson(projection2));
+  const execution = parsed.execution;
+  const personId = resource.person_id;
+  const resourceId = resource.id;
+  const resolvedPhones = projection2.contact.phones.map((phone) => ({ phone, normalized: resolvePhoneIdentity(phone, null) }));
+  const stored = {
+    account_key: account,
+    person_id: personId,
+    provider_resource_id: resourceId,
+    profile_url: profileUrl2,
+    vanity: projection2.vanity,
+    observed_at: projection2.observedAt,
+    completeness: projection2.completeness,
+    connected_since: projection2.contact.connectedSince,
+    email_recorded: projection2.contact.email !== null,
+    phones_recorded: resolvedPhones.filter((entry) => entry.normalized !== null).length,
+    phones_unresolved: resolvedPhones.filter((entry) => entry.normalized === null).length,
+    websites_recorded: projection2.contact.websites.length,
+    birthday_recorded: projection2.contact.birthday !== null
+  };
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const cached = getRow9(database, "SELECT id,result_json FROM source_runs WHERE provider=? AND account_key=? AND mode=? AND source_sha256=?", PROVIDER11, account, MODE8, sourceSha256);
+    if (cached !== null) {
+      database.exec("COMMIT");
+      return { ...storedResultFromJson(cached.result_json), run_id: cached.id, replayed: true };
+    }
+    const runId = insertedId9(run8(database, `INSERT INTO source_runs(
+      provider,account_key,mode,source_sha256,source_locator_sha256,completeness,result_json,started_at,completed_at
+    ) VALUES (?,?,?,?,?,?,?,?,?)`, PROVIDER11, account, MODE8, sourceSha256, sha256(profileUrl2), projection2.completeness, canonicalJson(stored), execution.startedAt, execution.finishedAt));
+    const methodLabel = `${OBSERVATION_BASIS2}:${sha256(profileUrl2).slice(0, 16)}`;
+    const methodMetadata = canonicalJson({ observedIn: OBSERVATION_BASIS2, observedAt: projection2.observedAt });
+    run8(database, "UPDATE contact_methods SET active=0 WHERE provider_resource_id=? AND label=?", resourceId, methodLabel);
+    if (projection2.contact.email !== null) {
+      run8(database, `INSERT INTO contact_methods(
+        person_id,kind,value,normalized_value,label,confidence,first_seen_run_id,last_seen_run_id,
+        metadata_json,provider_resource_id,active,identity_eligible
+      ) VALUES (?,'email',?,?,?,'exact',?,?,?,?,1,1)
+      ON CONFLICT(person_id,kind,normalized_value,label) DO UPDATE SET
+        value=excluded.value,last_seen_run_id=excluded.last_seen_run_id,metadata_json=excluded.metadata_json,
+        provider_resource_id=excluded.provider_resource_id,active=1,identity_eligible=1`, personId, projection2.contact.email, normalizedEmail3(projection2.contact.email, "contact email"), methodLabel, runId, runId, methodMetadata, resourceId);
+    }
+    for (const { phone, normalized } of resolvedPhones) {
+      if (normalized === null)
+        continue;
+      run8(database, `INSERT INTO contact_methods(
+        person_id,kind,value,normalized_value,label,confidence,first_seen_run_id,last_seen_run_id,
+        metadata_json,provider_resource_id,active,identity_eligible
+      ) VALUES (?,'phone',?,?,?,'exact',?,?,?,?,1,1)
+      ON CONFLICT(person_id,kind,normalized_value,label) DO UPDATE SET
+        value=excluded.value,last_seen_run_id=excluded.last_seen_run_id,metadata_json=excluded.metadata_json,
+        provider_resource_id=excluded.provider_resource_id,active=1,identity_eligible=1`, personId, phone, normalized, methodLabel, runId, runId, methodMetadata, resourceId);
+    }
+    for (const site of projection2.contact.websites) {
+      run8(database, `INSERT INTO contact_methods(
+        person_id,kind,value,normalized_value,label,confidence,first_seen_run_id,last_seen_run_id,
+        metadata_json,provider_resource_id,active,identity_eligible
+      ) VALUES (?,'url',?,?,?,'exact',?,?,?,?,1,0)
+      ON CONFLICT(person_id,kind,normalized_value,label) DO UPDATE SET
+        value=excluded.value,last_seen_run_id=excluded.last_seen_run_id,metadata_json=excluded.metadata_json,
+        provider_resource_id=excluded.provider_resource_id,active=1,identity_eligible=0`, personId, site, normalizedWebsite(site), methodLabel, runId, runId, methodMetadata, resourceId);
+    }
+    run8(database, "UPDATE person_field_observations SET active=0 WHERE provider_resource_id=? AND basis=?", resourceId, OBSERVATION_BASIS2);
+    if (projection2.contact.birthday !== null) {
+      run8(database, `INSERT INTO person_field_observations(
+        provider_resource_id,field,value,basis,priority,active,first_seen_run_id,last_seen_run_id,metadata_json
+      ) VALUES (?,'birthday',?,?,?,1,?,?,'{}')
+      ON CONFLICT(provider_resource_id,field,value,basis) DO UPDATE SET
+        priority=excluded.priority,active=1,last_seen_run_id=excluded.last_seen_run_id`, resourceId, projection2.contact.birthday, OBSERVATION_BASIS2, OBSERVATION_PRIORITY2, runId, runId);
+      run8(database, "UPDATE people SET birthday=coalesce(birthday,?) WHERE id=?", projection2.contact.birthday, personId);
+    }
+    const resourceMetadata = {
+      ...metadata3(resource.metadata_json),
+      linkedInContactInfo: {
+        observedAt: projection2.observedAt,
+        completeness: projection2.completeness,
+        connectedSince: projection2.contact.connectedSince,
+        viewerSubject: projection2.viewerSubject,
+        runId
+      }
+    };
+    run8(database, "UPDATE provider_resources SET last_seen_run_id=?,metadata_json=? WHERE id=?", runId, canonicalJson(resourceMetadata), resourceId);
+    run8(database, `INSERT INTO source_records(
+      run_id,ordinal,record_kind,record_sha256,person_id,provider_resource_id,resolution,projection_json,error_text
+    ) VALUES (?,1,?,?,?,?,'matched',?,NULL)`, runId, RECORD_KIND, sourceSha256, personId, resourceId, canonicalJson(projection2));
+    ledgerPeopleBladeGhostgetInvocation(database, {
+      provider: PROVIDER11,
+      accountKey: account,
+      capability: "contact_info",
+      execution,
+      costBasis: "local-browser-read",
+      metadata: { profileUrlSha256: sha256(profileUrl2), completeness: projection2.completeness }
+    });
+    database.exec("COMMIT");
+    return { ...stored, run_id: runId, replayed: false };
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+
 // src/local/providers/whatsapp.ts
 import { createHash as createHash9 } from "crypto";
 var CONTACTS_CONTRACT_SHA2562 = "0bd3c994f16608d5886f1192dd58d41736e4bd01add66a5a3e029efca8b14a38";
@@ -25013,18 +25372,18 @@ var DEVICE_LID_JID = /^([0-9]{5,32}):[0-9]{1,5}@lid$/u;
 var GROUP_JID = /^[0-9]{5,32}(?:-[0-9]{5,20})?@g\.us$/u;
 var OTHER_JID = /^(?:0@s\.whatsapp\.net|[0-9]{5,32}@newsletter|(?:status|[0-9]{5,32})@broadcast)$/u;
 var MESSAGE_ID = /^[A-Za-z0-9._~:-]{1,256}$/u;
-var PROVIDER11 = "whatsapp";
+var PROVIDER12 = "whatsapp";
 var STREAM2 = "messages";
-function getRow9(database, sql, ...values) {
+function getRow10(database, sql, ...values) {
   return database.query(sql).get(...values);
 }
-function run8(database, sql, ...values) {
+function run9(database, sql, ...values) {
   return database.run(sql, values);
 }
-function insertedId9(value) {
+function insertedId10(value) {
   return Number(value.lastInsertRowid);
 }
-function record6(value, label) {
+function record7(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
     throw new Error(`${label} must be a plain object`);
   }
@@ -25036,14 +25395,14 @@ function record6(value, label) {
     throw new Error(`${label} has symbol keys`);
   return value;
 }
-function exact4(value, keys, label) {
+function exact5(value, keys, label) {
   const actual = Object.keys(value).sort();
   const expected = [...keys].sort();
   if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
     throw new Error(`${label} contains unsupported or missing fields`);
   }
 }
-function text6(value, label, maximum = 4096, empty = false) {
+function text7(value, label, maximum = 4096, empty = false) {
   if (typeof value !== "string" || !empty && value.length === 0 || Buffer.byteLength(value, "utf8") > maximum || /[\u0000\r]/u.test(value)) {
     throw new Error(`${label} must be bounded text`);
   }
@@ -25060,7 +25419,7 @@ function bool3(value, label) {
   return value;
 }
 function digest5(value, label) {
-  const parsed = text6(value, label, 64);
+  const parsed = text7(value, label, 64);
   if (!SHA2563.test(parsed))
     throw new Error(`${label} is invalid`);
   return parsed;
@@ -25078,11 +25437,11 @@ function stableJson6(value) {
   }
   if (Array.isArray(value))
     return `[${value.map(stableJson6).join(",")}]`;
-  const parsed = record6(value, "canonical JSON");
+  const parsed = record7(value, "canonical JSON");
   return `{${Object.keys(parsed).sort().map((key) => `${JSON.stringify(key)}:${stableJson6(parsed[key])}`).join(",")}}`;
 }
-function timestamp6(value, label) {
-  const parsed = text6(value, label, 40);
+function timestamp7(value, label) {
+  const parsed = text7(value, label, 40);
   if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/u.test(parsed))
     throw new Error(`${label} is invalid`);
   const milliseconds2 = Date.parse(parsed);
@@ -25091,25 +25450,25 @@ function timestamp6(value, label) {
   return new Date(milliseconds2).toISOString();
 }
 function decimal(value, label) {
-  const parsed = text6(value, label, 19);
+  const parsed = text7(value, label, 19);
   if (!DECIMAL.test(parsed) || BigInt(parsed) > BigInt("9223372036854775807"))
     throw new Error(`${label} is invalid`);
   return parsed;
 }
-function authId2(value) {
-  const parsed = text6(value, "WhatsApp auth ID", 48);
+function authId3(value) {
+  const parsed = text7(value, "WhatsApp auth ID", 48);
   if (!/^[a-z][a-z0-9-]{0,47}$/u.test(parsed))
     throw new Error("WhatsApp auth ID is invalid");
   return parsed;
 }
 function subject(value) {
-  const parsed = text6(value, "WhatsApp account subject", 64);
+  const parsed = text7(value, "WhatsApp account subject", 64);
   if (!SUBJECT2.test(parsed))
     throw new Error("WhatsApp account subject is invalid");
   return parsed;
 }
 function canonicalJid(value, label, device = false) {
-  const parsed = text6(value, label, 96);
+  const parsed = text7(value, label, 96);
   const user = USER_JID.exec(parsed) ?? (device ? DEVICE_USER_JID.exec(parsed) : null);
   if (user?.[1] !== undefined)
     return { jid: `${user[1]}@s.whatsapp.net`, kind: "user" };
@@ -25131,7 +25490,7 @@ function directJid(value, label) {
 function ownerJid(accountSubject) {
   return accountSubject.startsWith("whatsapp:pn:") ? `${accountSubject.slice(12)}@s.whatsapp.net` : `${accountSubject.slice(13)}@lid`;
 }
-function envelope(value, input, auth) {
+function envelope2(value, input, auth) {
   const parsed = validatePeopleBladeGhostgetInvocation(value, {
     adapterId: "whatsapp-web",
     operationId: "contacts.list",
@@ -25144,25 +25503,25 @@ function envelope(value, input, auth) {
     contractSha256: CONTACTS_CONTRACT_SHA2562,
     finalOrigin: "https://web.whatsapp.com"
   });
-  return { output: record6(parsed.output, "Ghostget output"), execution: parsed.execution };
+  return { output: record7(parsed.output, "Ghostget output"), execution: parsed.execution };
 }
 var CONTACT_KEYS = ["providerId", "jidKind", "phone", "redactedPhone", "firstName", "fullName", "pushName", "businessName", "displayName", "displayNameBasis", "alias", "tags", "updatedAt", "localProjectionStatsComplete", "sentCount", "sentCountComplete", "sentCountLowerBound", "sentCountTruncated", "receivedCount", "receivedCountComplete", "receivedCountLowerBound", "receivedCountTruncated", "lastSentAt", "lastSentAtComplete", "lastSentAtBasis", "sentStatsIncompleteReasons", "lastReceivedAt", "lastReceivedAtComplete", "lastReceivedAtBasis", "receivedStatsIncompleteReasons"];
 function parseContact4(value, label) {
-  const parsed = record6(value, label);
-  exact4(parsed, CONTACT_KEYS, label);
+  const parsed = record7(value, label);
+  exact5(parsed, CONTACT_KEYS, label);
   const identity = directJid(parsed.providerId, `${label}.providerId`);
   if (parsed.jidKind !== identity.kind)
     throw new Error(`${label}.jidKind drifted`);
-  const phone = parsed.phone === null ? null : text6(parsed.phone, `${label}.phone`, 20);
+  const phone = parsed.phone === null ? null : text7(parsed.phone, `${label}.phone`, 20);
   if (phone !== (USER_JID.exec(identity.jid)?.[1] ?? null))
     throw new Error(`${label}.phone drifted`);
-  const displayName2 = parsed.displayName === null ? null : text6(parsed.displayName, `${label}.displayName`, 512);
+  const displayName2 = parsed.displayName === null ? null : text7(parsed.displayName, `${label}.displayName`, 512);
   const bases = ["full-name", "push-name", "business-name", "first-name", "redacted-phone", "phone", "unavailable"];
   if (!bases.includes(parsed.displayNameBasis))
     throw new Error(`${label}.displayNameBasis is invalid`);
   for (const key of ["redactedPhone", "firstName", "fullName", "pushName", "businessName"])
     if (parsed[key] !== null)
-      text6(parsed[key], `${label}.${key}`, 512);
+      text7(parsed[key], `${label}.${key}`, 512);
   if (parsed.alias !== null || parsed.updatedAt !== null || !Array.isArray(parsed.tags) || parsed.tags.length !== 0 || parsed.localProjectionStatsComplete !== false || parsed.sentCount !== null || parsed.sentCountComplete !== false || parsed.sentCountLowerBound !== false || parsed.sentCountTruncated !== false || parsed.receivedCount !== null || parsed.receivedCountComplete !== false || parsed.receivedCountLowerBound !== false || parsed.receivedCountTruncated !== false || parsed.lastSentAt !== null || parsed.lastSentAtComplete !== false || parsed.lastSentAtBasis !== "unavailable" || parsed.lastReceivedAt !== null || parsed.lastReceivedAtComplete !== false || parsed.lastReceivedAtBasis !== "unavailable" || stableJson6(parsed.sentStatsIncompleteReasons) !== stableJson6(["whatsapp-message-store-account-owner-unavailable"]) || stableJson6(parsed.receivedStatsIncompleteReasons) !== stableJson6(["whatsapp-message-store-account-owner-unavailable"])) {
     throw new Error(`${label} changed bounded contact semantics`);
   }
@@ -25175,9 +25534,9 @@ function parseContact4(value, label) {
   };
 }
 function parseContactPage(value, input, auth) {
-  const parsed = envelope(value, input, auth);
+  const parsed = envelope2(value, input, auth);
   const output = parsed.output;
-  exact4(output, ["provider", "operation", "accountSubject", "projection", "contacts", "nextCursor", "localContactTablePageComplete", "remoteContactSetComplete", "contactSetIncompleteReasons", "statsScope", "statsCompleteness"], "contact output");
+  exact5(output, ["provider", "operation", "accountSubject", "projection", "contacts", "nextCursor", "localContactTablePageComplete", "remoteContactSetComplete", "contactSetIncompleteReasons", "statsScope", "statsCompleteness"], "contact output");
   if (output.provider !== "whatsapp" || output.operation !== "contacts.list" || output.projection !== "quiescent-account-bound-session-store" || output.remoteContactSetComplete !== false || output.statsScope !== "unavailable" || output.statsCompleteness !== "unavailable" || stableJson6(output.contactSetIncompleteReasons) !== stableJson6(["linked-device-contact-sync-coverage-unknown"]) || input.collection !== "contacts") {
     throw new Error("Ghostget contact semantics drifted");
   }
@@ -25202,10 +25561,10 @@ function parseContactPage(value, input, auth) {
   return { input, accountSubject, contacts, nextCursor, localPageComplete: complete, safeOutputSha256, execution: parsed.execution };
 }
 function generation(value) {
-  const parsed = record6(value, "projection generation");
-  exact4(parsed, ["messageStoreIdentity", "schemaFingerprint"], "projection generation");
-  const identity = record6(parsed.messageStoreIdentity, "message-store identity");
-  exact4(identity, ["dev", "ino"], "message-store identity");
+  const parsed = record7(value, "projection generation");
+  exact5(parsed, ["messageStoreIdentity", "schemaFingerprint"], "projection generation");
+  const identity = record7(parsed.messageStoreIdentity, "message-store identity");
+  exact5(identity, ["dev", "ino"], "message-store identity");
   const dev = decimal(identity.dev, "message-store dev");
   const ino = decimal(identity.ino, "message-store ino");
   if (ino === "0" || parsed.schemaFingerprint !== PROJECTION_SCHEMA_FINGERPRINT)
@@ -25213,8 +25572,8 @@ function generation(value) {
   return { messageStoreIdentity: { dev, ino }, schemaFingerprint: PROJECTION_SCHEMA_FINGERPRINT };
 }
 function checkpoint(value, label) {
-  const parsed = record6(value, label);
-  exact4(parsed, ["cursor", "anchor"], label);
+  const parsed = record7(value, label);
+  exact5(parsed, ["cursor", "anchor"], label);
   const cursor = decimal(parsed.cursor, `${label}.cursor`);
   const anchor = parsed.anchor === null ? null : digest5(parsed.anchor, `${label}.anchor`);
   if (cursor === "0" !== (anchor === null))
@@ -25222,14 +25581,14 @@ function checkpoint(value, label) {
   return { cursor, anchor };
 }
 function parseInteraction(value, label) {
-  const parsed = record6(value, label);
-  exact4(parsed, ["rowid", "chatJid", "messageId", "senderJid", "timestamp", "fromMe", "chatKind"], label);
+  const parsed = record7(value, label);
+  exact5(parsed, ["rowid", "chatJid", "messageId", "senderJid", "timestamp", "fromMe", "chatKind"], label);
   const rowid = decimal(parsed.rowid, `${label}.rowid`);
   if (rowid === "0")
     throw new Error(`${label}.rowid is invalid`);
   const chat = canonicalJid(parsed.chatJid, `${label}.chatJid`);
   const sender = parsed.senderJid === null ? null : canonicalJid(parsed.senderJid, `${label}.senderJid`, true).jid;
-  const messageId = text6(parsed.messageId, `${label}.messageId`, 256);
+  const messageId = text7(parsed.messageId, `${label}.messageId`, 256);
   if (!MESSAGE_ID.test(messageId))
     throw new Error(`${label}.messageId is invalid`);
   const kinds = ["dm", "group", "broadcast", "newsletter", "unknown"];
@@ -25243,7 +25602,7 @@ function parseInteraction(value, label) {
     chatJid: chat.jid,
     messageId,
     senderJid: sender,
-    timestamp: timestamp6(parsed.timestamp, `${label}.timestamp`),
+    timestamp: timestamp7(parsed.timestamp, `${label}.timestamp`),
     fromMe: bool3(parsed.fromMe, `${label}.fromMe`),
     chatKind: parsed.chatKind
   };
@@ -25252,9 +25611,9 @@ function interactionAnchor(item) {
   return createHash9("sha256").update(item.rowid).update("\x00").update(item.chatJid).update("\x00").update(item.messageId).digest("hex");
 }
 function parseInteractionPage(value, input, auth) {
-  const parsed = envelope(value, input, auth);
+  const parsed = envelope2(value, input, auth);
   const output = parsed.output;
-  exact4(output, ["provider", "operation", "accountSubject", "contactCollection", "projection", "projectionGeneration", "interactions", "nextCursor", "localInsertPageComplete", "checkpoint", "remoteHistoryComplete", "incompleteReasons"], "interaction output");
+  exact5(output, ["provider", "operation", "accountSubject", "contactCollection", "projection", "projectionGeneration", "interactions", "nextCursor", "localInsertPageComplete", "checkpoint", "remoteHistoryComplete", "incompleteReasons"], "interaction output");
   if (output.provider !== "whatsapp" || output.operation !== "contacts.list" || output.contactCollection !== "interactions" || output.projection !== "quiescent-account-bound-local-message-inserts" || output.remoteHistoryComplete !== false || stableJson6(output.incompleteReasons) !== stableJson6(["linked-device-history-coverage-unknown", "rowid-cursor-discovers-inserts-only"]) || input.collection !== "interactions") {
     throw new Error("interaction projection semantics drifted");
   }
@@ -25291,7 +25650,7 @@ function parseInteractionPage(value, input, auth) {
   };
 }
 function ghostgetWhatsAppSnapshot(options = {}) {
-  const auth = authId2(options.authId ?? DEFAULT_WHATSAPP_AUTH);
+  const auth = authId3(options.authId ?? DEFAULT_WHATSAPP_AUTH);
   const contactPageSize = options.contactPageSize === undefined ? DEFAULT_WHATSAPP_CONTACT_PAGE_SIZE : integer6(options.contactPageSize, "contact page size", 1, 100);
   const interactionPageSize = options.interactionPageSize === undefined ? DEFAULT_WHATSAPP_INTERACTION_PAGE_SIZE : integer6(options.interactionPageSize, "interaction page size", 1, 1000);
   const supplied = options.checkpoint;
@@ -25377,47 +25736,47 @@ function generationSha256(value) {
   return sha2569(stableJson6(value));
 }
 function ensureResource2(database, account, sourceRealmId, jid, name, basis, runId) {
-  const existing = getRow9(database, `SELECT id,person_id,source_realm_id FROM provider_resources
-    WHERE provider=? AND account_key=? AND resource_type='jid' AND resource_id=?`, PROVIDER11, account, jid);
+  const existing = getRow10(database, `SELECT id,person_id,source_realm_id FROM provider_resources
+    WHERE provider=? AND account_key=? AND resource_type='jid' AND resource_id=?`, PROVIDER12, account, jid);
   if (existing !== null) {
     if (existing.source_realm_id !== null && existing.source_realm_id !== sourceRealmId) {
       throw new Error("WhatsApp contact resource crossed its bound account realm");
     }
-    run8(database, `UPDATE provider_resources SET source_realm_id=?,display_name=coalesce(?,display_name),active=1,last_seen_run_id=?,
+    run9(database, `UPDATE provider_resources SET source_realm_id=?,display_name=coalesce(?,display_name),active=1,last_seen_run_id=?,
       metadata_json=? WHERE id=?`, sourceRealmId, name, runId, stableJson6({ jidKind: USER_JID.test(jid) ? "user" : "lid", displayNameBasis: basis }), existing.id);
     if (name !== null)
-      run8(database, "UPDATE people SET display_name=coalesce(display_name,?) WHERE id=?", name, existing.person_id);
+      run9(database, "UPDATE people SET display_name=coalesce(display_name,?) WHERE id=?", name, existing.person_id);
     return { personId: existing.person_id, resourceId: existing.id, imported: false };
   }
-  const personId = insertedId9(run8(database, "INSERT INTO people(stable_key,display_name,metadata_json) VALUES (?,?,?)", `whatsapp:${sha2569(`${account}\x00${jid}`)}`, name, stableJson6({ createdBy: "exact-whatsapp-jid" })));
+  const personId = insertedId10(run9(database, "INSERT INTO people(stable_key,display_name,metadata_json) VALUES (?,?,?)", `whatsapp:${sha2569(`${account}\x00${jid}`)}`, name, stableJson6({ createdBy: "exact-whatsapp-jid" })));
   const phone = phoneForJid(jid);
   if (phone !== null)
-    run8(database, `INSERT INTO contact_methods(
+    run9(database, `INSERT INTO contact_methods(
     person_id,kind,value,normalized_value,label,confidence,first_seen_run_id,last_seen_run_id,metadata_json
   ) VALUES (?,'phone',?,?,'whatsapp','exact',?,?,?)`, personId, phone, phone, runId, runId, stableJson6({ derivedFromJid: true }));
-  const resourceId = insertedId9(run8(database, `INSERT INTO provider_resources(
+  const resourceId = insertedId10(run9(database, `INSERT INTO provider_resources(
     provider,account_key,source_realm_id,resource_type,resource_id,person_id,display_name,active,
     first_seen_run_id,last_seen_run_id,metadata_json
-  ) VALUES (?,?,?,'jid',?,?,?,1,?,?,?)`, PROVIDER11, account, sourceRealmId, jid, personId, name, runId, runId, stableJson6({ jidKind: USER_JID.test(jid) ? "user" : "lid", displayNameBasis: basis })));
+  ) VALUES (?,?,?,'jid',?,?,?,1,?,?,?)`, PROVIDER12, account, sourceRealmId, jid, personId, name, runId, runId, stableJson6({ jidKind: USER_JID.test(jid) ? "user" : "lid", displayNameBasis: basis })));
   return { personId, resourceId, imported: true };
 }
 function parseStoredGeneration(value) {
-  const parsed = record6(JSON.parse(value), "stored WhatsApp checkpoint metadata");
-  exact4(parsed, ["generation", "coverage"], "stored WhatsApp checkpoint metadata");
+  const parsed = record7(JSON.parse(value), "stored WhatsApp checkpoint metadata");
+  exact5(parsed, ["generation", "coverage"], "stored WhatsApp checkpoint metadata");
   if (parsed.coverage !== "local-insert-rowid-scan")
     throw new Error("stored WhatsApp coverage drifted");
   return generation(parsed.generation);
 }
 function databaseCheckpoint(database, auth) {
-  const row = getRow9(database, `SELECT checkpoint.cursor,checkpoint.cursor_anchor_sha256,checkpoint.metadata_json
+  const row = getRow10(database, `SELECT checkpoint.cursor,checkpoint.cursor_anchor_sha256,checkpoint.metadata_json
     FROM provider_accounts account JOIN provider_checkpoints checkpoint
       ON checkpoint.provider=account.provider AND checkpoint.account_key=account.account_key
-    WHERE account.provider=? AND account.auth_id=? AND checkpoint.stream_key=?`, PROVIDER11, auth, STREAM2);
+    WHERE account.provider=? AND account.auth_id=? AND checkpoint.stream_key=?`, PROVIDER12, auth, STREAM2);
   return row === null ? { cursor: "0", anchor: null } : { cursor: row.cursor, anchor: row.cursor_anchor_sha256, generation: parseStoredGeneration(row.metadata_json) };
 }
 function refreshMetrics2(database, account, runId) {
-  run8(database, "DELETE FROM interaction_metrics WHERE provider=? AND account_key=?", PROVIDER11, account);
-  run8(database, `INSERT INTO interaction_metrics(
+  run9(database, "DELETE FROM interaction_metrics WHERE provider=? AND account_key=?", PROVIDER12, account);
+  run9(database, `INSERT INTO interaction_metrics(
     provider,account_key,person_id,sent_count,received_count,interaction_count,conversation_count,
     first_interaction_at,last_interaction_at,reciprocal,completeness,last_seen_run_id,metadata_json
   ) SELECT ?,?,person_id,sum(direction='outgoing'),sum(direction='incoming'),count(*),
@@ -25425,11 +25784,11 @@ function refreshMetrics2(database, account, runId) {
     CASE WHEN sum(direction='outgoing')>0 AND sum(direction='incoming')>0 THEN 1 ELSE 0 END,
     'lower-bound',?,'{"coverage":"local-insert-rowid-scan"}'
     FROM interaction_events WHERE provider=? AND account_key=? AND resolution='matched' AND person_id IS NOT NULL
-    GROUP BY person_id`, PROVIDER11, account, runId, PROVIDER11, account);
+    GROUP BY person_id`, PROVIDER12, account, runId, PROVIDER12, account);
 }
 function resultFromJson2(value) {
-  const parsed = record6(JSON.parse(value), "stored WhatsApp result");
-  exact4(parsed, ["account_subject", "contacts_seen", "contacts_imported", "contacts_matched", "contacts_skipped_self", "messages_seen", "messages_inserted", "matched_messages", "skipped_messages", "checkpoint_cursor", "local_insert_scan_complete", "remote_history_complete", "counts_complete", "counts_lower_bound"], "stored WhatsApp result");
+  const parsed = record7(JSON.parse(value), "stored WhatsApp result");
+  exact5(parsed, ["account_subject", "contacts_seen", "contacts_imported", "contacts_matched", "contacts_skipped_self", "messages_seen", "messages_inserted", "matched_messages", "skipped_messages", "checkpoint_cursor", "local_insert_scan_complete", "remote_history_complete", "counts_complete", "counts_lower_bound"], "stored WhatsApp result");
   const numeric = ["contacts_seen", "contacts_imported", "contacts_matched", "contacts_skipped_self", "messages_seen", "messages_inserted", "matched_messages", "skipped_messages"];
   for (const key of numeric)
     integer6(parsed[key], `stored WhatsApp result.${key}`, 0, Number.MAX_SAFE_INTEGER);
@@ -25480,26 +25839,26 @@ function importWhatsAppSnapshot(database, snapshot) {
   }));
   database.exec("BEGIN IMMEDIATE");
   try {
-    const byAuth = getRow9(database, "SELECT account_key,auth_sha256 FROM provider_accounts WHERE provider=? AND auth_id=?", PROVIDER11, snapshot.authId);
-    const byAccount = getRow9(database, "SELECT auth_id,auth_sha256 FROM provider_accounts WHERE provider=? AND account_key=?", PROVIDER11, account);
+    const byAuth = getRow10(database, "SELECT account_key,auth_sha256 FROM provider_accounts WHERE provider=? AND auth_id=?", PROVIDER12, snapshot.authId);
+    const byAccount = getRow10(database, "SELECT auth_id,auth_sha256 FROM provider_accounts WHERE provider=? AND account_key=?", PROVIDER12, account);
     if (byAuth !== null && (byAuth.account_key !== account || byAuth.auth_sha256 !== firstExecution.authSha256) || byAccount !== null && (byAccount.auth_id !== snapshot.authId || byAccount.auth_sha256 !== firstExecution.authSha256)) {
       throw new Error("WhatsApp durable auth-to-account binding drifted");
     }
     if (byAuth === null)
-      run8(database, `INSERT INTO provider_accounts(provider,auth_id,account_key,auth_sha256,first_seen_at,last_seen_at)
-      VALUES (?,?,?,?,?,?)`, PROVIDER11, snapshot.authId, account, firstExecution.authSha256, firstExecution.startedAt, lastExecution.finishedAt);
+      run9(database, `INSERT INTO provider_accounts(provider,auth_id,account_key,auth_sha256,first_seen_at,last_seen_at)
+      VALUES (?,?,?,?,?,?)`, PROVIDER12, snapshot.authId, account, firstExecution.authSha256, firstExecution.startedAt, lastExecution.finishedAt);
     else
-      run8(database, "UPDATE provider_accounts SET last_seen_at=? WHERE provider=? AND auth_id=?", lastExecution.finishedAt, PROVIDER11, snapshot.authId);
+      run9(database, "UPDATE provider_accounts SET last_seen_at=? WHERE provider=? AND auth_id=?", lastExecution.finishedAt, PROVIDER12, snapshot.authId);
     const sourceRealmId = bindProviderAccountRealm(database, {
-      provider: PROVIDER11,
+      provider: PROVIDER12,
       authId: snapshot.authId,
       accountKey: account,
       authSha256: firstExecution.authSha256,
       firstSeenAt: firstExecution.startedAt,
       lastSeenAt: lastExecution.finishedAt
     }).id;
-    const storedCheckpoint = getRow9(database, `SELECT cursor,cursor_anchor_sha256,generation_sha256,metadata_json
-      FROM provider_checkpoints WHERE provider=? AND account_key=? AND stream_key=?`, PROVIDER11, account, STREAM2);
+    const storedCheckpoint = getRow10(database, `SELECT cursor,cursor_anchor_sha256,generation_sha256,metadata_json
+      FROM provider_checkpoints WHERE provider=? AND account_key=? AND stream_key=?`, PROVIDER12, account, STREAM2);
     if (storedCheckpoint === null) {
       if (snapshot.startCheckpoint.cursor !== "0" || snapshot.startCheckpoint.anchor !== null || snapshot.startCheckpoint.generation !== undefined)
         throw new Error("WhatsApp initial scan must start at zero");
@@ -25509,8 +25868,8 @@ function importWhatsAppSnapshot(database, snapshot) {
         throw new Error("WhatsApp durable checkpoint or message-store generation drifted");
       }
     }
-    const existingRun = getRow9(database, `SELECT result_json FROM source_runs
-      WHERE provider=? AND account_key=? AND mode='linked-device-sync' AND source_sha256=?`, PROVIDER11, account, sourceDigest);
+    const existingRun = getRow10(database, `SELECT result_json FROM source_runs
+      WHERE provider=? AND account_key=? AND mode='linked-device-sync' AND source_sha256=?`, PROVIDER12, account, sourceDigest);
     if (existingRun !== null) {
       database.exec("COMMIT");
       return resultFromJson2(existingRun.result_json);
@@ -25527,8 +25886,8 @@ function importWhatsAppSnapshot(database, snapshot) {
           expectedContactsSkippedSelf += 1;
           continue;
         }
-        const exists = getRow9(database, `SELECT 1 FROM provider_resources
-        WHERE provider=? AND account_key=? AND resource_type='jid' AND resource_id=?`, PROVIDER11, account, contact.providerId) !== null;
+        const exists = getRow10(database, `SELECT 1 FROM provider_resources
+        WHERE provider=? AND account_key=? AND resource_type='jid' AND resource_id=?`, PROVIDER12, account, contact.providerId) !== null;
         if (exists)
           expectedContactsMatched += 1;
         else
@@ -25561,11 +25920,11 @@ function importWhatsAppSnapshot(database, snapshot) {
       counts_complete: false,
       counts_lower_bound: true
     };
-    const runInsert = run8(database, `INSERT INTO source_runs(
+    const runInsert = run9(database, `INSERT INTO source_runs(
       provider,account_key,mode,source_sha256,source_locator_sha256,completeness,
       result_json,started_at,completed_at
-    ) VALUES (?,?,'linked-device-sync',?,?,'lower-bound',?,?,?)`, PROVIDER11, account, sourceDigest, sha2569(snapshot.authId), stableJson6(expectedResult), firstExecution.startedAt, lastExecution.finishedAt);
-    const runId = insertedId9(runInsert);
+    ) VALUES (?,?,'linked-device-sync',?,?,'lower-bound',?,?,?)`, PROVIDER12, account, sourceDigest, sha2569(snapshot.authId), stableJson6(expectedResult), firstExecution.startedAt, lastExecution.finishedAt);
+    const runId = insertedId10(runInsert);
     let ordinal = 0;
     let contactsSeen = 0;
     let contactsImported = 0;
@@ -25578,7 +25937,7 @@ function importWhatsAppSnapshot(database, snapshot) {
         if (contact.providerId === owner) {
           contactsSkippedSelf += 1;
           const item2 = stableJson6({ type: "contact", ...contact, resolution: "skipped-self" });
-          run8(database, `INSERT INTO source_records(run_id,ordinal,record_kind,record_sha256,resolution,projection_json,error_text)
+          run9(database, `INSERT INTO source_records(run_id,ordinal,record_kind,record_sha256,resolution,projection_json,error_text)
           VALUES (?,?,'contact',?,'skipped',?,'owner-self-contact')`, runId, ordinal, sha2569(item2), item2);
           continue;
         }
@@ -25588,7 +25947,7 @@ function importWhatsAppSnapshot(database, snapshot) {
         else
           contactsMatched += 1;
         const item = stableJson6({ type: "contact", ...contact });
-        run8(database, `INSERT INTO source_records(
+        run9(database, `INSERT INTO source_records(
         run_id,ordinal,record_kind,record_sha256,person_id,provider_resource_id,resolution,projection_json
       ) VALUES (?,?,'contact',?,?,?,?,?)`, runId, ordinal, sha2569(item), identity.personId, identity.resourceId, identity.imported ? "imported" : "matched", item);
       }
@@ -25632,13 +25991,13 @@ function importWhatsAppSnapshot(database, snapshot) {
           reason
         };
         const evidenceJson = stableJson6(evidence);
-        run8(database, `INSERT INTO source_records(
+        run9(database, `INSERT INTO source_records(
         run_id,ordinal,record_kind,record_sha256,person_id,provider_resource_id,resolution,projection_json,error_text
       ) VALUES (?,?,'message',?,?,?,?,?,?)`, runId, ordinal, sha2569(evidenceJson), personId, resourceId, resolution, evidenceJson, resolution === "matched" ? null : reason);
-        run8(database, `INSERT INTO interaction_events(
+        run9(database, `INSERT INTO interaction_events(
         provider,account_key,external_id,person_id,occurred_at,direction,conversation_sha256,
         event_kind,resolution,run_id,metadata_json
-      ) VALUES (?,?,?,?,?,?,?,'message',?,?,?)`, PROVIDER11, account, `row:${message.rowid}`, personId, message.timestamp, direction, conversationHash, resolution, runId, stableJson6({ conversationKind, reason, messageIdSha256: sha2569(message.messageId) }));
+      ) VALUES (?,?,?,?,?,?,?,'message',?,?,?)`, PROVIDER12, account, `row:${message.rowid}`, personId, message.timestamp, direction, conversationHash, resolution, runId, stableJson6({ conversationKind, reason, messageIdSha256: sha2569(message.messageId) }));
         messagesInserted += 1;
       }
     refreshMetrics2(database, account, runId);
@@ -25660,8 +26019,8 @@ function importWhatsAppSnapshot(database, snapshot) {
     };
     if (stableJson6(result) !== stableJson6(expectedResult))
       throw new Error("WhatsApp applied counts drifted from the reviewed snapshot");
-    const metadata3 = stableJson6({ generation: scanGeneration, coverage: "local-insert-rowid-scan" });
-    run8(database, `INSERT INTO provider_checkpoints(
+    const metadata4 = stableJson6({ generation: scanGeneration, coverage: "local-insert-rowid-scan" });
+    run9(database, `INSERT INTO provider_checkpoints(
       provider,account_key,source_realm_id,stream_key,source_locator_sha256,schema_sha256,generation_sha256,
       cursor,cursor_anchor_sha256,last_run_id,metadata_json
     ) VALUES (?,?,?,?,?,?,?,?,?,?,?)
@@ -25669,7 +26028,7 @@ function importWhatsAppSnapshot(database, snapshot) {
       source_realm_id=excluded.source_realm_id,source_locator_sha256=excluded.source_locator_sha256,schema_sha256=excluded.schema_sha256,
       generation_sha256=excluded.generation_sha256,cursor=excluded.cursor,
       cursor_anchor_sha256=excluded.cursor_anchor_sha256,last_run_id=excluded.last_run_id,
-      metadata_json=excluded.metadata_json,updated_at=CURRENT_TIMESTAMP`, PROVIDER11, account, sourceRealmId, STREAM2, sha2569(snapshot.authId), CONTACTS_CONTRACT_SHA2562, generationSha256(scanGeneration), end2.cursor, end2.anchor, runId, metadata3);
+      metadata_json=excluded.metadata_json,updated_at=CURRENT_TIMESTAMP`, PROVIDER12, account, sourceRealmId, STREAM2, sha2569(snapshot.authId), CONTACTS_CONTRACT_SHA2562, generationSha256(scanGeneration), end2.cursor, end2.anchor, runId, metadata4);
     database.exec("COMMIT");
     return result;
   } catch (error) {
@@ -25678,13 +26037,13 @@ function importWhatsAppSnapshot(database, snapshot) {
   }
 }
 function syncWhatsAppRelationships(database, options = {}) {
-  const auth = authId2(options.authId ?? DEFAULT_WHATSAPP_AUTH);
+  const auth = authId3(options.authId ?? DEFAULT_WHATSAPP_AUTH);
   if (options.checkpoint !== undefined)
     throw new Error("sync checkpoint is database-owned");
   const snapshot = ghostgetWhatsAppSnapshot({ ...options, authId: auth, checkpoint: databaseCheckpoint(database, auth) });
   for (const page of [...snapshot.contactPages, ...snapshot.interactionPages]) {
     ledgerPeopleBladeGhostgetInvocation(database, {
-      provider: PROVIDER11,
+      provider: PROVIDER12,
       accountKey: snapshot.accountSubject,
       capability: "contact_interactions",
       execution: page.execution,
@@ -25698,7 +26057,7 @@ function syncWhatsAppRelationships(database, options = {}) {
 }
 
 // src/cli/version.ts
-var peoplebladeVersion = "0.2.2";
+var peoplebladeVersion = "0.3.0";
 
 // src/cli/main.ts
 var usage = `PeopleBlade \u2014 local-first contact intelligence
@@ -25752,6 +26111,9 @@ Sources (append --auto-accept to run identity auto-accept after a successful imp
   x mutuals sync                    Sync X mutuals through Ghostget (requires reviewed Ghostget capability)
   whatsapp sync [--auth ID]        Sync WhatsApp through Ghostget's linked-device projection
   linkedin import ZIP               Import an official LinkedIn data-export ZIP
+  linkedin contact-info --person-id ID
+                                    Read one first-degree connection's Contact info through Ghostget
+                                    [--account KEY] [--auth ID]
   linkedin stats                    Show aggregate LinkedIn import statistics
   instagram import ZIP              Import an official Instagram JSON archive
   instagram stats                   Show aggregate Instagram import statistics
@@ -26481,14 +26843,14 @@ ${verification}`) });
     }
     if (command === "beeper" && subcommand === "sync") {
       const options = [...rest];
-      const authId3 = valueAfter(options, "--auth");
+      const authId4 = valueAfter(options, "--auth");
       const contactLimit = positive(valueAfter(options, "--contact-limit"), "--contact-limit", 200, 200);
       const withRelationships = options.includes("--with-relationships");
       if (withRelationships)
         options.splice(options.indexOf("--with-relationships"), 1);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      const effectiveAuthId = authId3 ?? DEFAULT_BEEPER_AUTH;
+      const effectiveAuthId = authId4 ?? DEFAULT_BEEPER_AUTH;
       if (withRelationships)
         console.error("Beeper relationships \xB7 deriving a body-free interaction summary through Ghostget");
       console.error("Beeper contacts \xB7 discovering connected accounts through Ghostget");
@@ -26510,7 +26872,7 @@ ${verification}`) });
     }
     if (command === "beeper" && subcommand === "rebind") {
       const options = [...rest];
-      const authId3 = valueAfter(options, "--auth");
+      const authId4 = valueAfter(options, "--auth");
       const confirm = options.includes("--confirm");
       if (confirm)
         options.splice(options.indexOf("--confirm"), 1);
@@ -26519,14 +26881,14 @@ ${verification}`) });
       if (!confirm)
         fail3("beeper rebind requires --confirm after reviewing the current Ghostget binding, release, and connected-account inventory.");
       console.error("Beeper binding \xB7 verifying the complete connected-account inventory before an append-only transition");
-      print(rebindBeeperSource(database, { ...authId3 === undefined ? {} : { authId: authId3 } }), asJson);
+      print(rebindBeeperSource(database, { ...authId4 === undefined ? {} : { authId: authId4 } }), asJson);
       return;
     }
     if (command === "beeper" && subcommand === "search") {
       const options = [...rest];
       const queries = valuesAfter(options, "--query");
       const services = valuesAfter(options, "--service");
-      const authId3 = valueAfter(options, "--auth");
+      const authId4 = valueAfter(options, "--auth");
       const limit = positive(valueAfter(options, "--limit"), "--limit", 20, 20);
       if (queries.length === 0)
         fail3("beeper search requires one or more --query values.");
@@ -26535,18 +26897,18 @@ ${verification}`) });
       print(backfillBeeperSearch(database, {
         queries,
         ...services.length === 0 ? {} : { services },
-        ...authId3 === undefined ? {} : { authId: authId3 },
+        ...authId4 === undefined ? {} : { authId: authId4 },
         limit
       }), asJson);
       return;
     }
     if (command === "google" && subcommand === "sync") {
       const options = [...rest];
-      const authId3 = valueAfter(options, "--auth");
+      const authId4 = valueAfter(options, "--auth");
       const pageSize = positive(valueAfter(options, "--page-size"), "--page-size", 100, 100);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      printImport(syncGoogleContacts(database, { ...authId3 === undefined ? {} : { authId: authId3 }, pageSize }), asJson);
+      printImport(syncGoogleContacts(database, { ...authId4 === undefined ? {} : { authId: authId4 }, pageSize }), asJson);
       return;
     }
     if (command === "google" && subcommand === "stats") {
@@ -26571,13 +26933,13 @@ ${verification}`) });
     }
     if (command === "whatsapp" && subcommand === "sync") {
       const options = [...rest];
-      const authId3 = valueAfter(options, "--auth");
+      const authId4 = valueAfter(options, "--auth");
       const contactPageSize = positive(valueAfter(options, "--contact-page-size"), "--contact-page-size", 100, 100);
       const interactionPageSize = positive(valueAfter(options, "--interaction-page-size"), "--interaction-page-size", 1000, 1000);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
       printImport(syncWhatsAppRelationships(database, {
-        ...authId3 === undefined ? {} : { authId: authId3 },
+        ...authId4 === undefined ? {} : { authId: authId4 },
         contactPageSize,
         interactionPageSize
       }), asJson);
@@ -26598,6 +26960,25 @@ ${verification}`) });
       }), asJson);
       return;
     }
+    if (command === "linkedin" && subcommand === "contact-info") {
+      const options = [...rest];
+      const personText = valueAfter(options, "--person-id");
+      if (personText === undefined)
+        fail3("linkedin contact-info requires --person-id ID.");
+      const personId = Number(personText);
+      if (!Number.isSafeInteger(personId) || personId < 1)
+        fail3("--person-id must be a positive integer.");
+      const accountKey5 = valueAfter(options, "--account");
+      const authId4 = valueAfter(options, "--auth");
+      if (options.length)
+        fail3(`Unknown argument: ${options[0]}`);
+      print(readLinkedInContactInfo(database, {
+        personId,
+        ...accountKey5 === undefined ? {} : { accountKey: accountKey5 },
+        ...authId4 === undefined ? {} : { authId: authId4 }
+      }), asJson);
+      return;
+    }
     if (command === "linkedin" && subcommand === "stats") {
       if (rest.length)
         fail3(`Unknown argument: ${rest[0]}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hraness/peopleblade",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "description": "Local-first, source-aware contact intelligence for people and agents",
   "type": "module",
   "bin": {