@hraness/peopleblade 0.2.1 → 0.2.2

package/dist/peopleblade.js

@@ -4312,13 +4312,13 @@ 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: "google-contacts", command: "google sync", status: "supported", transport: "ghostget", requirement: "Reviewed Gmail/People contacts.list and contact scopes" },
+    { id: "beeper", command: "beeper sync", status: "supported", transport: "ghostget", requirement: "Ghostget 0.17.1, Beeper adapter 2.4.0, CLI 0.6.2; body-free relationships require macOS arm64" },
+    { id: "whatsapp", command: "whatsapp sync", status: "supported", transport: "ghostget", requirement: "Reviewed linked-device contacts.list v2" },
     { id: "linkedin", command: "linkedin import", status: "supported", transport: "official-archive", requirement: "Owner-selected official ZIP; no authenticated browser collection" },
     { id: "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: [
@@ -12341,7 +12341,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 +12360,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 +12388,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 +12485,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 +12535,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 +12693,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 +12723,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 +12762,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 +12783,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 +12814,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 +12896,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 +12905,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 +12915,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 +12934,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 +12962,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 +13007,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 +13027,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 +13051,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 +13066,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 +13089,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 +13113,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 +13123,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 +13137,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 +13152,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 +13170,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 +13240,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 +13367,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 +13380,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 +13442,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 +13475,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 +13550,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 +13571,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 +13579,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 +13587,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 +13605,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 +13614,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 +13648,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 +13665,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 +13697,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-471pfpgn.js
+var GHOSTGET_VERSION = "0.17.1";
 
-// 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 +13735,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 +17622,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 +18144,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 +18153,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 +18391,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 +18419,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 +18470,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 +18542,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 +18681,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.1",
+    commit: "b74ae2ac594bcf07c3def71dc4bb2e5a98c826dd"
   }),
   adapter: Object.freeze({
     id: "beeper-local",
@@ -18721,6 +18721,22 @@ var BEEPER_WRENCH_COMPATIBILITY = Object.freeze({
     commit: "b9c1714410139c2139b597338cd002d785653e85"
   })
 });
+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 +18834,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 +18860,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 +19027,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 +19060,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 +19214,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 +19289,11 @@ 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 === currentMetadata)
+    return "ghostget-0.17.1-beeper-2.4";
   return null;
 }
 function assertStoredRealmInventory(database, sourceBindingId, accounts, storedSha256) {
@@ -19322,7 +19341,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 +19372,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");
   if (sameIdentity && !metadataOnly) {
     throw new Error("Beeper metadata-only rebind requires an exact reviewed same-identity predecessor.");
   }
@@ -19381,11 +19400,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 +19460,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 +19724,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 +19873,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 +19882,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 +19911,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 +20103,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 +20133,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 +20143,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 +20772,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 +20785,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 +20807,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 +20834,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 +20863,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 +21207,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",
@@ -25113,7 +25132,7 @@ 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, {
+  const parsed = validatePeopleBladeGhostgetInvocation(value, {
     adapterId: "whatsapp-web",
     operationId: "contacts.list",
     authId: auth,
@@ -25125,7 +25144,7 @@ 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: record6(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) {
@@ -25160,7 +25179,7 @@ function parseContactPage(value, input, auth) {
   const output = parsed.output;
   exact4(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)
@@ -25271,7 +25290,7 @@ function parseInteractionPage(value, input, auth) {
     execution: parsed.execution
   };
 }
-function wrenchWhatsAppSnapshot(options = {}) {
+function ghostgetWhatsAppSnapshot(options = {}) {
   const auth = authId2(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);
@@ -25281,7 +25300,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 +25352,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",
@@ -25662,9 +25681,9 @@ function syncWhatsAppRelationships(database, options = {}) {
   const auth = authId2(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, {
+    ledgerPeopleBladeGhostgetInvocation(database, {
       provider: PROVIDER11,
       accountKey: snapshot.accountSubject,
       capability: "contact_interactions",
@@ -25679,7 +25698,7 @@ function syncWhatsAppRelationships(database, options = {}) {
 }
 
 // src/cli/version.ts
-var peoplebladeVersion = "0.2.1";
+var peoplebladeVersion = "0.2.2";
 
 // src/cli/main.ts
 var usage = `PeopleBlade \u2014 local-first contact intelligence
@@ -25719,19 +25738,19 @@ 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 stats                    Show aggregate LinkedIn import statistics
   instagram import ZIP              Import an official Instagram JSON archive
@@ -26471,8 +26490,8 @@ ${verification}`) });
         fail3(`Unknown argument: ${options[0]}`);
       const effectiveAuthId = authId3 ?? 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,
@@ -26498,7 +26517,7 @@ ${verification}`) });
       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);
       return;
@@ -26625,7 +26644,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}`);