@hraness/peopleblade 0.2.1 → 0.3.0

package/dist/peopleblade.js

@@ -4312,20 +4312,21 @@ var peoplebladeCapabilities = Object.freeze({
   sources: [
     { 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: "wrench", requirement: "Reviewed Gmail/People contacts.list and contact scopes" },
-    { id: "beeper", command: "beeper sync", status: "supported", transport: "wrench", requirement: "Wrench 0.16.8, Beeper adapter 2.4.0, CLI 0.6.2; body-free relationships require macOS arm64" },
-    { id: "whatsapp", command: "whatsapp sync", status: "supported", transport: "wrench", 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: "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.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; 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 Wrench mutuals capability is not yet available" },
+    { id: "x-live", command: "x mutuals sync", status: "blocked", transport: "unavailable", requirement: "A reviewed bounded Ghostget mutuals capability is not yet available" },
     { id: "telegram", command: "telegram status", status: "planned", transport: "unavailable", requirement: "First real export and importer validation remain pending" }
   ],
   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 },
@@ -12341,7 +12342,7 @@ function importContactSourceSnapshot(database, value) {
   }
 }
 
-// node_modules/@hraness/wrench/dist/index-26yq8q16.js
+// node_modules/@hraness/ghostget/dist/index-26yq8q16.js
 var PROVIDER_PLUGIN_ID_MAX_LENGTH = 63;
 var PROVIDER_PLUGIN_OPERATION_NAME_MAX_LENGTH = 163;
 var strictKebabPattern = /^[a-z][a-z0-9]*(?:-[a-z0-9]+)*$/u;
@@ -12360,7 +12361,7 @@ function isProviderPluginOperationName(value) {
   return segments.length >= 2 && segments.length <= 4 && segments.every((segment) => segment.length <= 40 && strictKebabSegmentPattern.test(segment));
 }
 
-// node_modules/@hraness/wrench/dist/index-dqv16dt0.js
+// node_modules/@hraness/ghostget/dist/index-gwk7rbyj.js
 import { createHash as createHash4 } from "crypto";
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -12388,7 +12389,7 @@ function sha2563(value) {
   return createHash4("sha256").update(value).digest("hex");
 }
 
-// node_modules/@hraness/wrench/dist/client.js
+// node_modules/@hraness/ghostget/dist/client.js
 import { spawn, spawnSync } from "child_process";
 import { existsSync as existsSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
@@ -12485,7 +12486,7 @@ function publicWebSessionAuthority(request) {
 function expectedRequestAuthId(request, authKind) {
   if (authKind === PUBLIC_WEB_SESSION_AUTHORITY_KIND) {
     if (request.authId !== undefined) {
-      throw new Error("Wrench public invocation unexpectedly accepted an auth locator");
+      throw new Error("Ghostget public invocation unexpectedly accepted an auth locator");
     }
     return publicWebSessionAuthority(request).id;
   }
@@ -12535,14 +12536,14 @@ var clientReadFailureRetryDisposition = Object.freeze({
   "cleanup-required": "do-not-retry"
 });
 function parseClientReadFailure(value) {
-  const failure = record(value, "Wrench read failure");
-  assertExactKeys(failure, ["category", "retryDisposition"], [], "Wrench read failure");
+  const failure = record(value, "Ghostget read failure");
+  assertExactKeys(failure, ["category", "retryDisposition"], [], "Ghostget read failure");
   const category = failure.category;
   if (typeof category !== "string" || !Object.hasOwn(clientReadFailureRetryDisposition, category))
-    throw new Error("Wrench read failure category is malformed");
+    throw new Error("Ghostget read failure category is malformed");
   const retryDisposition = clientReadFailureRetryDisposition[category];
   if (failure.retryDisposition !== retryDisposition) {
-    throw new Error("Wrench read failure retry disposition is inconsistent");
+    throw new Error("Ghostget read failure retry disposition is inconsistent");
   }
   return Object.freeze({ category, retryDisposition });
 }
@@ -12693,16 +12694,16 @@ function cliSourcePath() {
   const packagedSource = fileURLToPath2(new URL("../src/cli.ts", import.meta.url));
   if (existsSync3(packagedSource))
     return packagedSource;
-  throw new Error("the installed Wrench CLI source is unavailable");
+  throw new Error("the installed Ghostget CLI source is unavailable");
 }
 function requireBunRuntime() {
   if (typeof process.versions.bun !== "string") {
-    throw new Error("@hraness/wrench/client requires Bun to run the installed Wrench CLI");
+    throw new Error("@hraness/ghostget/client requires Bun to run the installed Ghostget CLI");
   }
 }
 function environmentName(value) {
   if (value.length < 1 || value.includes("=") || value.includes("\x00")) {
-    throw new Error("Wrench client environment name is malformed");
+    throw new Error("Ghostget client environment name is malformed");
   }
   return value;
 }
@@ -12723,26 +12724,26 @@ function snapshotChildEnvironment(overrides) {
   if (overrides === undefined)
     return Object.freeze(environment);
   if (!isRecord2(overrides) || nodeTypes.isProxy(overrides) || Object.getPrototypeOf(overrides) !== Object.prototype && Object.getPrototypeOf(overrides) !== null) {
-    throw new Error("Wrench client environment must use a plain, non-proxy object");
+    throw new Error("Ghostget client environment must use a plain, non-proxy object");
   }
   const descriptors = Object.getOwnPropertyDescriptors(overrides);
   const keys = Reflect.ownKeys(descriptors);
   if (keys.some((key) => typeof key !== "string")) {
-    throw new Error("Wrench client environment has unsupported symbol fields");
+    throw new Error("Ghostget client environment has unsupported symbol fields");
   }
   for (const key of keys.sort((left, right) => left.localeCompare(right))) {
     const descriptor = descriptors[key];
     if (descriptor === undefined || !("value" in descriptor)) {
-      throw new Error("Wrench client environment must contain only data properties");
+      throw new Error("Ghostget client environment must contain only data properties");
     }
     if (!descriptor.enumerable) {
-      throw new Error("Wrench client environment properties must be enumerable");
+      throw new Error("Ghostget client environment properties must be enumerable");
     }
     const name = environmentName(key);
     if (descriptor.value === undefined) {
       delete environment[name];
     } else if (typeof descriptor.value !== "string" || descriptor.value.includes("\x00")) {
-      throw new Error("Wrench client environment value is malformed");
+      throw new Error("Ghostget client environment value is malformed");
     } else {
       defineEnvironmentValue(environment, name, descriptor.value);
     }
@@ -12762,20 +12763,20 @@ function isBrandedAbortSignal(value) {
 }
 function snapshotClientOptions(optionsValue, mode) {
   if (!isRecord2(optionsValue) || nodeTypes.isProxy(optionsValue) || Object.getPrototypeOf(optionsValue) !== Object.prototype && Object.getPrototypeOf(optionsValue) !== null)
-    throw new Error("Wrench client options must use a plain, non-proxy object");
+    throw new Error("Ghostget client options must use a plain, non-proxy object");
   const descriptors = Object.getOwnPropertyDescriptors(optionsValue);
   const keys = Reflect.ownKeys(descriptors);
   if (keys.some((key) => typeof key !== "string")) {
-    throw new Error("Wrench client options have unsupported symbol fields");
+    throw new Error("Ghostget client options have unsupported symbol fields");
   }
   const allowed = new Set(mode === "read" ? ["environment", "freshForMs", "now"] : mode === "revalidation" ? ["environment", "freshForMs", "now", "headed", "signal"] : mode === "invoke-async" ? ["environment", "headed", "signal"] : ["environment", "headed"]);
   for (const key of keys) {
     const descriptor = descriptors[key];
     if (descriptor === undefined || !allowed.has(key)) {
-      throw new Error("Wrench client options contain an unsupported field");
+      throw new Error("Ghostget client options contain an unsupported field");
     }
     if (!("value" in descriptor)) {
-      throw new Error("Wrench client options must contain only data properties");
+      throw new Error("Ghostget client options must contain only data properties");
     }
   }
   const option = (key) => descriptors[key]?.value;
@@ -12783,27 +12784,27 @@ function snapshotClientOptions(optionsValue, mode) {
   const nowValue = option("now");
   const headedValue = option("headed");
   const signalValue = option("signal");
-  const freshForMs = freshForMsValue === undefined ? undefined : safeInteger(freshForMsValue, "Wrench client freshness window", 0, MAX_FRESH_FOR_MS);
+  const freshForMs = freshForMsValue === undefined ? undefined : safeInteger(freshForMsValue, "Ghostget client freshness window", 0, MAX_FRESH_FOR_MS);
   let now;
   if (nowValue !== undefined) {
     if (nodeTypes.isProxy(nowValue) || !(nowValue instanceof Date) || Object.getPrototypeOf(nowValue) !== Date.prototype)
-      throw new Error("Wrench client observation time is invalid");
+      throw new Error("Ghostget client observation time is invalid");
     let time;
     try {
       time = Date.prototype.getTime.call(nowValue);
     } catch {
-      throw new Error("Wrench client observation time is invalid");
+      throw new Error("Ghostget client observation time is invalid");
     }
     if (!Number.isFinite(time)) {
-      throw new Error("Wrench client observation time is invalid");
+      throw new Error("Ghostget client observation time is invalid");
     }
     now = new Date(time);
   }
   if (headedValue !== undefined && typeof headedValue !== "boolean") {
-    throw new Error("Wrench client headed option is malformed");
+    throw new Error("Ghostget client headed option is malformed");
   }
   if (signalValue !== undefined && !isBrandedAbortSignal(signalValue))
-    throw new Error("Wrench client abort signal is malformed");
+    throw new Error("Ghostget client abort signal is malformed");
   return Object.freeze({
     cwd: process.cwd(),
     environment: snapshotChildEnvironment(option("environment")),
@@ -12814,18 +12815,18 @@ function snapshotClientOptions(optionsValue, mode) {
   });
 }
 function prepareRequest(requestValue) {
-  const snapshot = snapshotJson(requestValue, "Wrench client request");
-  const request = record(snapshot, "Wrench client request");
-  assertExactKeys(request, ["adapterId", "operationId"], ["authId", "input"], "Wrench client request");
-  const adapterId = safeString(request.adapterId, "Wrench client adapter ID", 64);
-  const operationId = providerOperationName(request.operationId, "Wrench client operation ID");
-  const authId = Object.hasOwn(request, "authId") ? safeString(request.authId, "Wrench client auth ID", 64) : undefined;
+  const snapshot = snapshotJson(requestValue, "Ghostget client request");
+  const request = record(snapshot, "Ghostget client request");
+  assertExactKeys(request, ["adapterId", "operationId"], ["authId", "input"], "Ghostget client request");
+  const adapterId = safeString(request.adapterId, "Ghostget client adapter ID", 64);
+  const operationId = providerOperationName(request.operationId, "Ghostget client operation ID");
+  const authId = Object.hasOwn(request, "authId") ? safeString(request.authId, "Ghostget client auth ID", 64) : undefined;
   const rawInput = Object.hasOwn(request, "input") ? request.input : {};
   if (!isRecord2(rawInput))
     throw new Error("input must be a JSON object");
   const input = canonicalJson2(rawInput);
   if (Buffer.byteLength(input, "utf8") > MAX_INPUT_BYTES) {
-    throw new Error("Wrench client input exceeds its byte bound");
+    throw new Error("Ghostget client input exceeds its byte bound");
   }
   return Object.freeze({
     adapterId,
@@ -12896,7 +12897,7 @@ function runIdentityCommand(command, options, label, responseLabel = `${label} r
   return parseOutput(stdout, responseLabel);
 }
 function runProjectionIdentityCommand(command, options) {
-  return runIdentityCommand(command, options, "Wrench projection identity preflight", "Wrench projection identity response");
+  return runIdentityCommand(command, options, "Ghostget projection identity preflight", "Ghostget projection identity response");
 }
 function observeProjectionIdentity(request, options) {
   const value = runProjectionIdentityCommand(preparedCommand(request, {
@@ -12905,7 +12906,7 @@ function observeProjectionIdentity(request, options) {
     headed: false
   }), options);
   if (value.ok !== true || value.source !== "projection-identity")
-    throw new Error("Wrench projection identity response is malformed");
+    throw new Error("Ghostget projection identity response is malformed");
   if (value.status === "ready") {
     assertExactKeys(value, [
       "ok",
@@ -12915,15 +12916,15 @@ function observeProjectionIdentity(request, options) {
       "authHash",
       "inputHash",
       "projection"
-    ], [], "Wrench projection identity response");
-    const projection = record(value.projection, "Wrench projection identity");
-    assertExactKeys(projection, ["key"], [], "Wrench projection identity");
+    ], [], "Ghostget projection identity response");
+    const projection = record(value.projection, "Ghostget projection identity");
+    assertExactKeys(projection, ["key"], [], "Ghostget projection identity");
     return Object.freeze({
       status: "ready",
-      key: digest(projection.key, "Wrench projection identity key"),
-      authIdentity: digest(value.authIdentity, "Wrench projection auth identity"),
-      authHash: digest(value.authHash, "Wrench projection auth hash"),
-      inputHash: digest(value.inputHash, "Wrench projection validated input hash")
+      key: digest(projection.key, "Ghostget projection identity key"),
+      authIdentity: digest(value.authIdentity, "Ghostget projection auth identity"),
+      authHash: digest(value.authHash, "Ghostget projection auth hash"),
+      inputHash: digest(value.inputHash, "Ghostget projection validated input hash")
     });
   }
   if (value.status === "unbound") {
@@ -12934,15 +12935,15 @@ function observeProjectionIdentity(request, options) {
       "authIdentity",
       "authHash",
       "inputHash"
-    ], [], "Wrench projection identity response");
+    ], [], "Ghostget projection identity response");
     return Object.freeze({
       status: "unbound",
-      authIdentity: digest(value.authIdentity, "Wrench projection auth identity"),
-      authHash: digest(value.authHash, "Wrench projection auth hash"),
-      inputHash: digest(value.inputHash, "Wrench projection validated input hash")
+      authIdentity: digest(value.authIdentity, "Ghostget projection auth identity"),
+      authHash: digest(value.authHash, "Ghostget projection auth hash"),
+      inputHash: digest(value.inputHash, "Ghostget projection validated input hash")
     });
   }
-  throw new Error("Wrench projection identity response is malformed");
+  throw new Error("Ghostget projection identity response is malformed");
 }
 function projectionIdentitiesMatch(before, after) {
   return before.status === "ready" ? after.status === "ready" && after.key === before.key && after.authIdentity === before.authIdentity && after.authHash === before.authHash && after.inputHash === before.inputHash : after.status === "unbound" && after.authIdentity === before.authIdentity && after.authHash === before.authHash && after.inputHash === before.inputHash;
@@ -12962,43 +12963,43 @@ function parseExecutionPreview(value, request) {
     "identityBinding",
     "transport",
     ...portable ? ["portablePluginContract"] : []
-  ], [], "Wrench execution identity preview");
+  ], [], "Ghostget execution identity preview");
   if (value.ok !== true || value.status !== "preview" || value.requiresConfirmation !== false || value.risk !== "R1")
-    throw new Error("Wrench execution identity preview is malformed");
-  const adapterValue = record(value.adapter, "Wrench execution identity preview adapter");
-  const auth = record(value.auth, "Wrench execution identity preview auth");
-  const binding2 = record(value.identityBinding, "Wrench execution identity preview binding");
-  assertExactKeys(adapterValue, ["id", "version", "hash"], [], "Wrench execution identity preview adapter");
-  assertExactKeys(auth, ["id", "kind", "realmFingerprint"], [], "Wrench execution identity preview auth");
-  assertExactKeys(binding2, ["status", "subject", "accountActor", "requestedActor"], [], "Wrench execution identity preview binding");
+    throw new Error("Ghostget execution identity preview is malformed");
+  const adapterValue = record(value.adapter, "Ghostget execution identity preview adapter");
+  const auth = record(value.auth, "Ghostget execution identity preview auth");
+  const binding2 = record(value.identityBinding, "Ghostget execution identity preview binding");
+  assertExactKeys(adapterValue, ["id", "version", "hash"], [], "Ghostget execution identity preview adapter");
+  assertExactKeys(auth, ["id", "kind", "realmFingerprint"], [], "Ghostget execution identity preview auth");
+  assertExactKeys(binding2, ["status", "subject", "accountActor", "requestedActor"], [], "Ghostget execution identity preview binding");
   const adapter = Object.freeze({
-    id: safeString(adapterValue.id, "Wrench execution identity preview adapter ID", 64),
-    version: safeString(adapterValue.version, "Wrench execution identity preview adapter version", 64),
-    hash: digest(adapterValue.hash, "Wrench execution identity preview adapter hash")
+    id: safeString(adapterValue.id, "Ghostget execution identity preview adapter ID", 64),
+    version: safeString(adapterValue.version, "Ghostget execution identity preview adapter version", 64),
+    hash: digest(adapterValue.hash, "Ghostget execution identity preview adapter hash")
   });
-  const operation = providerOperationName(value.operation, "Wrench execution identity preview operation");
+  const operation = providerOperationName(value.operation, "Ghostget execution identity preview operation");
   if (adapter.id !== request.adapterId || operation !== request.operationId) {
-    throw new Error("Wrench execution identity preview route is malformed");
+    throw new Error("Ghostget execution identity preview route is malformed");
   }
-  const authKind = safeString(auth.kind, "Wrench execution identity preview auth kind", 64);
-  if (safeString(auth.id, "Wrench execution identity preview auth ID", 64) !== expectedRequestAuthId(request, authKind))
-    throw new Error("Wrench execution identity preview auth is malformed");
-  const realmFingerprint = safeString(auth.realmFingerprint, "Wrench execution identity preview auth fingerprint", 16);
+  const authKind = safeString(auth.kind, "Ghostget execution identity preview auth kind", 64);
+  if (safeString(auth.id, "Ghostget execution identity preview auth ID", 64) !== expectedRequestAuthId(request, authKind))
+    throw new Error("Ghostget execution identity preview auth is malformed");
+  const realmFingerprint = safeString(auth.realmFingerprint, "Ghostget execution identity preview auth fingerprint", 16);
   if (!/^[a-f0-9]{16}$/u.test(realmFingerprint)) {
-    throw new Error("Wrench execution identity preview auth fingerprint is malformed");
+    throw new Error("Ghostget execution identity preview auth fingerprint is malformed");
   }
   if (authKind === PUBLIC_WEB_SESSION_AUTHORITY_KIND) {
     const authority = publicWebSessionAuthority(request);
     if (value.transport !== "web-session-api" || realmFingerprint !== sha2563(canonicalJson2(authority)).slice(0, 16) || binding2.status !== "public" || binding2.subject !== authority.subject || binding2.accountActor !== null || binding2.requestedActor !== null) {
-      throw new Error("Wrench execution identity preview public authority is malformed");
+      throw new Error("Ghostget execution identity preview public authority is malformed");
     }
   }
-  safeString(value.sideEffect, "Wrench execution identity preview side effect", 64);
+  safeString(value.sideEffect, "Ghostget execution identity preview side effect", 64);
   const transport = value.transport;
   if (transport === "portable-provider-plugin") {
     const portablePluginContract = parsePortableOperationIdentity(value.portablePluginContract);
     if (portablePluginContract.adapterId !== adapter.id || portablePluginContract.operation !== operation)
-      throw new Error("Wrench execution identity preview route is malformed");
+      throw new Error("Ghostget execution identity preview route is malformed");
     return Object.freeze({
       adapter,
       operation,
@@ -13007,18 +13008,18 @@ function parseExecutionPreview(value, request) {
     });
   }
   if (transport !== "browser" && transport !== "provider-api" && transport !== "web-session-api" && transport !== "reviewed-template-api" && transport !== "local-cli")
-    throw new Error("Wrench execution identity preview transport is malformed");
+    throw new Error("Ghostget execution identity preview transport is malformed");
   return Object.freeze({ adapter, operation, transport });
 }
 function parseCatalogExecutionIdentity(value, request, preview) {
-  assertExactKeys(value, ["ok", "adapters"], [], "Wrench execution identity catalog");
+  assertExactKeys(value, ["ok", "adapters"], [], "Ghostget execution identity catalog");
   if (value.ok !== true || !isUnknownArray(value.adapters)) {
-    throw new Error("Wrench execution identity catalog is malformed");
+    throw new Error("Ghostget execution identity catalog is malformed");
   }
   if (value.adapters.length !== 1) {
-    throw new Error("Wrench execution identity catalog is ambiguous");
+    throw new Error("Ghostget execution identity catalog is ambiguous");
   }
-  const adapterValue = record(value.adapters[0], "Wrench execution identity catalog adapter");
+  const adapterValue = record(value.adapters[0], "Ghostget execution identity catalog adapter");
   assertExactKeys(adapterValue, [
     "id",
     "version",
@@ -13027,17 +13028,17 @@ function parseCatalogExecutionIdentity(value, request, preview) {
     "origins",
     "manifestHash",
     "operations"
-  ], [], "Wrench execution identity catalog adapter");
+  ], [], "Ghostget execution identity catalog adapter");
   const adapter = Object.freeze({
-    id: safeString(adapterValue.id, "Wrench execution identity catalog adapter ID", 64),
-    version: safeString(adapterValue.version, "Wrench execution identity catalog adapter version", 64),
-    hash: digest(adapterValue.manifestHash, "Wrench execution identity catalog adapter hash")
+    id: safeString(adapterValue.id, "Ghostget execution identity catalog adapter ID", 64),
+    version: safeString(adapterValue.version, "Ghostget execution identity catalog adapter version", 64),
+    hash: digest(adapterValue.manifestHash, "Ghostget execution identity catalog adapter hash")
   });
   if (adapter.id !== request.adapterId || adapter.id !== preview.adapter.id || adapter.version !== preview.adapter.version || adapter.hash !== preview.adapter.hash || !isUnknownArray(adapterValue.operations))
-    throw new Error("Wrench execution identity preflights disagreed");
+    throw new Error("Ghostget execution identity preflights disagreed");
   const operations = adapterValue.operations.filter((candidate) => isRecord2(candidate) && candidate.id === request.operationId);
   if (operations.length !== 1) {
-    throw new Error("Wrench execution identity catalog operation is ambiguous");
+    throw new Error("Ghostget execution identity catalog operation is ambiguous");
   }
   const operation = operations[0];
   const commonKeys = [
@@ -13051,7 +13052,7 @@ function parseCatalogExecutionIdentity(value, request, preview) {
     "input"
   ];
   if (operation.risk !== "R1" || operation.transport !== preview.transport)
-    throw new Error("Wrench execution identity preflights disagreed");
+    throw new Error("Ghostget execution identity preflights disagreed");
   const common = Object.freeze({
     adapter,
     operation: preview.operation
@@ -13066,18 +13067,18 @@ function parseCatalogExecutionIdentity(value, request, preview) {
       "requiredScopeSets",
       "coverage",
       "implementation"
-    ], [], "Wrench execution identity provider capability");
-    const catalogSurface = providerSurfaceId(adapterValue.surfaceId, "Wrench execution identity catalog surface");
-    const provider = providerSurfaceId(operation.provider, "Wrench execution identity provider surface");
-    const providerAction = providerOperationName(operation.providerAction, "Wrench execution identity provider action");
-    safeInteger(operation.providerContractVersion, "Wrench execution identity provider contract version", 1, 1e6);
+    ], [], "Ghostget execution identity provider capability");
+    const catalogSurface = providerSurfaceId(adapterValue.surfaceId, "Ghostget execution identity catalog surface");
+    const provider = providerSurfaceId(operation.provider, "Ghostget execution identity provider surface");
+    const providerAction = providerOperationName(operation.providerAction, "Ghostget execution identity provider action");
+    safeInteger(operation.providerContractVersion, "Ghostget execution identity provider contract version", 1, 1e6);
     if (provider !== catalogSurface || providerAction !== preview.operation)
-      throw new Error("Wrench execution identity provider route is malformed");
+      throw new Error("Ghostget execution identity provider route is malformed");
     return Object.freeze({
       ...common,
       schemaVersion: 3,
       transport: "provider-api",
-      providerContractHash: digest(operation.providerContractHash, "Wrench execution identity provider contract hash")
+      providerContractHash: digest(operation.providerContractHash, "Ghostget execution identity provider contract hash")
     });
   }
   if (preview.transport === "web-session-api") {
@@ -13089,18 +13090,18 @@ function parseCatalogExecutionIdentity(value, request, preview) {
       "webSessionContractHash",
       "state",
       "implementation"
-    ], [], "Wrench execution identity web-session capability");
-    const catalogSurface = providerSurfaceId(adapterValue.surfaceId, "Wrench execution identity catalog surface");
-    const site = providerSurfaceId(operation.site, "Wrench execution identity web-session surface");
-    const webSessionAction = providerOperationName(operation.webSessionAction, "Wrench execution identity web-session action");
-    safeInteger(operation.webSessionContractVersion, "Wrench execution identity web-session contract version", 1, 1e6);
+    ], [], "Ghostget execution identity web-session capability");
+    const catalogSurface = providerSurfaceId(adapterValue.surfaceId, "Ghostget execution identity catalog surface");
+    const site = providerSurfaceId(operation.site, "Ghostget execution identity web-session surface");
+    const webSessionAction = providerOperationName(operation.webSessionAction, "Ghostget execution identity web-session action");
+    safeInteger(operation.webSessionContractVersion, "Ghostget execution identity web-session contract version", 1, 1e6);
     if (site !== catalogSurface || webSessionAction !== preview.operation)
-      throw new Error("Wrench execution identity web-session route is malformed");
+      throw new Error("Ghostget execution identity web-session route is malformed");
     return Object.freeze({
       ...common,
       schemaVersion: 4,
       transport: "web-session-api",
-      webSessionContractHash: digest(operation.webSessionContractHash, "Wrench execution identity web-session contract hash")
+      webSessionContractHash: digest(operation.webSessionContractHash, "Ghostget execution identity web-session contract hash")
     });
   }
   if (preview.transport === "local-cli") {
@@ -13113,8 +13114,8 @@ function parseCatalogExecutionIdentity(value, request, preview) {
       "localCliTool",
       "state",
       "implementation"
-    ], [], "Wrench execution identity local CLI capability");
-    const catalogSurface = providerSurfaceId(adapterValue.surfaceId, "Wrench execution identity catalog surface");
+    ], [], "Ghostget execution identity local CLI capability");
+    const catalogSurface = providerSurfaceId(adapterValue.surfaceId, "Ghostget execution identity catalog surface");
     const localCliContract = parseLocalCliContractIdentity({
       surface: operation.surface,
       action: operation.localCliAction,
@@ -13123,7 +13124,7 @@ function parseCatalogExecutionIdentity(value, request, preview) {
       tool: operation.localCliTool
     });
     if (localCliContract.surface !== catalogSurface || localCliContract.action !== preview.operation) {
-      throw new Error("Wrench execution identity local CLI route is malformed");
+      throw new Error("Ghostget execution identity local CLI route is malformed");
     }
     return Object.freeze({
       ...common,
@@ -13137,13 +13138,13 @@ function parseCatalogExecutionIdentity(value, request, preview) {
     "state",
     "reviewedTemplateContractVersion",
     "reviewedTemplateContractHash"
-  ], ["instructions", "reviewedAt", "evidenceSha256", "origin"], "Wrench execution identity reviewed-template capability");
-  safeInteger(operation.reviewedTemplateContractVersion, "Wrench execution identity reviewed-template contract version", 1, Number.MAX_SAFE_INTEGER);
+  ], ["instructions", "reviewedAt", "evidenceSha256", "origin"], "Ghostget execution identity reviewed-template capability");
+  safeInteger(operation.reviewedTemplateContractVersion, "Ghostget execution identity reviewed-template contract version", 1, Number.MAX_SAFE_INTEGER);
   return Object.freeze({
     ...common,
     schemaVersion: 5,
     transport: "reviewed-template-api",
-    reviewedTemplateContractHash: digest(operation.reviewedTemplateContractHash, "Wrench execution identity reviewed-template contract hash")
+    reviewedTemplateContractHash: digest(operation.reviewedTemplateContractHash, "Ghostget execution identity reviewed-template contract hash")
   });
 }
 function observeExecutionIdentity(request, options) {
@@ -13152,7 +13153,7 @@ function observeExecutionIdentity(request, options) {
     projectionIdentityOnly: false,
     preview: true,
     headed: false
-  }), options, "Wrench execution identity preview"), request);
+  }), options, "Ghostget execution identity preview"), request);
   if (preview.transport === "portable-provider-plugin") {
     return Object.freeze({
       adapter: preview.adapter,
@@ -13170,7 +13171,7 @@ function observeExecutionIdentity(request, options) {
       transport: preview.transport
     });
   }
-  return parseCatalogExecutionIdentity(runIdentityCommand(preparedCapabilitiesCommand(request), options, "Wrench execution identity catalog preflight"), request, preview);
+  return parseCatalogExecutionIdentity(runIdentityCommand(preparedCapabilitiesCommand(request), options, "Ghostget execution identity catalog preflight"), request, preview);
 }
 function receiptExecutionIdentity(receipt) {
   const common = Object.freeze({
@@ -13240,59 +13241,59 @@ function runLiveCommandSync(command, options) {
   const stdout = String(result.stdout ?? "");
   const stderr = String(result.stderr ?? "");
   if (stdout.trim().length === 0) {
-    throw new Error(boundedMessage(stderr) || `Wrench live invocation exited ${String(code)}`);
+    throw new Error(boundedMessage(stderr) || `Ghostget live invocation exited ${String(code)}`);
   }
   if (code !== 0 && code !== 3 && code !== 5) {
-    throw new Error(boundedMessage(stderr) || `Wrench live invocation exited ${String(code)}`);
+    throw new Error(boundedMessage(stderr) || `Ghostget live invocation exited ${String(code)}`);
   }
-  return parseOutput(stdout, "Wrench live response");
+  return parseOutput(stdout, "Ghostget live response");
 }
 function parsePublication(value) {
-  const publication = record(value, "Wrench cache publication");
-  assertExactKeys(publication, ["key", "dataRevision", "validatedAt", "dataChangedAt", "disposition"], ["currentDataRevision"], "Wrench cache publication");
+  const publication = record(value, "Ghostget cache publication");
+  assertExactKeys(publication, ["key", "dataRevision", "validatedAt", "dataChangedAt", "disposition"], ["currentDataRevision"], "Ghostget cache publication");
   const disposition = publication.disposition;
   if (disposition !== "created" && disposition !== "changed" && disposition !== "unchanged" && disposition !== "superseded")
-    throw new Error("Wrench cache publication disposition is malformed");
+    throw new Error("Ghostget cache publication disposition is malformed");
   if (disposition === "superseded" !== Object.hasOwn(publication, "currentDataRevision"))
-    throw new Error("Wrench cache publication current revision is malformed");
+    throw new Error("Ghostget cache publication current revision is malformed");
   return Object.freeze({
-    key: digest(publication.key, "Wrench cache publication key"),
-    dataRevision: digest(publication.dataRevision, "Wrench cache publication data revision"),
-    validatedAt: timestamp2(publication.validatedAt, "Wrench cache publication validation time"),
-    dataChangedAt: timestamp2(publication.dataChangedAt, "Wrench cache publication data-change time"),
+    key: digest(publication.key, "Ghostget cache publication key"),
+    dataRevision: digest(publication.dataRevision, "Ghostget cache publication data revision"),
+    validatedAt: timestamp2(publication.validatedAt, "Ghostget cache publication validation time"),
+    dataChangedAt: timestamp2(publication.dataChangedAt, "Ghostget cache publication data-change time"),
     disposition,
     ...publication.currentDataRevision === undefined ? {} : {
-      currentDataRevision: digest(publication.currentDataRevision, "Wrench current cache data revision")
+      currentDataRevision: digest(publication.currentDataRevision, "Ghostget current cache data revision")
     }
   });
 }
 function parseCacheOutcome(value) {
-  const outcome = record(value, "Wrench cache outcome");
+  const outcome = record(value, "Ghostget cache outcome");
   if (outcome.status === "stored") {
-    assertExactKeys(outcome, ["status", "publication"], [], "Wrench cache outcome");
+    assertExactKeys(outcome, ["status", "publication"], [], "Ghostget cache outcome");
     return Object.freeze({ status: "stored", publication: parsePublication(outcome.publication) });
   }
   if (outcome.status === "retained" && outcome.reason === "live-read-failed") {
-    assertExactKeys(outcome, ["status", "reason"], [], "Wrench cache outcome");
+    assertExactKeys(outcome, ["status", "reason"], [], "Ghostget cache outcome");
     return Object.freeze({ status: "retained", reason: "live-read-failed" });
   }
   if (outcome.status === "miss" && outcome.reason === "no-cached-snapshot") {
-    assertExactKeys(outcome, ["status", "reason"], [], "Wrench cache outcome");
+    assertExactKeys(outcome, ["status", "reason"], [], "Ghostget cache outcome");
     return Object.freeze({ status: "miss", reason: "no-cached-snapshot" });
   }
   if (outcome.status === "skipped" && outcome.reason === "auth-subject-unbound") {
-    assertExactKeys(outcome, ["status", "reason"], [], "Wrench cache outcome");
+    assertExactKeys(outcome, ["status", "reason"], [], "Ghostget cache outcome");
     return Object.freeze({ status: "skipped", reason: outcome.reason });
   }
   if (outcome.status === "error") {
-    assertExactKeys(outcome, ["status", "message"], [], "Wrench cache outcome");
-    return Object.freeze({ status: "error", message: safeString(outcome.message, "Wrench cache error", MAX_ERROR_BYTES) });
+    assertExactKeys(outcome, ["status", "message"], [], "Ghostget cache outcome");
+    return Object.freeze({ status: "error", message: safeString(outcome.message, "Ghostget cache error", MAX_ERROR_BYTES) });
   }
-  throw new Error("Wrench cache outcome is malformed");
+  throw new Error("Ghostget cache outcome is malformed");
 }
 function parseReceiptStatus(value) {
   if (value !== "succeeded" && value !== "failed") {
-    throw new Error("Wrench live receipt status is malformed");
+    throw new Error("Ghostget live receipt status is malformed");
   }
   return value;
 }
@@ -13367,7 +13368,7 @@ function parseLocalCliToolIdentity(value) {
     }
     return parsed;
   };
-  const tool = strictRecord(value, "Wrench local CLI tool identity");
+  const tool = strictRecord(value, "Ghostget local CLI tool identity");
   assertExactKeys(tool, [
     "schemaVersion",
     "id",
@@ -13380,58 +13381,58 @@ function parseLocalCliToolIdentity(value) {
     "releaseCommit",
     "releaseManifestSha256",
     "releaseManifestUrl"
-  ], "Wrench local CLI tool identity");
-  const artifactValues = strictArray(tool.artifacts, "Wrench local CLI tool artifact table");
+  ], "Ghostget local CLI tool identity");
+  const artifactValues = strictArray(tool.artifacts, "Ghostget local CLI tool artifact table");
   if (tool.schemaVersion !== 1) {
-    throw new Error("Wrench local CLI tool identity is malformed");
+    throw new Error("Ghostget local CLI tool identity is malformed");
   }
   if (artifactValues.length < 1) {
-    throw new Error("Wrench local CLI tool artifact table is malformed");
+    throw new Error("Ghostget local CLI tool artifact table is malformed");
   }
   const artifacts = artifactValues.map((artifactValue, index) => {
-    const artifact = strictRecord(artifactValue, `Wrench local CLI tool artifact ${index}`);
-    assertExactKeys(artifact, ["platform", "arch", "executableSha256"], ["archiveSha256", "downloadUrl"], `Wrench local CLI tool artifact ${index}`);
-    const archiveSha256 = artifact.archiveSha256 === undefined ? undefined : digest(artifact.archiveSha256, `Wrench local CLI tool artifact ${index} archive hash`);
-    const downloadUrl = artifact.downloadUrl === undefined ? undefined : exactHttpsUrl(artifact.downloadUrl, `Wrench local CLI tool artifact ${index} download URL`);
+    const artifact = strictRecord(artifactValue, `Ghostget local CLI tool artifact ${index}`);
+    assertExactKeys(artifact, ["platform", "arch", "executableSha256"], ["archiveSha256", "downloadUrl"], `Ghostget local CLI tool artifact ${index}`);
+    const archiveSha256 = artifact.archiveSha256 === undefined ? undefined : digest(artifact.archiveSha256, `Ghostget local CLI tool artifact ${index} archive hash`);
+    const downloadUrl = artifact.downloadUrl === undefined ? undefined : exactHttpsUrl(artifact.downloadUrl, `Ghostget local CLI tool artifact ${index} download URL`);
     if (archiveSha256 === undefined !== (downloadUrl === undefined)) {
-      throw new Error("Wrench local CLI tool artifact archive provenance is malformed");
+      throw new Error("Ghostget local CLI tool artifact archive provenance is malformed");
     }
     return Object.freeze({
-      platform: token(artifact.platform, `Wrench local CLI tool artifact ${index} platform`),
-      arch: token(artifact.arch, `Wrench local CLI tool artifact ${index} architecture`),
-      executableSha256: digest(artifact.executableSha256, `Wrench local CLI tool artifact ${index} executable hash`),
+      platform: token(artifact.platform, `Ghostget local CLI tool artifact ${index} platform`),
+      arch: token(artifact.arch, `Ghostget local CLI tool artifact ${index} architecture`),
+      executableSha256: digest(artifact.executableSha256, `Ghostget local CLI tool artifact ${index} executable hash`),
       ...archiveSha256 === undefined ? {} : { archiveSha256 },
       ...downloadUrl === undefined ? {} : { downloadUrl }
     });
   });
   const coordinates = artifacts.map((artifact) => `${artifact.platform}\x00${artifact.arch}`);
   if (new Set(coordinates).size !== coordinates.length || coordinates.some((coordinate, index) => index > 0 && coordinates[index - 1] >= coordinate))
-    throw new Error("Wrench local CLI tool artifact table is not canonical");
-  const sourceUrl = tool.sourceUrl === undefined ? undefined : exactHttpsUrl(tool.sourceUrl, "Wrench local CLI tool source URL");
-  const releaseManifestSha256 = tool.releaseManifestSha256 === undefined ? undefined : digest(tool.releaseManifestSha256, "Wrench local CLI tool release manifest hash");
-  const releaseManifestUrl = tool.releaseManifestUrl === undefined ? undefined : exactHttpsUrl(tool.releaseManifestUrl, "Wrench local CLI tool release manifest URL");
+    throw new Error("Ghostget local CLI tool artifact table is not canonical");
+  const sourceUrl = tool.sourceUrl === undefined ? undefined : exactHttpsUrl(tool.sourceUrl, "Ghostget local CLI tool source URL");
+  const releaseManifestSha256 = tool.releaseManifestSha256 === undefined ? undefined : digest(tool.releaseManifestSha256, "Ghostget local CLI tool release manifest hash");
+  const releaseManifestUrl = tool.releaseManifestUrl === undefined ? undefined : exactHttpsUrl(tool.releaseManifestUrl, "Ghostget local CLI tool release manifest URL");
   if (releaseManifestSha256 === undefined !== (releaseManifestUrl === undefined))
-    throw new Error("Wrench local CLI tool release manifest provenance is malformed");
+    throw new Error("Ghostget local CLI tool release manifest provenance is malformed");
   if (tool.versionScheme !== "semver" && tool.versionScheme !== "opaque") {
-    throw new Error("Wrench local CLI tool version scheme is malformed");
+    throw new Error("Ghostget local CLI tool version scheme is malformed");
   }
   if (typeof tool.version !== "string" || tool.version.length < 1 || tool.version.length > 128)
-    throw new Error("Wrench local CLI tool version is malformed");
+    throw new Error("Ghostget local CLI tool version is malformed");
   const version = tool.version;
   if (!wellFormedVisible(version) || tool.versionScheme === "semver" && !/^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[0-9A-Za-z-]*[A-Za-z-][0-9A-Za-z-]*))*))?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/u.test(version)) {
-    throw new Error("Wrench local CLI tool version is malformed");
+    throw new Error("Ghostget local CLI tool version is malformed");
   }
   const hasReleaseCommit = tool.releaseCommit !== undefined;
-  const releaseCommit = hasReleaseCommit ? safeString(tool.releaseCommit, "Wrench local CLI tool release commit", 40) : undefined;
+  const releaseCommit = hasReleaseCommit ? safeString(tool.releaseCommit, "Ghostget local CLI tool release commit", 40) : undefined;
   if (releaseCommit !== undefined && !/^[a-f0-9]{40}$/u.test(releaseCommit))
-    throw new Error("Wrench local CLI tool release commit is malformed");
-  const implementation = safeString(tool.implementation, "Wrench local CLI tool implementation", 256);
+    throw new Error("Ghostget local CLI tool release commit is malformed");
+  const implementation = safeString(tool.implementation, "Ghostget local CLI tool implementation", 256);
   if (!/^[A-Za-z0-9](?:[A-Za-z0-9._/+:-]{0,254}[A-Za-z0-9])?$/u.test(implementation)) {
-    throw new Error("Wrench local CLI tool implementation is malformed");
+    throw new Error("Ghostget local CLI tool implementation is malformed");
   }
   return Object.freeze({
     schemaVersion: 1,
-    id: token(tool.id, "Wrench local CLI tool ID"),
+    id: token(tool.id, "Ghostget local CLI tool ID"),
     implementation,
     versionScheme: tool.versionScheme,
     version,
@@ -13442,20 +13443,20 @@ function parseLocalCliToolIdentity(value) {
   });
 }
 function parseLocalCliContractIdentity(value) {
-  const identity = record(value, "Wrench local CLI contract identity");
-  assertExactKeys(identity, ["surface", "action", "version", "hash", "tool"], [], "Wrench local CLI contract identity");
-  const surface = providerSurfaceId(identity.surface, "Wrench local CLI surface");
-  const action = providerOperationName(identity.action, "Wrench local CLI action");
+  const identity = record(value, "Ghostget local CLI contract identity");
+  assertExactKeys(identity, ["surface", "action", "version", "hash", "tool"], [], "Ghostget local CLI contract identity");
+  const surface = providerSurfaceId(identity.surface, "Ghostget local CLI surface");
+  const action = providerOperationName(identity.action, "Ghostget local CLI action");
   return Object.freeze({
     surface,
     action,
-    version: safeInteger(identity.version, "Wrench local CLI contract version", 1, 1e6),
-    hash: digest(identity.hash, "Wrench local CLI contract hash"),
+    version: safeInteger(identity.version, "Ghostget local CLI contract version", 1, 1e6),
+    hash: digest(identity.hash, "Ghostget local CLI contract hash"),
     tool: parseLocalCliToolIdentity(identity.tool)
   });
 }
 function parseLiveReceipt(value, request, expectedInputHash) {
-  const receipt = record(value, "Wrench live receipt");
+  const receipt = record(value, "Ghostget live receipt");
   const commonKeys = [
     "schemaVersion",
     "runId",
@@ -13475,66 +13476,66 @@ function parseLiveReceipt(value, request, expectedInputHash) {
     "error"
   ];
   if (receipt.schemaVersion === 2 && receipt.transport === "browser") {
-    assertExactKeys(receipt, commonKeys, [], "Wrench live receipt");
+    assertExactKeys(receipt, commonKeys, [], "Ghostget live receipt");
   } else if (receipt.schemaVersion === 3 && receipt.transport === "provider-api") {
-    assertExactKeys(receipt, [...commonKeys, "providerContractHash"], [], "Wrench live receipt");
+    assertExactKeys(receipt, [...commonKeys, "providerContractHash"], [], "Ghostget live receipt");
   } else if (receipt.schemaVersion === 4 && receipt.transport === "web-session-api") {
-    assertExactKeys(receipt, [...commonKeys, "webSessionContractHash"], [], "Wrench live receipt");
+    assertExactKeys(receipt, [...commonKeys, "webSessionContractHash"], [], "Ghostget live receipt");
   } else if (receipt.schemaVersion === 5 && receipt.transport === "reviewed-template-api") {
-    assertExactKeys(receipt, [...commonKeys, "reviewedTemplateContractHash"], [], "Wrench live receipt");
+    assertExactKeys(receipt, [...commonKeys, "reviewedTemplateContractHash"], [], "Ghostget live receipt");
   } else if (receipt.schemaVersion === 6 && receipt.transport === "portable-provider-plugin") {
-    assertExactKeys(receipt, [...commonKeys, "portablePluginContract"], [], "Wrench live receipt");
+    assertExactKeys(receipt, [...commonKeys, "portablePluginContract"], [], "Ghostget live receipt");
   } else if (receipt.schemaVersion === 7 && receipt.transport === "local-cli") {
-    assertExactKeys(receipt, [...commonKeys, "localCliContract"], [], "Wrench live receipt");
+    assertExactKeys(receipt, [...commonKeys, "localCliContract"], [], "Ghostget live receipt");
   } else {
-    throw new Error("Wrench live receipt schema and transport are malformed");
-  }
-  const adapter = record(receipt.adapter, "Wrench live receipt adapter");
-  const auth = record(receipt.auth, "Wrench live receipt auth");
-  const dispatch = record(receipt.dispatch, "Wrench live receipt dispatch");
-  assertExactKeys(adapter, ["id", "version", "hash"], [], "Wrench live receipt adapter");
-  assertExactKeys(auth, ["id", "hash", "kind"], [], "Wrench live receipt auth");
-  assertExactKeys(dispatch, ["planned", "started", "verified"], [], "Wrench live receipt dispatch");
+    throw new Error("Ghostget live receipt schema and transport are malformed");
+  }
+  const adapter = record(receipt.adapter, "Ghostget live receipt adapter");
+  const auth = record(receipt.auth, "Ghostget live receipt auth");
+  const dispatch = record(receipt.dispatch, "Ghostget live receipt dispatch");
+  assertExactKeys(adapter, ["id", "version", "hash"], [], "Ghostget live receipt adapter");
+  assertExactKeys(auth, ["id", "hash", "kind"], [], "Ghostget live receipt auth");
+  assertExactKeys(dispatch, ["planned", "started", "verified"], [], "Ghostget live receipt dispatch");
   if (receipt.risk !== "R1") {
-    throw new Error("Wrench live receipt risk is malformed");
+    throw new Error("Ghostget live receipt risk is malformed");
   }
   const authKind = auth.kind;
   if (authKind !== "browser-profile" && authKind !== "cookie-source" && authKind !== "cookies-file" && authKind !== "linked-device-store" && authKind !== "oauth-token-file" && authKind !== PUBLIC_WEB_SESSION_AUTHORITY_KIND)
-    throw new Error("Wrench live receipt auth kind is malformed");
+    throw new Error("Ghostget live receipt auth kind is malformed");
   if (receipt.dispatchStarted !== false) {
-    throw new Error("Wrench live receipt dispatch state is malformed");
+    throw new Error("Ghostget live receipt dispatch state is malformed");
   }
-  const planned = safeInteger(dispatch.planned, "Wrench live receipt planned dispatch count", 0, Number.MAX_SAFE_INTEGER);
-  const started = safeInteger(dispatch.started, "Wrench live receipt started dispatch count", 0, Number.MAX_SAFE_INTEGER);
-  const verified = safeInteger(dispatch.verified, "Wrench live receipt verified dispatch count", 0, Number.MAX_SAFE_INTEGER);
+  const planned = safeInteger(dispatch.planned, "Ghostget live receipt planned dispatch count", 0, Number.MAX_SAFE_INTEGER);
+  const started = safeInteger(dispatch.started, "Ghostget live receipt started dispatch count", 0, Number.MAX_SAFE_INTEGER);
+  const verified = safeInteger(dispatch.verified, "Ghostget live receipt verified dispatch count", 0, Number.MAX_SAFE_INTEGER);
   if (planned !== 0 || started !== 0 || verified !== 0) {
-    throw new Error("Wrench live receipt dispatch counts are inconsistent");
+    throw new Error("Ghostget live receipt dispatch counts are inconsistent");
   }
   const status = parseReceiptStatus(receipt.status);
-  const finalOrigin = receipt.finalOrigin === null ? null : safeString(receipt.finalOrigin, "Wrench live receipt final origin", 4096);
-  const error = receipt.error === null ? null : boundedUtf8String(receipt.error, "Wrench live receipt error", MAX_RUN_RECEIPT_ERROR_BYTES);
+  const finalOrigin = receipt.finalOrigin === null ? null : safeString(receipt.finalOrigin, "Ghostget live receipt final origin", 4096);
+  const error = receipt.error === null ? null : boundedUtf8String(receipt.error, "Ghostget live receipt error", MAX_RUN_RECEIPT_ERROR_BYTES);
   if (receipt.planDigest !== null) {
-    throw new Error("Wrench live receipt plan digest is malformed");
+    throw new Error("Ghostget live receipt plan digest is malformed");
   }
-  const startedAt = timestamp2(receipt.startedAt, "Wrench live receipt start time");
-  const finishedAt = timestamp2(receipt.finishedAt, "Wrench live receipt finish time");
+  const startedAt = timestamp2(receipt.startedAt, "Ghostget live receipt start time");
+  const finishedAt = timestamp2(receipt.finishedAt, "Ghostget live receipt finish time");
   if (startedAt > finishedAt) {
-    throw new Error("Wrench live receipt finished before it started");
+    throw new Error("Ghostget live receipt finished before it started");
   }
   const common = Object.freeze({
-    runId: safeString(receipt.runId, "Wrench live receipt run ID", 64),
+    runId: safeString(receipt.runId, "Ghostget live receipt run ID", 64),
     planDigest: null,
     adapter: Object.freeze({
-      id: safeString(adapter.id, "Wrench live receipt adapter ID", 64),
-      version: safeString(adapter.version, "Wrench live receipt adapter version", 64),
-      hash: digest(adapter.hash, "Wrench live receipt adapter hash")
+      id: safeString(adapter.id, "Ghostget live receipt adapter ID", 64),
+      version: safeString(adapter.version, "Ghostget live receipt adapter version", 64),
+      hash: digest(adapter.hash, "Ghostget live receipt adapter hash")
     }),
-    operation: providerOperationName(receipt.operation, "Wrench live receipt operation"),
+    operation: providerOperationName(receipt.operation, "Ghostget live receipt operation"),
     risk: "R1",
-    inputHash: digest(receipt.inputHash, "Wrench live receipt input hash"),
+    inputHash: digest(receipt.inputHash, "Ghostget live receipt input hash"),
     auth: Object.freeze({
-      id: safeString(auth.id, "Wrench live receipt auth ID", 64),
-      hash: digest(auth.hash, "Wrench live receipt auth hash"),
+      id: safeString(auth.id, "Ghostget live receipt auth ID", 64),
+      hash: digest(auth.hash, "Ghostget live receipt auth hash"),
       kind: authKind
     }),
     status,
@@ -13550,18 +13551,18 @@ function parseLiveReceipt(value, request, expectedInputHash) {
     error
   });
   if (common.adapter.id !== request.adapterId || common.operation !== request.operationId)
-    throw new Error("Wrench live receipt route does not match its request");
+    throw new Error("Ghostget live receipt route does not match its request");
   if (common.auth.id !== expectedRequestAuthId(request, common.auth.kind)) {
-    throw new Error("Wrench live receipt auth does not match its request");
+    throw new Error("Ghostget live receipt auth does not match its request");
   }
   if (common.auth.kind === PUBLIC_WEB_SESSION_AUTHORITY_KIND) {
     const authority = publicWebSessionAuthority(request);
     if (receipt.schemaVersion !== 4 || receipt.transport !== "web-session-api" || common.auth.hash !== sha2563(canonicalJson2(authority))) {
-      throw new Error("Wrench live receipt public authority is malformed");
+      throw new Error("Ghostget live receipt public authority is malformed");
     }
   }
   if (common.inputHash !== expectedInputHash) {
-    throw new Error("Wrench live receipt input does not match its request");
+    throw new Error("Ghostget live receipt input does not match its request");
   }
   if (receipt.schemaVersion === 2 && receipt.transport === "browser") {
     return Object.freeze({ ...common, schemaVersion: 2, transport: "browser" });
@@ -13571,7 +13572,7 @@ function parseLiveReceipt(value, request, expectedInputHash) {
       ...common,
       schemaVersion: 3,
       transport: "provider-api",
-      providerContractHash: digest(receipt.providerContractHash, "Wrench live receipt provider contract hash")
+      providerContractHash: digest(receipt.providerContractHash, "Ghostget live receipt provider contract hash")
     });
   }
   if (receipt.schemaVersion === 4 && receipt.transport === "web-session-api") {
@@ -13579,7 +13580,7 @@ function parseLiveReceipt(value, request, expectedInputHash) {
       ...common,
       schemaVersion: 4,
       transport: "web-session-api",
-      webSessionContractHash: digest(receipt.webSessionContractHash, "Wrench live receipt web-session contract hash")
+      webSessionContractHash: digest(receipt.webSessionContractHash, "Ghostget live receipt web-session contract hash")
     });
   }
   if (receipt.schemaVersion === 5 && receipt.transport === "reviewed-template-api") {
@@ -13587,13 +13588,13 @@ function parseLiveReceipt(value, request, expectedInputHash) {
       ...common,
       schemaVersion: 5,
       transport: "reviewed-template-api",
-      reviewedTemplateContractHash: digest(receipt.reviewedTemplateContractHash, "Wrench live receipt reviewed-template contract hash")
+      reviewedTemplateContractHash: digest(receipt.reviewedTemplateContractHash, "Ghostget live receipt reviewed-template contract hash")
     });
   }
   if (receipt.schemaVersion === 6 && receipt.transport === "portable-provider-plugin") {
     const portablePluginContract = parsePortableOperationIdentity(receipt.portablePluginContract);
     if (portablePluginContract.adapterId !== common.adapter.id || portablePluginContract.operation !== common.operation) {
-      throw new Error("Wrench live portable contract route is malformed");
+      throw new Error("Ghostget live portable contract route is malformed");
     }
     return Object.freeze({
       ...common,
@@ -13605,7 +13606,7 @@ function parseLiveReceipt(value, request, expectedInputHash) {
   if (receipt.schemaVersion === 7 && receipt.transport === "local-cli") {
     const localCliContract = parseLocalCliContractIdentity(receipt.localCliContract);
     if (localCliContract.action !== common.operation) {
-      throw new Error("Wrench live local CLI contract route is malformed");
+      throw new Error("Ghostget live local CLI contract route is malformed");
     }
     return Object.freeze({
       ...common,
@@ -13614,30 +13615,30 @@ function parseLiveReceipt(value, request, expectedInputHash) {
       localCliContract
     });
   }
-  throw new Error("Wrench live receipt schema and transport are malformed");
+  throw new Error("Ghostget live receipt schema and transport are malformed");
 }
 function parseLiveResult(value, request, expectedInputHash) {
-  assertExactKeys(value, ["ok", "source", "status", "runId", "replayed", "receipt", "output", "cache"], ["readFailure"], "Wrench live response");
+  assertExactKeys(value, ["ok", "source", "status", "runId", "replayed", "receipt", "output", "cache"], ["readFailure"], "Ghostget live response");
   if (value.source !== "live")
-    throw new Error("Wrench live response has the wrong source");
+    throw new Error("Ghostget live response has the wrong source");
   const receipt = parseLiveReceipt(value.receipt, request, expectedInputHash);
-  const status = safeString(value.status, "Wrench live status", 32);
-  const responseRunId = safeString(value.runId, "Wrench live run ID", 64);
+  const status = safeString(value.status, "Ghostget live status", 32);
+  const responseRunId = safeString(value.runId, "Ghostget live run ID", 64);
   const expectedOk = receipt.status === "succeeded";
   if (status !== receipt.status || receipt.runId !== responseRunId || value.ok !== expectedOk) {
-    throw new Error("Wrench live response is not bound to its receipt");
+    throw new Error("Ghostget live response is not bound to its receipt");
   }
   if (typeof value.replayed !== "boolean" || !("output" in value)) {
-    throw new Error("Wrench live response is incomplete");
+    throw new Error("Ghostget live response is incomplete");
   }
   const cache = parseCacheOutcome(value.cache);
   const cacheMatchesReceipt = receipt.status === "succeeded" ? cache.status === "stored" || cache.status === "error" || cache.status === "skipped" : cache.status === "retained" || cache.status === "miss" || cache.status === "error" || cache.status === "skipped";
   if (!cacheMatchesReceipt) {
-    throw new Error("Wrench live cache outcome is inconsistent with its receipt");
+    throw new Error("Ghostget live cache outcome is inconsistent with its receipt");
   }
   const live = receipt.status === "failed" ? (() => {
     if (value.output !== null) {
-      throw new Error("Wrench failed live response retained an output");
+      throw new Error("Ghostget failed live response retained an output");
     }
     return Object.freeze({
       status: "failed",
@@ -13648,7 +13649,7 @@ function parseLiveResult(value, request, expectedInputHash) {
     });
   })() : (() => {
     if (value.readFailure !== undefined) {
-      throw new Error("Wrench successful live response included a read failure");
+      throw new Error("Ghostget successful live response included a read failure");
     }
     return Object.freeze({
       status: "succeeded",
@@ -13665,22 +13666,22 @@ function parseLiveResult(value, request, expectedInputHash) {
 function assertLiveInvocationFences(request, options, executionIdentityBefore, identityBefore, parsed, activity) {
   const identityAfter = observeProjectionIdentity(request, options);
   if (!projectionIdentitiesMatch(identityBefore, identityAfter)) {
-    throw new Error(`Wrench projection identity changed while ${activity} was running; the live result was discarded`);
+    throw new Error(`Ghostget projection identity changed while ${activity} was running; the live result was discarded`);
   }
   if (!executionIdentitiesMatch(executionIdentityBefore, receiptExecutionIdentity(parsed.live.receipt))) {
-    throw new Error(`Wrench execution identity changed while ${activity} was running; the live result was discarded`);
+    throw new Error(`Ghostget execution identity changed while ${activity} was running; the live result was discarded`);
   }
   if (parsed.live.receipt.auth.hash !== identityBefore.authHash) {
-    throw new Error(`Wrench projection identity changed while ${activity} was running; the live result was discarded`);
+    throw new Error(`Ghostget projection identity changed while ${activity} was running; the live result was discarded`);
   }
   if (identityBefore.status === "unbound") {
     if (parsed.cache.status !== "skipped") {
-      throw new Error(`Wrench projection identity changed while ${activity} was running; the live result was discarded`);
+      throw new Error(`Ghostget projection identity changed while ${activity} was running; the live result was discarded`);
     }
     return;
   }
   if (parsed.cache.status === "skipped" || parsed.cache.status === "stored" && parsed.cache.publication.key !== identityBefore.key) {
-    throw new Error(`Wrench projection identity changed while ${activity} was running; the live result was discarded`);
+    throw new Error(`Ghostget projection identity changed while ${activity} was running; the live result was discarded`);
   }
 }
 function invokeCapabilitySync(request, options = {}) {
@@ -13697,10 +13698,10 @@ function invokeCapabilitySync(request, options = {}) {
   return parsed.live;
 }
 
-// node_modules/@hraness/wrench/dist/index-j1f3cp88.js
-var WRENCH_VERSION = "0.16.8";
+// node_modules/@hraness/ghostget/dist/index-rxvsqb3f.js
+var GHOSTGET_VERSION = "0.17.3";
 
-// node_modules/@hraness/wrench/dist/beeper-client.js
+// node_modules/@hraness/ghostget/dist/beeper-client.js
 import { spawnSync as spawnSync2 } from "child_process";
 import { existsSync as existsSync4 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
@@ -13735,7 +13736,7 @@ var LOCAL_MESSAGE_BUNDLE_V1_ARTIFACTS = Object.freeze([
   Object.freeze({ path: "tombstones.ndjson", kind: "tombstone" })
 ]);
 
-// node_modules/@hraness/wrench/dist/beeper-client.js
+// node_modules/@hraness/ghostget/dist/beeper-client.js
 import { types as nodeTypes4 } from "util";
 var wrench_web_adapter_default = {
   schemaVersion: 6,
@@ -17622,8 +17623,8 @@ var BEEPER_CONTACT_INTERACTION_TRANSFORM = Object.freeze({
 });
 var BEEPER_CONTACT_INTERACTION_IMPLEMENTATION = Object.freeze({
   producer: Object.freeze({
-    package: "@hraness/wrench",
-    version: WRENCH_VERSION
+    package: "@hraness/ghostget",
+    version: GHOSTGET_VERSION
   }),
   officialCli: Object.freeze({
     implementation: BEEPER_CLI_PIN.implementation,
@@ -18144,7 +18145,7 @@ function parseBeeperContactInteractionExportResult(value) {
 var MAX_STDERR_BYTES = 8 * 1024;
 var PROCESS_TIMEOUT_MS = 6 * 60 * 60 * 1000 + 60000;
 function fail22(message) {
-  throw new Error(`Wrench Beeper client: ${message}`);
+  throw new Error(`Ghostget Beeper client: ${message}`);
 }
 function cliSourcePath2() {
   const besideSource = fileURLToPath3(new URL("./cli.ts", import.meta.url));
@@ -18153,11 +18154,11 @@ function cliSourcePath2() {
   const packagedSource = fileURLToPath3(new URL("../src/cli.ts", import.meta.url));
   if (existsSync4(packagedSource))
     return packagedSource;
-  return fail22("the installed Wrench CLI source is unavailable");
+  return fail22("the installed Ghostget CLI source is unavailable");
 }
 function requireBunRuntime2() {
   if (typeof process.versions.bun !== "string") {
-    fail22("@hraness/wrench/beeper requires Bun to run the installed Wrench CLI");
+    fail22("@hraness/ghostget/beeper requires Bun to run the installed Ghostget CLI");
   }
 }
 function plainDataObject(value, label) {
@@ -18391,7 +18392,7 @@ function recordSourceExecutionReceipt(database, input) {
   return { id: Number(inserted.lastInsertRowid), replayed: false };
 }
 
-// src/local/wrench-adapter.ts
+// src/local/ghostget-adapter.ts
 var DIGEST3 = /^[a-f0-9]{64}$/u;
 var RUN_ID = /^(?:[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}|[a-z][a-z0-9._+-]{0,127})$/u;
 function contractSha256(receipt) {
@@ -18419,41 +18420,41 @@ function canonicalTimestamp(value, label) {
 }
 function boundedRunId(value) {
   if (!RUN_ID.test(value))
-    throw new Error("Wrench run ID is invalid");
+    throw new Error("Ghostget run ID is invalid");
   return value;
 }
-function validatePeopleBladeWrenchInvocation(result, request, policy) {
+function validatePeopleBladeGhostgetInvocation(result, request, policy) {
   const receipt = result.receipt;
   if (result.replayed || receipt.status !== "succeeded" || receipt.error !== null || receipt.planDigest !== null || receipt.risk !== "R1" || receipt.dispatchStarted || receipt.dispatch.planned !== 0 || receipt.dispatch.started !== 0 || receipt.dispatch.verified !== 0)
-    throw new Error("Wrench invocation crossed PeopleBlade's read-only execution boundary");
+    throw new Error("Ghostget invocation crossed PeopleBlade's read-only execution boundary");
   if (receipt.adapter.id !== request.adapterId || receipt.adapter.version !== policy.adapterVersion || receipt.operation !== request.operationId || receipt.auth.id !== request.authId || receipt.auth.kind !== policy.authKind || receipt.transport !== policy.transport || receipt.finalOrigin !== policy.finalOrigin)
-    throw new Error("Wrench invocation route identity drifted");
+    throw new Error("Ghostget invocation route identity drifted");
   if (receipt.transport === "local-cli") {
     const expected = policy.localCli;
     const actual = receipt.localCliContract;
     if (expected === undefined || actual.surface !== expected.surface || actual.action !== expected.action || actual.version !== expected.version || actual.tool.id !== expected.toolId || actual.tool.implementation !== expected.toolImplementation || actual.tool.versionScheme !== "semver" || actual.tool.version !== expected.toolVersion || actual.tool.releaseCommit !== expected.toolCommit || actual.tool.releaseManifestSha256 !== expected.toolReleaseManifestSha256)
-      throw new Error("Wrench local CLI contract identity drifted");
+      throw new Error("Ghostget local CLI contract identity drifted");
   } else if (policy.localCli !== undefined) {
-    throw new Error("Wrench invocation did not use the required local CLI route");
+    throw new Error("Ghostget invocation did not use the required local CLI route");
   }
   boundedRunId(receipt.runId);
   const expectedInput = sha256(canonicalJson(request.input));
   if (receipt.inputHash !== expectedInput || !DIGEST3.test(receipt.inputHash)) {
-    throw new Error("Wrench receipt does not bind the exact input");
+    throw new Error("Ghostget receipt does not bind the exact input");
   }
   if (!DIGEST3.test(receipt.adapter.hash))
-    throw new Error("Wrench adapter identity is invalid");
+    throw new Error("Ghostget adapter identity is invalid");
   if (policy.adapterSha256 !== undefined && receipt.adapter.hash !== policy.adapterSha256) {
-    throw new Error("Wrench adapter implementation drifted");
+    throw new Error("Ghostget adapter implementation drifted");
   }
   const contract = contractSha256(receipt);
   if (contract !== policy.contractSha256 || !DIGEST3.test(policy.contractSha256)) {
-    throw new Error("Wrench operation contract identity drifted");
+    throw new Error("Ghostget operation contract identity drifted");
   }
-  const startedAt = canonicalTimestamp(receipt.startedAt, "Wrench start");
-  const finishedAt = canonicalTimestamp(receipt.finishedAt, "Wrench finish");
+  const startedAt = canonicalTimestamp(receipt.startedAt, "Ghostget start");
+  const finishedAt = canonicalTimestamp(receipt.finishedAt, "Ghostget finish");
   if (finishedAt < startedAt)
-    throw new Error("Wrench receipt timing is invalid");
+    throw new Error("Ghostget receipt timing is invalid");
   return {
     output: result.output,
     execution: {
@@ -18470,13 +18471,13 @@ function validatePeopleBladeWrenchInvocation(result, request, policy) {
     }
   };
 }
-function callPeopleBladeWrench(request, invoke = invokeCapabilitySync) {
+function callPeopleBladeGhostget(request, invoke = invokeCapabilitySync) {
   return invoke(request);
 }
 function callPeopleBladeBeeperContactInteractions(request, exportInteractions = exportBeeperContactInteractionsSync) {
   return parseBeeperContactInteractionExportResult(exportInteractions(request));
 }
-function ledgerPeopleBladeWrenchInvocation(database, input) {
+function ledgerPeopleBladeGhostgetInvocation(database, input) {
   const { receipt } = input.execution;
   return recordSourceExecutionReceipt(database, {
     provider: input.provider,
@@ -18542,21 +18543,21 @@ function canonicalTimestamp2(value, label) {
 function readBeeperContactInteractions(request, exportInteractions) {
   const result = callPeopleBladeBeeperContactInteractions(request, exportInteractions);
   if (result.receipt.auth.id !== request.authId || result.receipt.auth.kind !== "linked-device-store" || result.receipt.auth.provider !== "beeper" || result.receipt.operation !== "beeper.export-contact-interactions" || result.receipt.status !== "succeeded" || result.receipt.transport !== "linked-device")
-    throw new Error("Wrench Beeper interaction export route identity drifted");
+    throw new Error("Ghostget Beeper interaction export route identity drifted");
   const expectedBounds = {
     limitChats: request.limitChats ?? null,
     limitMessages: request.limitMessages ?? null,
     maxParticipants: request.maxParticipants ?? null
   };
   if (canonicalJson(result.receipt.bounds) !== canonicalJson(expectedBounds)) {
-    throw new Error("Wrench Beeper interaction export did not bind the requested bounds");
+    throw new Error("Ghostget Beeper interaction export did not bind the requested bounds");
   }
   if (result.receipt.output.summarySha256 !== result.output.integrity.summarySha256 || !DIGEST4.test(result.receipt.integrity.receiptSha256) || !DIGEST4.test(result.receipt.auth.identitySha256))
-    throw new Error("Wrench Beeper interaction export integrity drifted");
+    throw new Error("Ghostget Beeper interaction export integrity drifted");
   canonicalTimestamp2(result.receipt.startedAt, "Beeper interaction export start");
   canonicalTimestamp2(result.receipt.finishedAt, "Beeper interaction export finish");
   if (result.receipt.finishedAt < result.receipt.startedAt) {
-    throw new Error("Wrench Beeper interaction export timing is invalid");
+    throw new Error("Ghostget Beeper interaction export timing is invalid");
   }
   return result;
 }
@@ -18681,10 +18682,10 @@ function projectBeeperContactInteractions(summary2, coordinates) {
 }
 
 // src/local/providers/beeper-compatibility.ts
-var BEEPER_WRENCH_COMPATIBILITY = Object.freeze({
-  wrench: Object.freeze({
-    version: "0.16.8",
-    commit: "b0cf2ecbc1113fcc8ef673a824be475c3d7bbb46"
+var BEEPER_GHOSTGET_COMPATIBILITY = Object.freeze({
+  ghostget: Object.freeze({
+    version: "0.17.3",
+    commit: "67b53cc1917bb09a48b22042cc988c3afbc0aaf8"
   }),
   adapter: Object.freeze({
     id: "beeper-local",
@@ -18721,6 +18722,38 @@ var BEEPER_WRENCH_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",
+  wrenchCommit: "b0cf2ecbc1113fcc8ef673a824be475c3d7bbb46",
+  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 PEOPLEBLADE_010_WRENCH_0150_BEEPER_SOURCE_BINDING_METADATA = Object.freeze({
   transport: "local-cli",
   wrenchVersion: "0.15.0",
@@ -18818,15 +18851,15 @@ var BEEPER_INTERACTION_EXPORT_COMPATIBILITY = Object.freeze({
   sourceVersion: "1.1.0",
   transformId: "beeper-direct-contact-interactions",
   transformVersion: 1,
-  wrenchVersion: BEEPER_WRENCH_COMPATIBILITY.wrench.version,
+  wrenchVersion: BEEPER_GHOSTGET_COMPATIBILITY.ghostget.version,
   platform: "darwin-arm64"
 });
 function beeperSourceBindingMetadata() {
-  const compatibility = BEEPER_WRENCH_COMPATIBILITY;
+  const compatibility = BEEPER_GHOSTGET_COMPATIBILITY;
   return Object.freeze({
     transport: compatibility.adapter.transport,
-    wrenchVersion: compatibility.wrench.version,
-    wrenchCommit: compatibility.wrench.commit,
+    wrenchVersion: compatibility.ghostget.version,
+    wrenchCommit: compatibility.ghostget.commit,
     adapterId: compatibility.adapter.id,
     adapterVersion: compatibility.adapter.version,
     adapterSha256: compatibility.adapter.sha256,
@@ -18844,11 +18877,11 @@ function beeperSourceBindingMetadata() {
 // src/local/providers/beeper.ts
 var PROVIDER4 = "beeper";
 var MODE3 = "wrench-contacts-v1";
-var ADAPTER_ID = BEEPER_WRENCH_COMPATIBILITY.adapter.id;
-var ADAPTER_VERSION = BEEPER_WRENCH_COMPATIBILITY.adapter.version;
-var ADAPTER_SHA256 = BEEPER_WRENCH_COMPATIBILITY.adapter.sha256;
-var CONTRACT_SHA256 = BEEPER_WRENCH_COMPATIBILITY.operations["contacts.list"].sha256;
-var FINAL_ORIGIN = BEEPER_WRENCH_COMPATIBILITY.adapter.origin;
+var ADAPTER_ID = BEEPER_GHOSTGET_COMPATIBILITY.adapter.id;
+var ADAPTER_VERSION = BEEPER_GHOSTGET_COMPATIBILITY.adapter.version;
+var ADAPTER_SHA256 = BEEPER_GHOSTGET_COMPATIBILITY.adapter.sha256;
+var CONTRACT_SHA256 = BEEPER_GHOSTGET_COMPATIBILITY.operations["contacts.list"].sha256;
+var FINAL_ORIGIN = BEEPER_GHOSTGET_COMPATIBILITY.adapter.origin;
 var MAX_ACCOUNTS = 128;
 var MAX_CONTACTS2 = 200;
 var SUBJECT = /^beeper:local:[a-f0-9]{64}$/u;
@@ -19011,22 +19044,22 @@ function parseContact(value, label) {
 }
 function parseBeeperContactPage(value, input, authId) {
   const request = { adapterId: ADAPTER_ID, operationId: "contacts.list", authId, input };
-  const validated = validatePeopleBladeWrenchInvocation(value, request, {
+  const validated = validatePeopleBladeGhostgetInvocation(value, request, {
     adapterVersion: ADAPTER_VERSION,
     adapterSha256: ADAPTER_SHA256,
     authKind: "linked-device-store",
-    transport: BEEPER_WRENCH_COMPATIBILITY.adapter.transport,
+    transport: BEEPER_GHOSTGET_COMPATIBILITY.adapter.transport,
     contractSha256: CONTRACT_SHA256,
     finalOrigin: FINAL_ORIGIN,
     localCli: {
-      surface: BEEPER_WRENCH_COMPATIBILITY.adapter.surface,
+      surface: BEEPER_GHOSTGET_COMPATIBILITY.adapter.surface,
       action: "contacts.list",
-      version: BEEPER_WRENCH_COMPATIBILITY.operations["contacts.list"].version,
-      toolId: BEEPER_WRENCH_COMPATIBILITY.cli.id,
-      toolImplementation: BEEPER_WRENCH_COMPATIBILITY.cli.implementation,
-      toolVersion: BEEPER_WRENCH_COMPATIBILITY.cli.version,
-      toolCommit: BEEPER_WRENCH_COMPATIBILITY.cli.commit,
-      toolReleaseManifestSha256: BEEPER_WRENCH_COMPATIBILITY.cli.releaseManifestSha256
+      version: BEEPER_GHOSTGET_COMPATIBILITY.operations["contacts.list"].version,
+      toolId: BEEPER_GHOSTGET_COMPATIBILITY.cli.id,
+      toolImplementation: BEEPER_GHOSTGET_COMPATIBILITY.cli.implementation,
+      toolVersion: BEEPER_GHOSTGET_COMPATIBILITY.cli.version,
+      toolCommit: BEEPER_GHOSTGET_COMPATIBILITY.cli.commit,
+      toolReleaseManifestSha256: BEEPER_GHOSTGET_COMPATIBILITY.cli.releaseManifestSha256
     }
   });
   const execution = validated.execution;
@@ -19044,7 +19077,7 @@ function parseBeeperContactPage(value, input, authId) {
     "continuation"
   ], "Beeper contact output");
   if (output.provider !== "beeper" || output.operation !== "contacts.list" || output.projection !== "bounded-local-desktop-api" || output.query !== null) {
-    throw new Error("Wrench Beeper output changed projection semantics");
+    throw new Error("Ghostget Beeper output changed projection semantics");
   }
   const accountSubject = text2(output.accountSubject, "Beeper account subject", 128);
   if (!SUBJECT.test(accountSubject))
@@ -19198,7 +19231,7 @@ function sameExecution(left, right) {
   return left.authId === right.authId && left.authSha256 === right.authSha256 && left.adapterSha256 === right.adapterSha256 && left.contractSha256 === right.contractSha256;
 }
 function ledgerBeeperContactRead(database, account, page) {
-  ledgerPeopleBladeWrenchInvocation(database, {
+  ledgerPeopleBladeGhostgetInvocation(database, {
     provider: PROVIDER4,
     accountKey: account,
     capability: "contacts",
@@ -19273,8 +19306,14 @@ function classifyReviewedBeeperPredecessor(value, currentMetadata) {
   if (encoded === canonicalJson(PREVIOUS_WRENCH_0167_BEEPER_SOURCE_BINDING_METADATA)) {
     return "wrench-0.16.7-beeper-2.4";
   }
-  if (encoded === currentMetadata)
+  if (encoded === canonicalJson(PREVIOUS_WRENCH_0168_BEEPER_SOURCE_BINDING_METADATA)) {
     return "wrench-0.16.8-beeper-2.4";
+  }
+  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) {
@@ -19322,7 +19361,7 @@ function rebindBeeperSource(database, options = {}) {
   if (!AUTH_ID.test(authId))
     throw new Error("Beeper auth ID must be lowercase kebab text.");
   const input = { limit: 1 };
-  const invocation = callPeopleBladeWrench({
+  const invocation = callPeopleBladeGhostget({
     adapterId: ADAPTER_ID,
     operationId: "contacts.list",
     authId,
@@ -19353,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");
+  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.");
   }
@@ -19381,11 +19420,11 @@ function rebindBeeperSource(database, options = {}) {
       subjectSha256: next.subjectSha256,
       authSha256: next.authSha256,
       metadataSha256: sha256(currentMetadata),
-      wrenchVersion: BEEPER_WRENCH_COMPATIBILITY.wrench.version,
-      adapterVersion: BEEPER_WRENCH_COMPATIBILITY.adapter.version,
-      adapterSha256: BEEPER_WRENCH_COMPATIBILITY.adapter.sha256,
-      transport: BEEPER_WRENCH_COMPATIBILITY.adapter.transport,
-      contractSha256: BEEPER_WRENCH_COMPATIBILITY.operations["contacts.list"].sha256
+      wrenchVersion: BEEPER_GHOSTGET_COMPATIBILITY.ghostget.version,
+      adapterVersion: BEEPER_GHOSTGET_COMPATIBILITY.adapter.version,
+      adapterSha256: BEEPER_GHOSTGET_COMPATIBILITY.adapter.sha256,
+      transport: BEEPER_GHOSTGET_COMPATIBILITY.adapter.transport,
+      contractSha256: BEEPER_GHOSTGET_COMPATIBILITY.operations["contacts.list"].sha256
     },
     inventory: {
       accounts: inventory.accounts.length,
@@ -19441,7 +19480,7 @@ function syncBeeperContacts(database, options = {}) {
   const limit = options.contactLimit ?? DEFAULT_BEEPER_CONTACT_LIMIT;
   if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_CONTACTS2)
     throw new Error("Beeper contact limit must be from 1 through 200.");
-  const invoke = (input) => callPeopleBladeWrench({
+  const invoke = (input) => callPeopleBladeGhostget({
     adapterId: ADAPTER_ID,
     operationId: "contacts.list",
     authId,
@@ -19705,12 +19744,12 @@ function beeperStats(database) {
 var PROVIDER5 = "beeper";
 var MODE4 = "wrench-targeted-search-v1";
 var ACCEPTANCE_MODE = "search-candidate-acceptance-v1";
-var ADAPTER_ID2 = BEEPER_WRENCH_COMPATIBILITY.adapter.id;
-var ADAPTER_VERSION2 = BEEPER_WRENCH_COMPATIBILITY.adapter.version;
-var ADAPTER_SHA2562 = BEEPER_WRENCH_COMPATIBILITY.adapter.sha256;
-var CONTACTS_SEARCH_CONTRACT_SHA256 = BEEPER_WRENCH_COMPATIBILITY.operations["contacts.search"].sha256;
-var MESSAGING_SEARCH_CONTRACT_SHA256 = BEEPER_WRENCH_COMPATIBILITY.operations["messaging.search"].sha256;
-var FINAL_ORIGIN2 = BEEPER_WRENCH_COMPATIBILITY.adapter.origin;
+var ADAPTER_ID2 = BEEPER_GHOSTGET_COMPATIBILITY.adapter.id;
+var ADAPTER_VERSION2 = BEEPER_GHOSTGET_COMPATIBILITY.adapter.version;
+var ADAPTER_SHA2562 = BEEPER_GHOSTGET_COMPATIBILITY.adapter.sha256;
+var CONTACTS_SEARCH_CONTRACT_SHA256 = BEEPER_GHOSTGET_COMPATIBILITY.operations["contacts.search"].sha256;
+var MESSAGING_SEARCH_CONTRACT_SHA256 = BEEPER_GHOSTGET_COMPATIBILITY.operations["messaging.search"].sha256;
+var FINAL_ORIGIN2 = BEEPER_GHOSTGET_COMPATIBILITY.adapter.origin;
 var MAX_QUERIES = 50;
 var MAX_RESULTS = 20;
 var SHA2562 = /^[a-f0-9]{64}$/u;
@@ -19854,7 +19893,7 @@ function parseConversation(value, label) {
 }
 function parseSearchPage(value, operation, input, authId) {
   const expectedContract = operation === "contacts.search" ? CONTACTS_SEARCH_CONTRACT_SHA256 : MESSAGING_SEARCH_CONTRACT_SHA256;
-  const validated = validatePeopleBladeWrenchInvocation(value, {
+  const validated = validatePeopleBladeGhostgetInvocation(value, {
     adapterId: ADAPTER_ID2,
     operationId: operation,
     authId,
@@ -19863,18 +19902,18 @@ function parseSearchPage(value, operation, input, authId) {
     adapterVersion: ADAPTER_VERSION2,
     adapterSha256: ADAPTER_SHA2562,
     authKind: "linked-device-store",
-    transport: BEEPER_WRENCH_COMPATIBILITY.adapter.transport,
+    transport: BEEPER_GHOSTGET_COMPATIBILITY.adapter.transport,
     contractSha256: expectedContract,
     finalOrigin: FINAL_ORIGIN2,
     localCli: {
-      surface: BEEPER_WRENCH_COMPATIBILITY.adapter.surface,
+      surface: BEEPER_GHOSTGET_COMPATIBILITY.adapter.surface,
       action: operation,
-      version: BEEPER_WRENCH_COMPATIBILITY.operations[operation].version,
-      toolId: BEEPER_WRENCH_COMPATIBILITY.cli.id,
-      toolImplementation: BEEPER_WRENCH_COMPATIBILITY.cli.implementation,
-      toolVersion: BEEPER_WRENCH_COMPATIBILITY.cli.version,
-      toolCommit: BEEPER_WRENCH_COMPATIBILITY.cli.commit,
-      toolReleaseManifestSha256: BEEPER_WRENCH_COMPATIBILITY.cli.releaseManifestSha256
+      version: BEEPER_GHOSTGET_COMPATIBILITY.operations[operation].version,
+      toolId: BEEPER_GHOSTGET_COMPATIBILITY.cli.id,
+      toolImplementation: BEEPER_GHOSTGET_COMPATIBILITY.cli.implementation,
+      toolVersion: BEEPER_GHOSTGET_COMPATIBILITY.cli.version,
+      toolCommit: BEEPER_GHOSTGET_COMPATIBILITY.cli.commit,
+      toolReleaseManifestSha256: BEEPER_GHOSTGET_COMPATIBILITY.cli.releaseManifestSha256
     }
   });
   const execution = validated.execution;
@@ -19892,7 +19931,7 @@ function parseSearchPage(value, operation, input, authId) {
     "completeness"
   ], "Beeper search output");
   if (output.provider !== "beeper" || output.operation !== operation || output.projection !== "bounded-local-desktop-search" || output.searchSemantics !== "provider-fuzzy-candidates")
-    throw new Error("Wrench Beeper search changed projection semantics");
+    throw new Error("Ghostget Beeper search changed projection semantics");
   const accountSubject = text3(output.accountSubject, "Beeper account subject", 128);
   if (!/^beeper:local:[a-f0-9]{64}$/u.test(accountSubject))
     throw new Error("Beeper account subject is invalid");
@@ -20084,7 +20123,7 @@ function stageCandidates(database, snapshot, candidates, query, service) {
 function ledgerSearchExecution(database, account, operation, execution) {
   if (execution.receipt.operation !== operation)
     throw new Error("Beeper search execution operation drifted");
-  return !ledgerPeopleBladeWrenchInvocation(database, {
+  return !ledgerPeopleBladeGhostgetInvocation(database, {
     provider: PROVIDER5,
     accountKey: account,
     capability: "search_people",
@@ -20114,7 +20153,7 @@ function backfillBeeperSearch(database, options) {
     }
     return normalized;
   }));
-  const invoke = (operation, input) => callPeopleBladeWrench({ adapterId: ADAPTER_ID2, operationId: operation, authId, input }, options.invoke);
+  const invoke = (operation, input) => callPeopleBladeGhostget({ adapterId: ADAPTER_ID2, operationId: operation, authId, input }, options.invoke);
   const inventoryInput = { limit: 1 };
   const inventory = parseBeeperContactPage(invoke("contacts.list", inventoryInput), inventoryInput, authId);
   assertSourceBindingCurrent(database, PROVIDER5, {
@@ -20124,7 +20163,7 @@ function backfillBeeperSearch(database, options) {
     metadata: beeperSourceBindingMetadata()
   });
   let executionReceiptsRecorded = 0;
-  if (!ledgerPeopleBladeWrenchInvocation(database, {
+  if (!ledgerPeopleBladeGhostgetInvocation(database, {
     provider: PROVIDER5,
     accountKey: `beeper:binding:${sha256(inventory.accountSubject)}`,
     capability: "contacts",
@@ -20753,7 +20792,7 @@ function parseContact3(value, label, spec) {
   };
 }
 function parsePage(value, input, auth, spec) {
-  const validated = validatePeopleBladeWrenchInvocation(value, {
+  const validated = validatePeopleBladeGhostgetInvocation(value, {
     adapterId: "gmail",
     operationId: "contacts.list",
     authId: auth,
@@ -20766,20 +20805,20 @@ function parsePage(value, input, auth, spec) {
     finalOrigin: null
   });
   const execution = validated.execution;
-  const output = record5(validated.output, "Wrench output");
-  exact3(output, ["provider", "operation", "accountSubject", "contactCollection", "statsIncluded", "contacts", "nextCursor", "totalItems", "statsScanLimit", "statsScope"], "Wrench output");
+  const output = record5(validated.output, "Ghostget output");
+  exact3(output, ["provider", "operation", "accountSubject", "contactCollection", "statsIncluded", "contacts", "nextCursor", "totalItems", "statsScanLimit", "statsScope"], "Ghostget output");
   if (output.provider !== "gmail" || output.operation !== "contacts.list" || output.contactCollection !== spec.id || output.statsIncluded !== false || output.statsScanLimit !== null || output.statsScope !== "not-requested") {
-    throw new Error("Wrench Gmail contact projection drifted");
+    throw new Error("Ghostget Gmail contact projection drifted");
   }
-  const accountSubject = text4(output.accountSubject, "Wrench account subject", 254).toLowerCase();
+  const accountSubject = text4(output.accountSubject, "Ghostget account subject", 254).toLowerCase();
   if (!ACCOUNT.test(accountSubject) || accountSubject !== output.accountSubject)
-    throw new Error("Wrench Gmail account subject is invalid");
+    throw new Error("Ghostget Gmail account subject is invalid");
   const limit = integer5(input.limit, "Google page limit", 1, 100);
-  const contacts = array2(output.contacts, "Wrench contacts", limit).map((entry, index) => parseContact3(entry, `contacts[${index}]`, spec));
+  const contacts = array2(output.contacts, "Ghostget contacts", limit).map((entry, index) => parseContact3(entry, `contacts[${index}]`, spec));
   if (new Set(contacts.map((contact) => contact.resourceName)).size !== contacts.length)
-    throw new Error("Wrench contact page contains duplicate resources");
-  const nextCursor = optionalText2(output.nextCursor, "Wrench next cursor", 4096);
-  const totalItems = output.totalItems === null ? null : integer5(output.totalItems, "Wrench total items", 0, MAX_CONTACTS3);
+    throw new Error("Ghostget contact page contains duplicate resources");
+  const nextCursor = optionalText2(output.nextCursor, "Ghostget next cursor", 4096);
+  const totalItems = output.totalItems === null ? null : integer5(output.totalItems, "Ghostget total items", 0, MAX_CONTACTS3);
   return { collection: spec.id, input, accountSubject, contacts, nextCursor, totalItems, execution };
 }
 function authId(value) {
@@ -20788,11 +20827,11 @@ function authId(value) {
     throw new Error("Google auth ID is invalid");
   return parsed;
 }
-function wrenchGoogleContactsSnapshot(options = {}, collection = "contacts") {
+function ghostgetGoogleContactsSnapshot(options = {}, collection = "contacts") {
   const spec = collectionSpec(collection);
   const auth = authId(options.authId ?? DEFAULT_GOOGLE_AUTH);
   const pageSize = options.pageSize === undefined ? DEFAULT_GOOGLE_PAGE_SIZE : integer5(options.pageSize, "Google page size", 1, 100);
-  const call = (input) => callPeopleBladeWrench({
+  const call = (input) => callPeopleBladeGhostget({
     adapterId: "gmail",
     operationId: "contacts.list",
     authId: auth,
@@ -20815,7 +20854,7 @@ function wrenchGoogleContactsSnapshot(options = {}, collection = "contacts") {
     const page = parsePage(call(input), input, auth, spec);
     const priorExecution = pages.at(-1)?.execution;
     if (priorExecution !== undefined && Date.parse(page.execution.startedAt) < Date.parse(priorExecution.finishedAt)) {
-      throw new Error("Wrench Google page timing moved backwards during pagination");
+      throw new Error("Ghostget Google page timing moved backwards during pagination");
     }
     if (account !== null && page.accountSubject !== account)
       throw new Error("Google account changed during pagination");
@@ -20844,25 +20883,25 @@ function wrenchGoogleContactsSnapshot(options = {}, collection = "contacts") {
     throw new Error("Google contact total is incomplete or exceeds its bound");
   const executions = pages.map((page) => page.execution);
   if (new Set(executions.map((item) => item.runId)).size !== executions.length)
-    throw new Error("Wrench reused a Google run ID");
+    throw new Error("Ghostget reused a Google run ID");
   const first = executions[0];
   for (const item of executions)
     if (item.authId !== first.authId || item.authSha256 !== first.authSha256 || item.adapterVersion !== first.adapterVersion || item.adapterSha256 !== first.adapterSha256 || item.contractSha256 !== first.contractSha256) {
-      throw new Error("Wrench Google execution identity changed during pagination");
+      throw new Error("Ghostget Google execution identity changed during pagination");
     }
   return { schemaVersion: 1, provider: "google-contacts", collection: spec.id, accountSubject: account, authId: auth, pages };
 }
-function wrenchGoogleContactsSnapshots(options = {}) {
-  const snapshots = COLLECTIONS.map((spec) => wrenchGoogleContactsSnapshot(options, spec.id));
+function ghostgetGoogleContactsSnapshots(options = {}) {
+  const snapshots = COLLECTIONS.map((spec) => ghostgetGoogleContactsSnapshot(options, spec.id));
   const first = snapshots[0];
   const executions = snapshots.flatMap((snapshot) => snapshot.pages.map((page) => page.execution));
   if (new Set(executions.map((execution) => execution.runId)).size !== executions.length) {
-    throw new Error("Wrench reused a Google run ID across contact collections");
+    throw new Error("Ghostget reused a Google run ID across contact collections");
   }
   for (const snapshot of snapshots) {
     const execution = snapshot.pages[0].execution;
     if (snapshot.accountSubject !== first.accountSubject || snapshot.authId !== first.authId || execution.authSha256 !== first.pages[0].execution.authSha256 || execution.adapterVersion !== first.pages[0].execution.adapterVersion || execution.adapterSha256 !== first.pages[0].execution.adapterSha256 || execution.contractSha256 !== first.pages[0].execution.contractSha256) {
-      throw new Error("Wrench Google execution identity changed across contact collections");
+      throw new Error("Ghostget Google execution identity changed across contact collections");
     }
   }
   return snapshots;
@@ -21188,10 +21227,10 @@ function importGoogleContactsSnapshots(database, snapshots) {
   }
 }
 function syncGoogleContacts(database, options = {}) {
-  const snapshots = wrenchGoogleContactsSnapshots(options);
+  const snapshots = ghostgetGoogleContactsSnapshots(options);
   for (const snapshot of snapshots)
     for (const page of snapshot.pages) {
-      ledgerPeopleBladeWrenchInvocation(database, {
+      ledgerPeopleBladeGhostgetInvocation(database, {
         provider: PROVIDER6,
         accountKey: snapshot.accountSubject,
         capability: "contacts",
@@ -24570,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)
@@ -24974,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";
@@ -24994,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`);
   }
@@ -25017,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`);
   }
@@ -25041,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;
@@ -25059,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);
@@ -25072,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" };
@@ -25112,8 +25490,8 @@ 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) {
-  const parsed = validatePeopleBladeWrenchInvocation(value, {
+function envelope2(value, input, auth) {
+  const parsed = validatePeopleBladeGhostgetInvocation(value, {
     adapterId: "whatsapp-web",
     operationId: "contacts.list",
     authId: auth,
@@ -25125,25 +25503,25 @@ function envelope(value, input, auth) {
     contractSha256: CONTACTS_CONTRACT_SHA2562,
     finalOrigin: "https://web.whatsapp.com"
   });
-  return { output: record6(parsed.output, "Wrench 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`);
   }
@@ -25156,11 +25534,11 @@ 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("Wrench contact semantics drifted");
+    throw new Error("Ghostget contact semantics drifted");
   }
   const limit = integer6(input.limit, "contact limit", 1, 100);
   if (!Array.isArray(output.contacts) || output.contacts.length > limit)
@@ -25183,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)
@@ -25194,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))
@@ -25203,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"];
@@ -25224,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
   };
@@ -25233,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");
   }
@@ -25271,8 +25649,8 @@ function parseInteractionPage(value, input, auth) {
     execution: parsed.execution
   };
 }
-function wrenchWhatsAppSnapshot(options = {}) {
-  const auth = authId2(options.authId ?? DEFAULT_WHATSAPP_AUTH);
+function ghostgetWhatsAppSnapshot(options = {}) {
+  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;
@@ -25281,7 +25659,7 @@ function wrenchWhatsAppSnapshot(options = {}) {
   const startGeneration = supplied?.generation === undefined ? undefined : generation(supplied.generation);
   if (startCursor === "0" !== (startAnchor === null))
     throw new Error("checkpoint is inconsistent");
-  const call = (_operation, input) => callPeopleBladeWrench({
+  const call = (_operation, input) => callPeopleBladeGhostget({
     adapterId: "whatsapp-web",
     operationId: "contacts.list",
     authId: auth,
@@ -25333,11 +25711,11 @@ function wrenchWhatsAppSnapshot(options = {}) {
     throw new Error("WhatsApp interaction pagination exceeded its bound");
   const executions = [...contactPages, ...interactionPages].map((page) => page.execution);
   if (new Set(executions.map((item) => item.runId)).size !== executions.length)
-    throw new Error("Wrench reused a WhatsApp run ID");
+    throw new Error("Ghostget reused a WhatsApp run ID");
   const first = executions[0];
   for (const item of executions)
     if (item.authId !== first.authId || item.authSha256 !== first.authSha256 || item.adapterVersion !== first.adapterVersion || item.adapterSha256 !== first.adapterSha256 || item.contractSha256 !== first.contractSha256)
-      throw new Error("Wrench execution identity changed during sync");
+      throw new Error("Ghostget execution identity changed during sync");
   return {
     schemaVersion: 2,
     provider: "whatsapp",
@@ -25358,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(*),
@@ -25406,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);
@@ -25461,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");
@@ -25490,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);
@@ -25508,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
@@ -25542,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;
@@ -25559,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;
         }
@@ -25569,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);
       }
@@ -25613,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);
@@ -25641,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 (?,?,?,?,?,?,?,?,?,?,?)
@@ -25650,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) {
@@ -25659,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 = wrenchWhatsAppSnapshot({ ...options, authId: auth, checkpoint: databaseCheckpoint(database, auth) });
+  const snapshot = ghostgetWhatsAppSnapshot({ ...options, authId: auth, checkpoint: databaseCheckpoint(database, auth) });
   for (const page of [...snapshot.contactPages, ...snapshot.interactionPages]) {
-    ledgerPeopleBladeWrenchInvocation(database, {
-      provider: PROVIDER11,
+    ledgerPeopleBladeGhostgetInvocation(database, {
+      provider: PROVIDER12,
       accountKey: snapshot.accountSubject,
       capability: "contact_interactions",
       execution: page.execution,
@@ -25679,7 +26057,7 @@ function syncWhatsAppRelationships(database, options = {}) {
 }
 
 // src/cli/version.ts
-var peoplebladeVersion = "0.2.1";
+var peoplebladeVersion = "0.3.0";
 
 // src/cli/main.ts
 var usage = `PeopleBlade \u2014 local-first contact intelligence
@@ -25719,20 +26097,23 @@ Core:
 
 Sources (append --auto-accept to run identity auto-accept after a successful import):
   contacts sync [--directory PATH] Sync macOS Contacts from the local AddressBook database
-  beeper sync [--auth ID]         Sync connected Beeper accounts sequentially through Wrench
+  beeper sync [--auth ID]         Sync connected Beeper accounts sequentially through Ghostget
     [--with-relationships]         Add body-free lower-bound direct interaction counts
   beeper search --query TEXT      Import bounded fuzzy candidates for explicit identity review
     [--query TEXT ...] [--service NAME ...]
   beeper rebind --confirm         Explicitly transition a verified existing Beeper source binding
   beeper stats                    Show aggregate Beeper realm and completeness statistics
-  google sync [--auth ID]         Sync saved and Other Google Contacts through Wrench
+  google sync [--auth ID]         Sync saved and Other Google Contacts through Ghostget
   google stats                    Show aggregate Google contact statistics by collection
   imessage sync [--database PATH]  Sync content-free iMessage metadata incrementally
   x import ZIP                      Import exact IDs from an official X data archive
   x stats                           Show aggregate X archive statistics
-  x mutuals sync                    Sync X mutuals through Wrench (requires reviewed Wrench capability)
-  whatsapp sync [--auth ID]        Sync WhatsApp through Wrench's linked-device projection
+  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
@@ -26462,17 +26843,17 @@ ${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 Wrench");
-      console.error("Beeper contacts \xB7 discovering connected accounts through Wrench");
+        console.error("Beeper relationships \xB7 deriving a body-free interaction summary through Ghostget");
+      console.error("Beeper contacts \xB7 discovering connected accounts through Ghostget");
       printImport(syncBeeperContacts(database, {
         authId: effectiveAuthId,
         contactLimit,
@@ -26491,23 +26872,23 @@ ${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);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
       if (!confirm)
-        fail3("beeper rebind requires --confirm after reviewing the current Wrench binding, release, and connected-account inventory.");
+        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.");
@@ -26516,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") {
@@ -26552,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);
@@ -26579,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]}`);
@@ -26625,7 +27025,7 @@ ${verification}`) });
       return;
     }
     if (command === "x" && subcommand === "mutuals" && rest[0] === "sync")
-      fail3("X mutual sync is not enabled until Wrench ships a reviewed, bounded x-web mutuals capability. No official X API is required.");
+      fail3("X mutual sync is not enabled until Ghostget ships a reviewed, bounded x-web mutuals capability. No official X API is required.");
     fail3(`Unknown command.
 
 ${usage}`);