@hraness/peopleblade 0.3.5 → 0.3.6

package/dist/peopleblade.js

@@ -2,13 +2,573 @@
 // @bun
 var __require = import.meta.require;
 
+// node_modules/@hraness/support-foundation/dist/node.js
+import { randomUUID } from "crypto";
+import { execFile } from "child_process";
+import { constants } from "fs";
+import { mkdir, open, rename, unlink } from "fs/promises";
+import { homedir } from "os";
+import { isAbsolute, join } from "path";
+var SOURCES = ["cli", "agent", "web", "desktop", "skill"];
+var ACCOUNT_ORIGIN = "https://account.hraness.com";
+var UNSAFE_TEXT = /[\p{Cc}\p{Cf}\p{Zl}\p{Zp}]/u;
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function plainText(value, max) {
+  return typeof value === "string" && value.length > 0 && value.length <= max && value.trim() === value && !UNSAFE_TEXT.test(value);
+}
+function parseSupportProfile(value) {
+  if (!isRecord(value) || Object.keys(value).sort().join(",") !== "id,name,updates,valueProposition" || typeof value.id !== "string" || !/^[a-z][a-z0-9-]{0,47}$/.test(value.id) || !plainText(value.name, 80) || !plainText(value.valueProposition, 240) || typeof value.updates !== "boolean")
+    return null;
+  return Object.freeze({
+    id: value.id,
+    name: value.name,
+    valueProposition: value.valueProposition,
+    updates: value.updates
+  });
+}
+function createSupportOffer(profile, source) {
+  const parsed = parseSupportProfile(profile);
+  if (parsed === null || !SOURCES.includes(source)) {
+    throw new TypeError("Invalid support profile or source.");
+  }
+  const destination = new URL("/support", ACCOUNT_ORIGIN);
+  destination.searchParams.set("product", parsed.id);
+  destination.searchParams.set("source", source);
+  const actions = [];
+  if (parsed.updates) {
+    actions.push(Object.freeze({
+      kind: "updates",
+      label: `Get free ${parsed.name} product updates`,
+      url: `${destination.href}#updates`
+    }));
+  }
+  actions.push(Object.freeze({
+    kind: "support",
+    label: "Explore optional paid support",
+    url: `${destination.href}#support`
+  }));
+  return Object.freeze({
+    schemaVersion: "hraness-support-offer-v1",
+    optional: true,
+    product: Object.freeze({ id: parsed.id, name: parsed.name }),
+    valueProposition: parsed.valueProposition,
+    actions: Object.freeze(actions)
+  });
+}
+function renderSupportOffer(offer) {
+  return [
+    `Optional: ${offer.valueProposition}`,
+    ...offer.actions.map((action) => `${action.label}: ${action.url}`),
+    ...offer.emailSuggestion ? [
+      `Suggested email from Git: ${offer.emailSuggestion.email}. You can use it, change it, or skip updates.`
+    ] : [],
+    "Payment is optional. Review any recurring price and confirm in your browser."
+  ].join(`
+`) + `
+`;
+}
+function createSupportProtocol(profile, options) {
+  const command = options.command;
+  if (!Array.isArray(command) || command.length < 1 || command.length > 8 || !Array.from(command).every((part) => plainText(part, 240))) {
+    throw new TypeError("Invalid support command prefix.");
+  }
+  const argv = (...args) => Object.freeze([...command, "support", ...args]);
+  return Object.freeze({
+    schemaVersion: "hraness-support-protocol-v1",
+    optional: true,
+    offer: createSupportOffer(profile, "agent"),
+    commands: Object.freeze({
+      protocol: argv("protocol", "--json"),
+      offer: argv("offer", "--json"),
+      shown: argv("shown", "{invitationId}"),
+      release: argv("release", "{invitationId}"),
+      status: argv("status", "--json"),
+      dismiss: argv("dismiss"),
+      snooze: argv("snooze"),
+      enable: argv("enable")
+    }),
+    invitationIdPlaceholder: "{invitationId}",
+    lifecycle: Object.freeze({
+      eligibility: "Check once after useful successful work with a human-facing closeout. Skip when the person requests no promotions, or the task is unattended or failed.",
+      claim: "Run the offer argv once. An offer reserves presentation for ten minutes; quiet requires no mention. Do not poll during a tool loop.",
+      presentation: "Show one brief optional invitation with the returned value proposition and links on a persistent human-facing message or card, respecting the person's preferences. After that output, run shown with the returned invitation ID.",
+      acknowledgement: "Shown records agent/host-reported persistent output, not proof the human read it or consented. A duplicate acknowledgement does not extend the weekly cooldown; that cooldown requires an acknowledged presentation.",
+      toolOrdering: "Never acknowledge temporary or collapsed progress commentary as the persistent invitation. If the final answer is the only persistent surface and tools must precede it, include the invitation in the final answer and leave its reservation unacknowledged. Without post-output acknowledgement the reservation expires after ten minutes and a later task may offer again; never invent a weekly receipt.",
+      cancellation: "For an unshown invitation, release its ID once. Do not reacquire it in the same task.",
+      failures: "Support and storage failures never change the useful task result. Do not repeat an invitation after an uncertain output or acknowledgement."
+    }),
+    handoff: Object.freeze({
+      emailSuggestion: "Only a returned Git-config suggestion may be offered automatically. It is unverified and editable; offer use, change, or skip. Never search other accounts for an address.",
+      addressSelection: "Selecting an address permits browser prefilling only. Open the returned updates URL unchanged and fill Email address through normal browser input; without browser capability provide the clean link for manual entry.",
+      signup: "Submit only after an explicit signup or confirmation-email request, without asking again when authorized. Inbox confirmation is still required; a sent email is not an active subscription.",
+      payment: "The person reviews current terms and confirms payment in their browser. Never sign up, send mail, authenticate, or purchase in the background."
+    })
+  });
+}
+var WEEK_MS = 7 * 24 * 60 * 60 * 1000;
+var SNOOZE_MS = 30 * 24 * 60 * 60 * 1000;
+var RESERVATION_MS = 10 * 60 * 1000;
+var DISCOVERY_MS = 10 * 60 * 1000;
+var OUTPUT_TIMEOUT_MS = 500;
+var pendingOutputs = new WeakMap;
+var STATE_SCHEMA = "hraness-support-state-v1";
+var RESULT_SCHEMA = "hraness-support-result-v1";
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+function record(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function timestamp(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value >= 0;
+}
+function parseState(value) {
+  if (!record(value) || Object.keys(value).sort().join(",") !== "lastShownAt,optedOut,reservation,schemaVersion,snoozedUntil" || value.schemaVersion !== STATE_SCHEMA || typeof value.optedOut !== "boolean" || value.snoozedUntil !== null && !timestamp(value.snoozedUntil) || value.lastShownAt !== null && !timestamp(value.lastShownAt)) {
+    throw new Error("Invalid support preference state.");
+  }
+  const reservation = value.reservation;
+  if (reservation !== null && (!record(reservation) || Object.keys(reservation).sort().join(",") !== "createdAt,expiresAt,id" || typeof reservation.id !== "string" || !UUID.test(reservation.id) || !timestamp(reservation.createdAt) || !timestamp(reservation.expiresAt) || reservation.expiresAt !== reservation.createdAt + RESERVATION_MS)) {
+    throw new Error("Invalid support invitation reservation.");
+  }
+  return value;
+}
+function initialState() {
+  return { schemaVersion: STATE_SCHEMA, optedOut: false, snoozedUntil: null, lastShownAt: null, reservation: null };
+}
+function errorCode(error) {
+  return record(error) && typeof error.code === "string" ? error.code : undefined;
+}
+function currentTime(options) {
+  const now = options.now ?? Date.now();
+  if (!timestamp(now) || now > Number.MAX_SAFE_INTEGER - SNOOZE_MS)
+    throw new Error("Invalid support clock.");
+  return now;
+}
+function stateDirectory(options) {
+  if (options.stateDirectory !== undefined)
+    return options.stateDirectory;
+  const env = options.env ?? process.env;
+  const xdg = env.XDG_STATE_HOME;
+  return join(xdg && isAbsolute(xdg) ? xdg : join(homedir(), ".local", "state"), "hraness", "support");
+}
+function environmentSuppresses(options) {
+  const env = options.env ?? process.env;
+  if (audience(options) === "off")
+    return true;
+  if (["off", "false", "0"].includes(env.HRANESS_SUPPORT?.trim().toLowerCase() ?? ""))
+    return true;
+  return ["CI", "CONTINUOUS_INTEGRATION", "GITHUB_ACTIONS", "TF_BUILD", "BUILD_NUMBER", "TEAMCITY_VERSION", "JENKINS_URL"].some((name) => {
+    const value = env[name]?.trim().toLowerCase();
+    return value !== undefined && value !== "" && value !== "false" && value !== "0";
+  });
+}
+function audience(options) {
+  const value = options.audience ?? (options.env ?? process.env).HRANESS_SUPPORT_AUDIENCE;
+  if (value === undefined)
+    return "agent";
+  return value === "agent" || value === "human" || value === "off" ? value : "off";
+}
+async function withGitEmailSuggestion(offer, options) {
+  const env = options.env ?? process.env;
+  if (!offer.actions.some((action) => action.kind === "updates") || options.gitEmail === false || ["off", "false", "0"].includes(env.HRANESS_SUPPORT_EMAIL?.trim().toLowerCase() ?? ""))
+    return offer;
+  const email = await new Promise((resolve) => {
+    execFile("git", ["config", "--get", "user.email"], {
+      cwd: options.cwd,
+      env,
+      encoding: "utf8",
+      timeout: 500,
+      killSignal: "SIGKILL",
+      maxBuffer: 1024,
+      windowsHide: true
+    }, (error, stdout) => {
+      if (error) {
+        resolve(null);
+        return;
+      }
+      const candidate = stdout.trim();
+      const parts = candidate.split("@");
+      const local = parts[0] ?? "";
+      const domain = parts[1]?.toLowerCase() ?? "";
+      const valid = parts.length === 2 && candidate.length <= 254 && local.length <= 64 && /^[A-Za-z0-9!#$%&'*+/=?^_`{|}~.-]+$/u.test(local) && !local.startsWith(".") && !local.endsWith(".") && !local.includes("..") && /^[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?(?:\.[A-Za-z0-9](?:[A-Za-z0-9-]{0,61}[A-Za-z0-9])?)+$/u.test(domain) && domain !== "noreply.github.com" && !domain.endsWith(".noreply.github.com") && !/^(?:no-?reply|do-?not-?reply)$/iu.test(local);
+      resolve(valid ? candidate : null);
+    });
+  }).catch(() => null);
+  return email === null ? offer : Object.freeze({
+    ...offer,
+    emailSuggestion: Object.freeze({ email, source: "git-config", verified: false })
+  });
+}
+async function readLocalJson(path) {
+  let handle;
+  try {
+    handle = await open(path, constants.O_RDONLY | constants.O_NOFOLLOW | constants.O_NONBLOCK);
+    const stat = await handle.stat();
+    if (!stat.isFile() || stat.size > 4096)
+      throw new Error("Invalid support state file.");
+    const buffer = Buffer.alloc(4097);
+    let length = 0;
+    while (length < buffer.length) {
+      const read = await handle.read(buffer, length, buffer.length - length, null);
+      if (read.bytesRead === 0)
+        break;
+      length += read.bytesRead;
+    }
+    if (length > 4096)
+      throw new Error("Oversized support state file.");
+    return JSON.parse(buffer.subarray(0, length).toString("utf8"));
+  } catch (error) {
+    if (errorCode(error) === "ENOENT")
+      return;
+    throw error;
+  } finally {
+    await handle?.close();
+  }
+}
+async function writeLocalJson(directory, name, value) {
+  const temporary = join(directory, `${name}.${randomUUID()}.tmp`);
+  try {
+    const handle = await open(temporary, "wx", 384);
+    try {
+      await handle.writeFile(`${JSON.stringify(value)}
+`, "utf8");
+      await handle.sync();
+    } finally {
+      await handle.close();
+    }
+    await rename(temporary, join(directory, name));
+  } finally {
+    await unlink(temporary).catch(() => {});
+  }
+}
+async function withState(options, action) {
+  let lock;
+  let lockPath;
+  try {
+    const directory = stateDirectory(options);
+    await mkdir(directory, { recursive: true, mode: 448 });
+    lockPath = join(directory, "state.lock");
+    try {
+      lock = await open(lockPath, "wx", 384);
+    } catch (error) {
+      return { ok: false, reason: errorCode(error) === "EEXIST" ? "busy" : "state-unavailable" };
+    }
+    const raw = await readLocalJson(join(directory, "state.json"));
+    const state = raw === undefined ? initialState() : parseState(raw);
+    const result = await action(state, directory);
+    if (result.changed)
+      await writeLocalJson(directory, "state.json", state);
+    return { ok: true, value: result.value };
+  } catch {
+    return { ok: false, reason: "state-unavailable" };
+  } finally {
+    if (lock !== undefined) {
+      await lock.close().catch(() => {});
+      if (lockPath !== undefined)
+        await unlink(lockPath).catch(() => {});
+    }
+  }
+}
+function suppression(state, now) {
+  if (state.optedOut)
+    return "dismissed";
+  if (state.snoozedUntil !== null && now < state.snoozedUntil)
+    return "snoozed";
+  if (state.lastShownAt !== null && now < state.lastShownAt + WEEK_MS)
+    return "cooldown";
+  if (state.reservation !== null && now < state.reservation.expiresAt)
+    return "reserved";
+  return null;
+}
+async function claimInvitation(options) {
+  if (environmentSuppresses(options))
+    return { kind: "quiet", reason: "environment" };
+  let now;
+  try {
+    now = currentTime(options);
+  } catch {
+    return { kind: "quiet", reason: "state-unavailable" };
+  }
+  const result = await withState(options, async (state, directory) => {
+    const reason = suppression(state, now);
+    if (reason !== null)
+      return { value: { kind: "quiet", reason } };
+    await readPresentationReceipt(directory);
+    const id = randomUUID();
+    state.reservation = { id, createdAt: now, expiresAt: now + RESERVATION_MS };
+    return { value: { kind: "offer", id }, changed: true };
+  });
+  return result.ok ? result.value : { kind: "quiet", reason: result.reason };
+}
+async function acknowledgeInvitation(id, options) {
+  const now = currentTime(options);
+  return withState(options, (state, directory) => acknowledgeState(state, directory, id, now));
+}
+async function readPresentationReceipt(directory) {
+  const receipt = await readLocalJson(join(directory, "presentation.json"));
+  if (receipt !== undefined && (!record(receipt) || Object.keys(receipt).sort().join(",") !== "id,schemaVersion,shownAt" || receipt.schemaVersion !== "hraness-support-presentation-v1" || typeof receipt.id !== "string" || !UUID.test(receipt.id) || !timestamp(receipt.shownAt)))
+    throw new Error("Invalid presentation receipt.");
+  return receipt;
+}
+async function acknowledgeState(state, directory, id, now) {
+  const receipt = await readPresentationReceipt(directory);
+  const reservation = state.reservation;
+  if (state.optedOut || state.snoozedUntil !== null && now < state.snoozedUntil)
+    return { value: false };
+  if (reservation === null) {
+    return { value: receipt !== undefined && receipt.id === id && receipt.shownAt === state.lastShownAt && timestamp(receipt.shownAt) && now >= receipt.shownAt && now < receipt.shownAt + WEEK_MS };
+  }
+  if (reservation.id !== id || now < reservation.createdAt || now >= reservation.expiresAt)
+    return { value: false };
+  await writeLocalJson(directory, "presentation.json", {
+    schemaVersion: "hraness-support-presentation-v1",
+    id,
+    shownAt: now
+  });
+  state.lastShownAt = now;
+  state.reservation = null;
+  return { value: true, changed: true };
+}
+async function presentInvitation(id, message, sink, options) {
+  const now = currentTime(options);
+  let output = false;
+  await withState(options, async (state, directory) => {
+    const reservation = state.reservation;
+    if (state.optedOut || state.snoozedUntil !== null && now < state.snoozedUntil || reservation?.id !== id || now < reservation.createdAt || now >= reservation.expiresAt)
+      return { value: false };
+    await readPresentationReceipt(directory);
+    output = await writeOutput(sink, message);
+    if (!output)
+      return { value: false };
+    return acknowledgeState(state, directory, id, now);
+  });
+  return output;
+}
+async function releaseInvitation(id, options) {
+  return withState(options, (state) => {
+    if (state.reservation?.id !== id)
+      return { value: false };
+    state.reservation = null;
+    return { value: true, changed: true };
+  });
+}
+async function claimDiscovery(options) {
+  const now = currentTime(options);
+  const result = await withState(options, async (state, directory) => {
+    if (suppression(state, now) !== null)
+      return { value: false };
+    await readPresentationReceipt(directory);
+    const discovery = await readLocalJson(join(directory, "discovery.json"));
+    if (discovery !== undefined) {
+      if (!record(discovery) || Object.keys(discovery).sort().join(",") !== "lastAttemptAt,schemaVersion" || discovery.schemaVersion !== "hraness-support-discovery-state-v1" || !timestamp(discovery.lastAttemptAt))
+        throw new Error("Invalid discovery state.");
+      if (now < discovery.lastAttemptAt + DISCOVERY_MS)
+        return { value: false };
+    }
+    await writeLocalJson(directory, "discovery.json", {
+      schemaVersion: "hraness-support-discovery-state-v1",
+      lastAttemptAt: now
+    });
+    return { value: true };
+  });
+  return result.ok && result.value;
+}
+function json(value) {
+  return `${JSON.stringify(value)}
+`;
+}
+function success(value) {
+  return { exitCode: 0, stdout: json(value), stderr: "" };
+}
+function failure(message, exitCode = 1) {
+  return { exitCode, stdout: "", stderr: `${message}
+` };
+}
+async function runSupportCommand(profile, args = [], options = {}) {
+  try {
+    if (args.length === 2 && args[0] === "protocol" && args[1] === "--json") {
+      return success(createSupportProtocol(profile, { command: options.command ?? [] }));
+    }
+    const offer = createSupportOffer(profile, args[0] === "offer" ? "agent" : "cli");
+    if (args.length === 0)
+      return { exitCode: 0, stdout: renderSupportOffer(await withGitEmailSuggestion(offer, options)), stderr: "" };
+    if (args.length === 1 && args[0] === "--json")
+      return success(await withGitEmailSuggestion(offer, options));
+    if (args.length === 2 && args[0] === "offer" && args[1] === "--json") {
+      const claim = await claimInvitation(options);
+      return success(claim.kind === "offer" ? { schemaVersion: RESULT_SCHEMA, kind: "offer", invitation: { id: claim.id, ...await withGitEmailSuggestion(offer, options) } } : { schemaVersion: RESULT_SCHEMA, ...claim });
+    }
+    if (args.length === 2 && args[0] === "shown") {
+      if (!UUID.test(args[1] ?? ""))
+        return failure("Support invitation is invalid or expired.", 2);
+      const result = await acknowledgeInvitation(args[1], options);
+      if (!result.ok)
+        return failure(`Support preferences are unavailable (${result.reason}).`);
+      if (!result.value)
+        return failure("Support invitation is invalid or expired.", 2);
+      return success({ schemaVersion: RESULT_SCHEMA, kind: "shown" });
+    }
+    if (args.length === 2 && args[0] === "release") {
+      if (!UUID.test(args[1] ?? ""))
+        return failure("Support invitation is invalid or expired.", 2);
+      const result = await releaseInvitation(args[1], options);
+      if (!result.ok)
+        return failure(`Support preferences are unavailable (${result.reason}).`);
+      if (!result.value)
+        return failure("Support invitation is invalid or expired.", 2);
+      return success({ schemaVersion: RESULT_SCHEMA, kind: "released" });
+    }
+    if (args.length === 2 && args[0] === "status" && args[1] === "--json") {
+      const result = await withState(options, (state) => ({ value: {
+        schemaVersion: RESULT_SCHEMA,
+        kind: "status",
+        environmentSuppressed: environmentSuppresses(options),
+        optedOut: state.optedOut,
+        snoozedUntil: state.snoozedUntil,
+        lastShownAt: state.lastShownAt,
+        cooldownUntil: state.lastShownAt === null ? null : state.lastShownAt + WEEK_MS,
+        reservationExpiresAt: state.reservation?.expiresAt ?? null
+      } }));
+      return result.ok ? success(result.value) : failure(`Support preferences are unavailable (${result.reason}).`);
+    }
+    const command = args[0];
+    if (args.length === 1 && (command === "dismiss" || command === "snooze" || command === "enable")) {
+      const now = currentTime(options);
+      const result = await withState(options, (state) => {
+        state.reservation = null;
+        if (command === "dismiss")
+          state.optedOut = true;
+        else if (command === "snooze")
+          state.snoozedUntil = now + SNOOZE_MS;
+        else {
+          state.optedOut = false;
+          state.snoozedUntil = null;
+        }
+        return { value: { schemaVersion: RESULT_SCHEMA, kind: command === "dismiss" ? "dismissed" : command === "snooze" ? "snoozed" : "enabled" }, changed: true };
+      });
+      return result.ok ? success(result.value) : failure(`Support preferences are unavailable (${result.reason}).`);
+    }
+    return failure("Usage: support [--json | protocol --json | offer --json | shown <id> | release <id> | dismiss | snooze | enable | status --json]", 2);
+  } catch {
+    return failure("Support configuration is invalid or unavailable.", 2);
+  }
+}
+async function writeOutput(sink, message) {
+  if (pendingOutputs.has(sink))
+    return false;
+  const operation = Symbol();
+  pendingOutputs.set(sink, operation);
+  return new Promise((resolve) => {
+    let settled = false;
+    let timer;
+    const stream = typeof sink.on === "function" && typeof sink.removeListener === "function";
+    const cleanup = () => {
+      try {
+        sink.removeListener?.("error", onError);
+      } catch {}
+      try {
+        sink.removeListener?.("close", onClose);
+      } catch {}
+      if (pendingOutputs.get(sink) === operation)
+        pendingOutputs.delete(sink);
+    };
+    const settle = (ok) => {
+      if (settled)
+        return;
+      settled = true;
+      clearTimeout(timer);
+      resolve(ok);
+    };
+    const finished = (ok) => {
+      settle(ok);
+      if (stream)
+        setTimeout(cleanup, 0).unref();
+      else
+        cleanup();
+    };
+    const onError = () => finished(false);
+    const onClose = () => finished(false);
+    timer = setTimeout(() => {
+      settle(false);
+    }, OUTPUT_TIMEOUT_MS);
+    try {
+      if (stream) {
+        sink.on("error", onError);
+        sink.on("close", onClose);
+        sink.write(message, (error) => finished(!error));
+      } else {
+        const result = sink.write(message);
+        Promise.resolve(result).then((value) => finished(value !== false), () => finished(false));
+      }
+    } catch {
+      finished(false);
+    }
+  });
+}
+async function maybeShowSupportInvitation(profile, options) {
+  try {
+    const stderr = options.stderr ?? process.stderr;
+    const target = audience(options);
+    if (!options.usefulResult || target === "off" || environmentSuppresses(options))
+      return false;
+    if (target === "agent") {
+      const protocol = createSupportProtocol(profile, { command: options.command ?? [] });
+      if (!await claimDiscovery(options))
+        return false;
+      return await writeOutput(stderr, json({
+        schemaVersion: "hraness-support-discovery-v1",
+        optional: true,
+        product: protocol.offer.product,
+        protocol: protocol.commands.protocol,
+        message: `${protocol.offer.actions.some((action) => action.kind === "updates") ? "Optional product updates and support are available." : "Optional support is available."} The local protocol describes choices and human handoff; it does not change the requested task.`
+      }));
+    }
+    if (stderr.isTTY !== true)
+      return false;
+    const offer = createSupportOffer(profile, "cli");
+    const claim = await claimInvitation(options);
+    if (claim.kind !== "offer")
+      return false;
+    const message = renderSupportOffer(await withGitEmailSuggestion(offer, options));
+    return await presentInvitation(claim.id, message, stderr, options);
+  } catch {
+    return false;
+  }
+}
+
+// src/cli/support.ts
+var supportProfile = {
+  id: "peopleblade",
+  name: "PeopleBlade",
+  valueProposition: "Support ongoing development of tools for understanding and maintaining your contact book.",
+  updates: true
+};
+function standaloneSupportEnvironment() {
+  const env = { ...process.env };
+  process.env.HRANESS_SUPPORT_AUDIENCE = "off";
+  return env;
+}
+async function runProductSupportCommand(args, output, options = {}) {
+  const result = await runSupportCommand(supportProfile, args, { command: ["peopleblade"], ...options });
+  if (result.stdout !== "")
+    output.stdout(result.stdout);
+  if (result.stderr !== "")
+    output.stderr(result.stderr);
+  return result.exitCode;
+}
+async function showProductSupportInvitation(options = {}) {
+  try {
+    await maybeShowSupportInvitation(supportProfile, { usefulResult: true, command: ["peopleblade"], ...options });
+  } catch {}
+}
+
 // src/cli/main.ts
-import { closeSync as closeSync9, constants as constants9, existsSync as existsSync6, fstatSync as fstatSync8, mkdirSync as mkdirSync3, openSync as openSync9, readSync as readSync3 } from "fs";
-import { join as join7, resolve as resolve7 } from "path";
+import { closeSync as closeSync9, constants as constants10, existsSync as existsSync5, fstatSync as fstatSync8, mkdirSync as mkdirSync3, openSync as openSync9, readSync as readSync3 } from "fs";
+import { join as join8, resolve as resolve7 } from "path";
 import { ZodError } from "zod";
 
 // src/local/contacts.ts
-import { closeSync, constants, fstatSync, openSync, readFileSync } from "fs";
+import { closeSync, constants as constants2, fstatSync, openSync, readFileSync } from "fs";
 import { z as z3 } from "zod";
 
 // src/lib/contracts.ts
@@ -3982,7 +4542,7 @@ function currentResearchContext(database, requestedPersonId) {
   };
 }
 function readResearchFile(path) {
-  const descriptor = openSync(path, constants.O_RDONLY | (constants.O_NOFOLLOW ?? 0));
+  const descriptor = openSync(path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
   try {
     const before = fstatSync(descriptor);
     const uid = typeof process.getuid === "function" ? process.getuid() : null;
@@ -4347,7 +4907,7 @@ var peoplebladeCapabilities = Object.freeze({
 // src/local/workspace.ts
 import { randomBytes } from "crypto";
 import { chmodSync, lstatSync, mkdtempSync, rmdirSync, unlinkSync, writeFileSync } from "fs";
-import { join } from "path";
+import { join as join2 } from "path";
 import { tmpdir } from "os";
 import { z as z5 } from "zod";
 
@@ -4390,7 +4950,7 @@ function previewNoteMarkdown(source) {
 }
 
 // src/local/note-revisions.ts
-var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
+var UUID2 = /^[0-9a-f]{8}-[0-9a-f]{4}-[1-8][0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/u;
 var SHA256 = /^[0-9a-f]{64}$/u;
 var UNSUPPORTED_CONTROLS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/u;
 
@@ -4410,7 +4970,7 @@ function positiveInteger(value, label) {
     invalid(`${label} must be a positive safe integer.`);
 }
 function validatePersonNoteMutationRequest(requestId, expectedContextSha256) {
-  if (typeof requestId !== "string" || !UUID.test(requestId))
+  if (typeof requestId !== "string" || !UUID2.test(requestId))
     invalid("Request ID must be a canonical lowercase UUID.");
   if (typeof expectedContextSha256 !== "string" || !SHA256.test(expectedContextSha256))
     invalid("Expected context must be a SHA-256 digest.");
@@ -4581,7 +5141,7 @@ function listPersonNoteRevisions(database, input) {
 }
 
 // src/local/notes.ts
-import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync2 } from "fs";
+import { closeSync as closeSync2, constants as constants3, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync2 } from "fs";
 
 // src/local/identity-attestations.ts
 var MODE = "identity-attestation-v1";
@@ -4600,11 +5160,11 @@ function identityAttestationReviewsConflicts(metadataJson, evidence, canonicalTa
   }
   if (metadata === null || Array.isArray(metadata) || typeof metadata !== "object")
     return false;
-  const record = metadata;
-  if (record.source !== "explicit-user-attestation" || record.conflictOverride !== true || record.confirmedPersonId !== canonicalTargetPersonId || !Array.isArray(record.reviewedConflictingMethods))
+  const record2 = metadata;
+  if (record2.source !== "explicit-user-attestation" || record2.conflictOverride !== true || record2.confirmedPersonId !== canonicalTargetPersonId || !Array.isArray(record2.reviewedConflictingMethods))
     return false;
   try {
-    return canonicalJson(record.reviewedConflictingMethods) === canonicalJson(evidence);
+    return canonicalJson(record2.reviewedConflictingMethods) === canonicalJson(evidence);
   } catch {
     return false;
   }
@@ -5454,10 +6014,10 @@ function metadataObject(value) {
   if (value === null || Array.isArray(value) || typeof value !== "object") {
     fail("Note metadata must be a JSON object.");
   }
-  const json = canonicalJson(value);
-  if (Buffer.byteLength(json, "utf8") > MAX_METADATA_BYTES)
+  const json2 = canonicalJson(value);
+  if (Buffer.byteLength(json2, "utf8") > MAX_METADATA_BYTES)
     fail("Note metadata exceeds 64 KiB.");
-  return JSON.parse(json);
+  return JSON.parse(json2);
 }
 function canonicalPersonId2(database, personId) {
   const row = database.query("SELECT canonical_person_id FROM person_identity_components WHERE person_id=?").get(personId);
@@ -5897,16 +6457,16 @@ function searchPersonNotes(database, args) {
     return mapEffectiveNotes(database, rows);
   }).deferred();
 }
-function recordValue(record, ...keys) {
+function recordValue(record2, ...keys) {
   for (const key of keys) {
-    if (key in record)
-      return record[key];
+    if (key in record2)
+      return record2[key];
   }
-  const lower = new Map(Object.keys(record).map((key) => [key.toLocaleLowerCase("en-US"), key]));
+  const lower = new Map(Object.keys(record2).map((key) => [key.toLocaleLowerCase("en-US"), key]));
   for (const key of keys) {
     const actual = lower.get(key.toLocaleLowerCase("en-US"));
     if (actual !== undefined)
-      return record[actual];
+      return record2[actual];
   }
   return;
 }
@@ -5936,12 +6496,12 @@ function parseAttendee(value) {
       return { name: null, email: null, phone: phone2 };
     return { name: cleanText(trimmed, MAX_TITLE_CHARS), email: null, phone: null };
   }
-  const record = asRecord(value);
-  if (record === null)
+  const record2 = asRecord(value);
+  if (record2 === null)
     return { name: null, email: null, phone: null };
-  const emailValue = recordValue(record, "email", "email_address", "emailAddress");
-  const phoneValue = recordValue(record, "phone", "phone_number", "phoneNumber");
-  const nameValue = recordValue(record, "name", "display_name", "displayName");
+  const emailValue = recordValue(record2, "email", "email_address", "emailAddress");
+  const phoneValue = recordValue(record2, "phone", "phone_number", "phoneNumber");
+  const nameValue = recordValue(record2, "name", "display_name", "displayName");
   const email = typeof emailValue === "string" ? normalizeEmailIdentity(emailValue) : null;
   const phone = typeof phoneValue === "string" ? normalizePhoneForMatch(phoneValue) : null;
   return {
@@ -5950,8 +6510,8 @@ function parseAttendee(value) {
     phone
   };
 }
-function meetingId(record) {
-  const value = recordValue(record, "id", "meeting_id", "meetingId");
+function meetingId(record2) {
+  const value = recordValue(record2, "id", "meeting_id", "meetingId");
   if (typeof value !== "string")
     return null;
   const trimmed = value.trim();
@@ -5961,8 +6521,8 @@ function meetingId(record) {
     return trimmed;
   return null;
 }
-function meetingOccurredAt(record) {
-  const value = recordValue(record, "occurredAt", "occurred_at", "date", "start", "started_at", "startedAt", "created_at", "createdAt");
+function meetingOccurredAt(record2) {
+  const value = recordValue(record2, "occurredAt", "occurred_at", "date", "start", "started_at", "startedAt", "created_at", "createdAt");
   if (typeof value !== "string")
     return null;
   try {
@@ -5971,17 +6531,17 @@ function meetingOccurredAt(record) {
     return null;
   }
 }
-function firstCleanText(record, keys, maximum) {
+function firstCleanText(record2, keys, maximum) {
   for (const key of keys) {
-    const text = cleanText(recordValue(record, key), maximum);
+    const text = cleanText(recordValue(record2, key), maximum);
     if (text !== null)
       return text;
   }
   return null;
 }
-function granolaBody(record) {
-  const privateNotes = firstCleanText(record, ["privateNotes", "private_notes", "notes"], MAX_BODY_BYTES);
-  const summary2 = firstCleanText(record, ["summary_markdown", "summary", "summary_text", "aiSummary", "ai_summary"], MAX_BODY_BYTES);
+function granolaBody(record2) {
+  const privateNotes = firstCleanText(record2, ["privateNotes", "private_notes", "notes"], MAX_BODY_BYTES);
+  const summary2 = firstCleanText(record2, ["summary_markdown", "summary", "summary_text", "aiSummary", "ai_summary"], MAX_BODY_BYTES);
   const parts = [privateNotes, summary2].filter((part) => part !== null);
   if (parts.length === 0)
     return null;
@@ -5996,8 +6556,8 @@ function granolaBody(record) {
     return summary2;
   return joined.slice(0, MAX_BODY_BYTES);
 }
-function inviteeEmailByName(record) {
-  const event = asRecord(recordValue(record, "calendar_event", "calendarEvent"));
+function inviteeEmailByName(record2) {
+  const event = asRecord(recordValue(record2, "calendar_event", "calendarEvent"));
   if (event === null)
     return new Map;
   const invitees = recordValue(event, "invitees", "attendees", "participants");
@@ -6018,11 +6578,11 @@ function inviteeEmailByName(record) {
   }
   return new Map([...emails].filter((entry) => entry[1] !== "ambiguous"));
 }
-function meetingAttendees(record) {
-  const value = recordValue(record, "attendees", "participants", "known_participants", "knownParticipants");
+function meetingAttendees(record2) {
+  const value = recordValue(record2, "attendees", "participants", "known_participants", "knownParticipants");
   if (!Array.isArray(value))
     return [];
-  const inviteeEmails = inviteeEmailByName(record);
+  const inviteeEmails = inviteeEmailByName(record2);
   return value.slice(0, MAX_ATTENDEES).map((item) => {
     const attendee = parseAttendee(item);
     if (attendee.email !== null)
@@ -6034,9 +6594,9 @@ function meetingAttendees(record) {
     return email === undefined ? attendee : { ...attendee, email };
   });
 }
-function meetingMetadata(record, attendees) {
-  const folder = cleanText(recordValue(record, "folder", "folder_name", "folderName"), 1024);
-  const urlValue = recordValue(record, "url", "link");
+function meetingMetadata(record2, attendees) {
+  const folder = cleanText(recordValue(record2, "folder", "folder_name", "folderName"), 1024);
+  const urlValue = recordValue(record2, "url", "link");
   const url = typeof urlValue === "string" && httpUrlSchema.safeParse(urlValue.trim()).success ? urlValue.trim() : null;
   const names = attendees.map((attendee) => attendee.name).filter((name) => name !== null).slice(0, MAX_ATTENDEES);
   const metadata = { attendeeCount: attendees.length };
@@ -6234,14 +6794,14 @@ function matchAttendee(database, attendee, nameIndex) {
 function meetingsFromPayload(payload) {
   if (Array.isArray(payload))
     return payload;
-  const record = asRecord(payload);
-  if (record === null)
+  const record2 = asRecord(payload);
+  if (record2 === null)
     fail("Granola import must be a meeting array or { meetings: [...] }.");
-  const meetings = recordValue(record, "meetings", "documents", "notes");
+  const meetings = recordValue(record2, "meetings", "documents", "notes");
   if (Array.isArray(meetings))
     return meetings;
-  if (meetingId(record) !== null || recordValue(record, "attendees", "participants") !== undefined) {
-    return [record];
+  if (meetingId(record2) !== null || recordValue(record2, "attendees", "participants") !== undefined) {
+    return [record2];
   }
   fail("Granola import must be a meeting array or { meetings: [...] }.");
 }
@@ -6267,15 +6827,15 @@ function importGranolaMeetings(database, payload) {
   try {
     const nameIndex = buildPersonNameIndex(database);
     for (const item of meetings) {
-      const record = asRecord(item);
-      if (record === null) {
+      const record2 = asRecord(item);
+      if (record2 === null) {
         skippedQueue.push({ meetingId: null, reason: "invalid" });
         continue;
       }
-      const id = meetingId(record);
-      const occurredAt = meetingOccurredAt(record);
-      const body = granolaBody(record);
-      const attendees = meetingAttendees(record);
+      const id = meetingId(record2);
+      const occurredAt = meetingOccurredAt(record2);
+      const body = granolaBody(record2);
+      const attendees = meetingAttendees(record2);
       if (id === null || occurredAt === null) {
         skippedQueue.push({ meetingId: id, reason: "invalid" });
         continue;
@@ -6288,8 +6848,8 @@ function importGranolaMeetings(database, payload) {
         skippedQueue.push({ meetingId: id, reason: "no-attendees" });
         continue;
       }
-      const title = cleanText(recordValue(record, "title", "name"), MAX_TITLE_CHARS);
-      const meetingBaseMetadata = meetingMetadata(record, attendees);
+      const title = cleanText(recordValue(record2, "title", "name"), MAX_TITLE_CHARS);
+      const meetingBaseMetadata = meetingMetadata(record2, attendees);
       const resolved = attendees.map((attendee) => ({
         attendee,
         result: matchAttendee(database, attendee, nameIndex)
@@ -6390,7 +6950,7 @@ function importGranolaMeetings(database, payload) {
   };
 }
 function readGranolaImportFile(path) {
-  const descriptor = openSync2(path, constants2.O_RDONLY | (constants2.O_NOFOLLOW ?? 0));
+  const descriptor = openSync2(path, constants3.O_RDONLY | (constants3.O_NOFOLLOW ?? 0));
   try {
     const before = fstatSync2(descriptor);
     const uid = typeof process.getuid === "function" ? process.getuid() : null;
@@ -6948,15 +7508,15 @@ function workspaceClient() {
         const row = node("tr", "", selectedPerson === person.id ? "selected" : "");
         row.dataset.personId = String(person.id);
         const name = node("td");
-        const open = node("button", person.displayName);
-        open.type = "button";
-        open.addEventListener("click", () => {
+        const open2 = node("button", person.displayName);
+        open2.type = "button";
+        open2.addEventListener("click", () => {
           if (mayDiscard()) {
             dirty = false;
             showPerson(person.id);
           }
         });
-        name.append(open, node("small", person.title ?? person.primaryEmail ?? ""));
+        name.append(open2, node("small", person.title ?? person.primaryEmail ?? ""));
         const company = node("td", person.organization ?? "\u2014");
         company.append(node("small", person.sources.join(" \xB7 ")));
         const interactions = node("td", person.interactionCount.toLocaleString());
@@ -7356,7 +7916,7 @@ class WorkspaceRequestError extends Error {
     this.code = code;
   }
 }
-function json(value, status = 200) {
+function json2(value, status = 200) {
   return Response.json(value, { status, headers: securityHeaders });
 }
 async function readPayload(request) {
@@ -7407,31 +7967,31 @@ function createWorkspaceHandler(input) {
       request.body?.cancel().catch(() => {
         return;
       });
-      return json({ error: "forbidden" }, 403);
+      return json2({ error: "forbidden" }, 403);
     }
     if (request.method === "GET") {
       const asset = url.pathname === "/" ? [input.assets.html, "text/html; charset=utf-8"] : url.pathname === "/workspace.js" ? [input.assets.script, "text/javascript; charset=utf-8"] : url.pathname === "/workspace.css" ? [input.assets.css, "text/css; charset=utf-8"] : null;
-      return asset === null ? json({ error: "not_found" }, 404) : new Response(asset[0], { headers: { ...securityHeaders, "content-type": asset[1] } });
+      return asset === null ? json2({ error: "not_found" }, 404) : new Response(asset[0], { headers: { ...securityHeaders, "content-type": asset[1] } });
     }
     if (request.method !== "POST" || url.pathname !== "/api")
-      return json({ error: "not_found" }, 404);
+      return json2({ error: "not_found" }, 404);
     const supplied = request.headers.get("authorization")?.replace(/^Bearer /u, "") ?? "";
     if (request.headers.get("origin") !== input.origin || !/^[A-Za-z0-9_-]{43}$/u.test(supplied) || !timingSafeEqual(Buffer.from(supplied), secret)) {
       request.body?.cancel().catch(() => {
         return;
       });
-      return json({ error: "unauthorized" }, 401);
+      return json2({ error: "unauthorized" }, 401);
     }
     if (request.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json") {
-      return json({ error: "unsupported_media_type" }, 415);
+      return json2({ error: "unsupported_media_type" }, 415);
     }
     try {
-      return json({ ok: true, result: await input.dispatch(await readPayload(request)) });
+      return json2({ ok: true, result: await input.dispatch(await readPayload(request)) });
     } catch (error) {
       if (error instanceof WorkspaceRequestError) {
-        return json({ ok: false, error: error.code, message: error.message }, error.code === "not_found" ? 404 : error.code === "conflict" ? 409 : 400);
+        return json2({ ok: false, error: error.code, message: error.message }, error.code === "not_found" ? 404 : error.code === "conflict" ? 409 : 400);
       }
-      return json({ ok: false, error: "operation_failed", message: "The operation failed. Your existing data is preserved." }, 500);
+      return json2({ ok: false, error: "operation_failed", message: "The operation failed. Your existing data is preserved." }, 500);
     }
   };
 }
@@ -7527,9 +8087,9 @@ function startLocalWorkspace(database, port = 0) {
   let directory;
   let accessFile;
   try {
-    directory = mkdtempSync(join(tmpdir(), "peopleblade-workspace-"));
+    directory = mkdtempSync(join2(tmpdir(), "peopleblade-workspace-"));
     chmodSync(directory, 448);
-    accessFile = join(directory, "access.json");
+    accessFile = join2(directory, "access.json");
     writeFileSync(accessFile, JSON.stringify({ schemaVersion: "peopleblade.workspace-access.v1", origin, capability }), { flag: "wx", mode: 384 });
   } catch (error) {
     server.stop(true);
@@ -7594,25 +8154,25 @@ import { z as z8 } from "zod";
 import { z as z7 } from "zod";
 
 // src/local/config.ts
-import { closeSync as closeSync3, constants as constants3, existsSync, mkdirSync, openSync as openSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
+import { closeSync as closeSync3, constants as constants4, existsSync, mkdirSync, openSync as openSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
 import { z as z6 } from "zod";
 
 // src/local/paths.ts
-import { homedir, hostname, platform } from "os";
-import { join as join2 } from "path";
+import { homedir as homedir2, hostname, platform } from "os";
+import { join as join3 } from "path";
 function peoplebladeDirectory() {
   if (platform() === "darwin")
-    return join2(homedir(), "Library", "Application Support", "PeopleBlade");
+    return join3(homedir2(), "Library", "Application Support", "PeopleBlade");
   if (platform() === "win32")
-    return join2(process.env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local"), "PeopleBlade");
-  return join2(process.env.XDG_DATA_HOME ?? join2(homedir(), ".local", "share"), "peopleblade");
+    return join3(process.env.LOCALAPPDATA ?? join3(homedir2(), "AppData", "Local"), "PeopleBlade");
+  return join3(process.env.XDG_DATA_HOME ?? join3(homedir2(), ".local", "share"), "peopleblade");
 }
 function peoplebladeDatabasePath() {
-  return process.env.PEOPLEBLADE_DATABASE ?? join2(peoplebladeDirectory(), "peopleblade.sqlite3");
+  return process.env.PEOPLEBLADE_DATABASE ?? join3(peoplebladeDirectory(), "peopleblade.sqlite3");
 }
 function peoplebladeConfigPath() {
-  return join2(peoplebladeDirectory(), "config.json");
+  return join3(peoplebladeDirectory(), "config.json");
 }
 function defaultDeviceName() {
   return `${hostname() || "Mac"} \xB7 PeopleBlade CLI`.slice(0, 128);
@@ -7637,7 +8197,7 @@ function writeLocalConfig(config) {
   const directory = dirname(path);
   mkdirSync(directory, { recursive: true, mode: 448 });
   const temporary = `${path}.stage-${process.pid}`;
-  const descriptor = openSync3(temporary, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL, 384);
+  const descriptor = openSync3(temporary, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL, 384);
   try {
     writeFileSync2(descriptor, `${JSON.stringify(configSchema.parse(config), null, 2)}
 `);
@@ -8467,7 +9027,7 @@ import crypto2 from "crypto";
 import {
   chmodSync as chmodSync2,
   closeSync as closeSync4,
-  constants as constants4,
+  constants as constants5,
   existsSync as existsSync2,
   fchmodSync,
   fstatSync as fstatSync3,
@@ -8483,7 +9043,7 @@ import {
   unlinkSync as unlinkSync2,
   writeFileSync as writeFileSync3
 } from "fs";
-import { basename, dirname as dirname2, join as join3, resolve } from "path";
+import { basename, dirname as dirname2, join as join4, resolve } from "path";
 import { fileURLToPath } from "url";
 
 // src/local/phone-identity-migration.ts
@@ -8847,7 +9407,7 @@ function bindSourceRealmCoordinates(database, authority, accountKey, binding, re
 // src/local/source-account-migration.ts
 var PROVIDER2 = /^[a-z][a-z0-9-]{0,63}$/u;
 var DIGEST = /^[a-f0-9]{64}$/u;
-function timestamp(value, label) {
+function timestamp2(value, label) {
   const milliseconds = Date.parse(value);
   if (!Number.isFinite(milliseconds))
     throw new Error(`${label} must be a timestamp.`);
@@ -8863,8 +9423,8 @@ function bindProviderAccountRealm(database, input) {
   if (!DIGEST.test(input.authSha256)) {
     throw new Error("Provider account contains an invalid authorization identity.");
   }
-  const firstSeenAt = timestamp(input.firstSeenAt, "Provider account first observation");
-  const lastSeenAt = timestamp(input.lastSeenAt, "Provider account last observation");
+  const firstSeenAt = timestamp2(input.firstSeenAt, "Provider account first observation");
+  const lastSeenAt = timestamp2(input.lastSeenAt, "Provider account last observation");
   if (lastSeenAt < firstSeenAt) {
     throw new Error("Provider account observation timing is invalid.");
   }
@@ -8914,8 +9474,8 @@ function convergeLegacyProviderAccounts(database) {
   database.exec("BEGIN IMMEDIATE");
   try {
     for (const account of accounts) {
-      const firstSeenAt = timestamp(account.first_seen_at, "Legacy account first observation");
-      const lastSeenAt = timestamp(account.last_seen_at, "Legacy account last observation");
+      const firstSeenAt = timestamp2(account.first_seen_at, "Legacy account first observation");
+      const lastSeenAt = timestamp2(account.last_seen_at, "Legacy account last observation");
       const subjectSha256 = sha256(account.account_key);
       const realm = bindProviderAccountRealm(database, {
         provider: account.provider,
@@ -8980,7 +9540,7 @@ function convergeLegacyProviderAccounts(database) {
 }
 
 // src/local/database.ts
-var migrationsDirectory = join3(dirname2(fileURLToPath(import.meta.url)), "migrations");
+var migrationsDirectory = join4(dirname2(fileURLToPath(import.meta.url)), "migrations");
 function migrationNames() {
   return readdirSync(migrationsDirectory).filter((name) => name.endsWith(".sql")).sort();
 }
@@ -9132,7 +9692,7 @@ function connectLocalDatabase(path = peoplebladeDatabasePath(), readonly = false
   if (!existsSync2(path)) {
     if (readonly)
       throw new Error(`PeopleBlade database does not exist: ${path}`);
-    const descriptor = openSync4(path, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | (constants4.O_NOFOLLOW ?? 0), 384);
+    const descriptor = openSync4(path, constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL | (constants5.O_NOFOLLOW ?? 0), 384);
     closeSync4(descriptor);
   }
   const physical = realpathSync(path);
@@ -9151,7 +9711,7 @@ function migrateLocalDatabase(database) {
       continue;
     database.exec("BEGIN IMMEDIATE");
     try {
-      database.exec(readFileSync4(join3(migrationsDirectory, filename), "utf8"));
+      database.exec(readFileSync4(join4(migrationsDirectory, filename), "utf8"));
       database.query("INSERT INTO schema_migrations(version) VALUES (?)").run(filename);
       database.exec("COMMIT");
     } catch (error) {
@@ -9208,7 +9768,7 @@ function backupLocalDatabase(sourcePath, destinationPath) {
   if (source === requestedDestination)
     throw new Error("Backup destination cannot be the source database.");
   const destinationDirectory = assertSecureBackupDirectory(dirname2(requestedDestination));
-  const destination = join3(destinationDirectory, basename(requestedDestination));
+  const destination = join4(destinationDirectory, basename(requestedDestination));
   if (existsSync2(destination))
     throw new Error(`Backup already exists: ${destination}`);
   if (source === destination)
@@ -9227,8 +9787,8 @@ function backupLocalDatabase(sourcePath, destinationPath) {
   } finally {
     database.close();
   }
-  const temporary = join3(destinationDirectory, `.peopleblade-backup-${process.pid}-${crypto2.randomBytes(8).toString("hex")}`);
-  const descriptor = openSync4(temporary, constants4.O_WRONLY | constants4.O_CREAT | constants4.O_EXCL | (constants4.O_NOFOLLOW ?? 0), 384);
+  const temporary = join4(destinationDirectory, `.peopleblade-backup-${process.pid}-${crypto2.randomBytes(8).toString("hex")}`);
+  const descriptor = openSync4(temporary, constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL | (constants5.O_NOFOLLOW ?? 0), 384);
   try {
     try {
       fchmodSync(descriptor, 384);
@@ -9250,7 +9810,7 @@ function backupLocalDatabase(sourcePath, destinationPath) {
     throw error;
   }
   secureFile(destination);
-  const directory = openSync4(destinationDirectory, constants4.O_RDONLY);
+  const directory = openSync4(destinationDirectory, constants5.O_RDONLY);
   try {
     fsyncSync(directory);
   } finally {
@@ -9260,15 +9820,15 @@ function backupLocalDatabase(sourcePath, destinationPath) {
 function standardBackupPath(label, databasePath = peoplebladeDatabasePath()) {
   if (!/^[a-z0-9][a-z0-9-]{0,63}$/u.test(label))
     throw new Error("Backup label is invalid.");
-  const timestamp2 = new Date().toISOString().replaceAll(/[-:.]/gu, "").replace("Z", "Z");
-  return join3(dirname2(databasePath), "backups", `${label}-${timestamp2}.sqlite3`);
+  const timestamp3 = new Date().toISOString().replaceAll(/[-:.]/gu, "").replace("Z", "Z");
+  return join4(dirname2(databasePath), "backups", `${label}-${timestamp3}.sqlite3`);
 }
 
 // src/local/ensoul.ts
 import { randomBytes as randomBytes3 } from "crypto";
 import {
   closeSync as closeSync5,
-  constants as constants5,
+  constants as constants6,
   fchmodSync as fchmodSync2,
   fstatSync as fstatSync4,
   fsyncSync as fsyncSync2,
@@ -9279,7 +9839,7 @@ import {
   unlinkSync as unlinkSync3,
   writeFileSync as writeFileSync4
 } from "fs";
-import { basename as basename2, dirname as dirname3, join as join4, resolve as resolve2 } from "path";
+import { basename as basename2, dirname as dirname3, join as join5, resolve as resolve2 } from "path";
 
 // src/lib/ensoul-contracts.ts
 import { z as z9 } from "zod";
@@ -9368,7 +9928,7 @@ var ensoulSourceRecordSemanticSchema = z9.object({
     model: boundedText2(160).optional(),
     contentSha256: digestSchema
   }).strict()
-}).strict().refine((record) => record.occurredAt !== undefined || record.observedAt !== undefined, "Source record requires occurredAt or observedAt");
+}).strict().refine((record2) => record2.occurredAt !== undefined || record2.observedAt !== undefined, "Source record requires occurredAt or observedAt");
 var ensoulSourceRecordSchema = ensoulSourceRecordSemanticSchema.extend({
   digest: prefixedDigestSchema
 }).strict();
@@ -9470,29 +10030,29 @@ var ensoulSourcePacketSchema = peoplebladeEnsoulPacketSemanticSchema.extend({
       message: "Source packet digest does not match its canonical semantic content"
     });
   const recordIds = new Set;
-  packet.records.forEach((record, index) => {
-    if (recordIds.has(record.id))
+  packet.records.forEach((record2, index) => {
+    if (recordIds.has(record2.id))
       context.addIssue({
         code: "custom",
         path: ["records", index, "id"],
         message: "Source record IDs must be unique"
       });
-    recordIds.add(record.id);
-    const { digest, ...recordSemantic } = record;
+    recordIds.add(record2.id);
+    const { digest, ...recordSemantic } = record2;
     if (`sha256:${sha256(ensoulJcsCanonicalJson(recordSemantic))}` !== digest)
       context.addIssue({
         code: "custom",
         path: ["records", index, "digest"],
         message: "Source record digest does not match"
       });
-    if (sha256(ensoulJcsCanonicalJson(record.content)) !== record.provenance.contentSha256)
+    if (sha256(ensoulJcsCanonicalJson(record2.content)) !== record2.provenance.contentSha256)
       context.addIssue({
         code: "custom",
         path: ["records", index, "provenance", "contentSha256"],
         message: "Source record content digest does not match"
       });
-    const occurredAt = record.occurredAt === undefined ? null : Date.parse(record.occurredAt);
-    const observedAt = record.observedAt === undefined ? null : Date.parse(record.observedAt);
+    const occurredAt = record2.occurredAt === undefined ? null : Date.parse(record2.occurredAt);
+    const observedAt = record2.observedAt === undefined ? null : Date.parse(record2.observedAt);
     if (occurredAt !== null && observedAt !== null && occurredAt > observedAt)
       context.addIssue({
         code: "custom",
@@ -9780,7 +10340,7 @@ function buildPeoplebladeEnsoulSourcePacketSnapshot(database, requestedPersonId,
         ...redactedUrl === evidence.url ? { url: evidence.url } : {},
         ...exportedTitle === title ? {} : { truncated: true }
       };
-      const record = buildEnsoulSourceRecord({
+      const record2 = buildEnsoulSourceRecord({
         id: sourceId,
         kind: "public_page",
         observedAt: enrichment.observedAt,
@@ -9799,8 +10359,8 @@ function buildPeoplebladeEnsoulSourcePacketSnapshot(database, requestedPersonId,
           contentSha256: sha256(ensoulJcsCanonicalJson(content))
         }
       });
-      records.push(record);
-      recordIds.set(evidenceIndex, record.id);
+      records.push(record2);
+      recordIds.set(evidenceIndex, record2.id);
     }
     for (const { claim, claimIndex, field, value } of exportableClaims) {
       const evidenceRecordIds = claim.evidenceIndexes.map((index) => recordIds.get(index));
@@ -9824,8 +10384,8 @@ function buildPeoplebladeEnsoulSourcePacketSnapshot(database, requestedPersonId,
   if (records.length > MAX_RECORDS || claims.length > MAX_CLAIMS) {
     throw new Error("Current public enrichment material exceeds the Ensoul packet bounds.");
   }
-  const sourceTimes = records.flatMap((record) => [record.occurredAt, record.observedAt].filter((value) => value !== undefined)).sort();
-  const observedTimes = records.flatMap((record) => record.observedAt === undefined ? [] : [record.observedAt]).sort();
+  const sourceTimes = records.flatMap((record2) => [record2.occurredAt, record2.observedAt].filter((value) => value !== undefined)).sort();
+  const observedTimes = records.flatMap((record2) => record2.observedAt === undefined ? [] : [record2.observedAt]).sort();
   return buildEnsoulSourcePacket({
     schemaVersion: ensoulSourcePacketVersion,
     digestCanonicalization: ensoulDigestCanonicalization,
@@ -9907,12 +10467,12 @@ function writePrivatePacket(path, contents) {
   if (filename === "." || filename === "..")
     throw new Error("Ensoul output requires a file path.");
   const directory = assertPrivateOutputDirectory(dirname3(requested));
-  const destination = join4(directory, filename);
+  const destination = join5(directory, filename);
   if (pathEntryExists2(destination))
     throw new Error("Ensoul output already exists; refusing to overwrite it.");
-  const temporary = join4(directory, `.peopleblade-ensoul-${process.pid}-${randomBytes3(12).toString("hex")}`);
+  const temporary = join5(directory, `.peopleblade-ensoul-${process.pid}-${randomBytes3(12).toString("hex")}`);
   let identity = null;
-  const descriptor = openSync5(temporary, constants5.O_WRONLY | constants5.O_CREAT | constants5.O_EXCL | (constants5.O_NOFOLLOW ?? 0), 384);
+  const descriptor = openSync5(temporary, constants6.O_WRONLY | constants6.O_CREAT | constants6.O_EXCL | (constants6.O_NOFOLLOW ?? 0), 384);
   try {
     identity = fstatSync4(descriptor);
     fchmodSync2(descriptor, 384);
@@ -9939,7 +10499,7 @@ function writePrivatePacket(path, contents) {
     if (!published.isFile() || published.isSymbolicLink() || identity === null || published.dev !== identity.dev || published.ino !== identity.ino || published.nlink !== 1 || uid === null || published.uid !== uid || (published.mode & 511) !== 384) {
       throw new Error("Ensoul output was not published as one private, owned regular file.");
     }
-    const directoryDescriptor = openSync5(directory, constants5.O_RDONLY);
+    const directoryDescriptor = openSync5(directory, constants6.O_RDONLY);
     try {
       fsyncSync2(directoryDescriptor);
     } finally {
@@ -9997,7 +10557,7 @@ function binding(value) {
     return value;
   throw new Error("Legacy database value is not a supported SQLite binding.");
 }
-function json2(value) {
+function json3(value) {
   return canonicalJson(value);
 }
 function providerForKind(kind) {
@@ -10083,7 +10643,7 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
             return rootValue;
           return candidates.map((item) => item[key]).find((value) => value !== null && value !== "") ?? rootValue;
         };
-        const inserted = insertPerson.run(`rolodex-v1:${canonicalId}`, preferred("display_name"), preferred("given_name"), preferred("family_name"), preferred("organization"), preferred("title"), candidates.some((person) => person.do_not_contact === 1) ? 1 : 0, preferred("notes"), json2({ legacy_person_ids: memberIds }), candidates.map((person) => person.created_at).sort()[0], candidates.map((person) => person.updated_at).sort().at(-1));
+        const inserted = insertPerson.run(`rolodex-v1:${canonicalId}`, preferred("display_name"), preferred("given_name"), preferred("family_name"), preferred("organization"), preferred("title"), candidates.some((person) => person.do_not_contact === 1) ? 1 : 0, preferred("notes"), json3({ legacy_person_ids: memberIds }), candidates.map((person) => person.created_at).sort()[0], candidates.map((person) => person.updated_at).sort().at(-1));
         targetByCanonical.set(canonicalId, number(inserted.lastInsertRowid, "person id"));
       }
       const personFor = (legacyPersonId) => {
@@ -10108,7 +10668,7 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
         const fileHash = text(row.file_sha256, "source hash");
         const importedAt = text(row.imported_at, "source imported_at");
         const locator = nullableText2(row.file_path);
-        const result2 = insertRun.run(providerForKind(kind), `${kind}:${legacyId}`, fileHash, locator === null ? null : sha256(locator), json2({ legacy_source_id: legacyId, kind, name: row.name, row_count: row.row_count, metadata: JSON.parse(text(row.metadata_json, "metadata_json")) }), importedAt, importedAt);
+        const result2 = insertRun.run(providerForKind(kind), `${kind}:${legacyId}`, fileHash, locator === null ? null : sha256(locator), json3({ legacy_source_id: legacyId, kind, name: row.name, row_count: row.row_count, metadata: JSON.parse(text(row.metadata_json, "metadata_json")) }), importedAt, importedAt);
         sourceMap.set(legacyId, number(result2.lastInsertRowid, "source run id"));
         sourceRuns += 1;
       }
@@ -10119,7 +10679,7 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
       for (const row of source.query("SELECT * FROM emails ORDER BY id").all()) {
         const targetPerson = personFor(number(row.person_id, "email person"));
         const run = row.source_id === null ? null : sourceMap.get(number(row.source_id, "email source")) ?? null;
-        const result2 = insertMethod.run(...[targetPerson, "email", row.address, row.normalized_address, "", row.is_primary, row.confidence, run, run, json2({ legacy_email_id: row.id, source_row: row.source_row }), row.created_at].map(binding));
+        const result2 = insertMethod.run(...[targetPerson, "email", row.address, row.normalized_address, "", row.is_primary, row.confidence, run, run, json3({ legacy_email_id: row.id, source_row: row.source_row }), row.created_at].map(binding));
         if (result2.changes > 0)
           contactMethods += 1;
       }
@@ -10127,7 +10687,7 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
         for (const row of source.query("SELECT * FROM phone_numbers ORDER BY id").all()) {
           const targetPerson = personFor(number(row.person_id, "phone person"));
           const run = row.source_id === null ? null : sourceMap.get(number(row.source_id, "phone source")) ?? null;
-          const result2 = insertMethod.run(...[targetPerson, "phone", row.value, row.normalized_value, nullableText2(row.type) ?? "", 0, "exact", run, run, json2({ legacy_phone_id: row.id, source_row: row.source_row }), row.created_at].map(binding));
+          const result2 = insertMethod.run(...[targetPerson, "phone", row.value, row.normalized_value, nullableText2(row.type) ?? "", 0, "exact", run, run, json3({ legacy_phone_id: row.id, source_row: row.source_row }), row.created_at].map(binding));
           if (result2.changes > 0)
             contactMethods += 1;
         }
@@ -10137,12 +10697,12 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
         metadata_json, created_at, updated_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, coalesce(?, CURRENT_TIMESTAMP), coalesce(?, CURRENT_TIMESTAMP))`);
       const resourceSpecs = [
-        { table: "google_contacts", query: "SELECT * FROM google_contacts ORDER BY id", convert: (r) => ["google", r.account_subject, r.collection, r.resource_name, personFor(number(r.person_id, "google person")), null, null, 0, r.collection === "contacts" || r.collection === "other-contacts" ? 1 : 0, null, r.deleted === 1 ? 0 : 1, r.first_seen_source_id === null ? null : sourceMap.get(number(r.first_seen_source_id, "source")), r.last_seen_source_id === null ? null : sourceMap.get(number(r.last_seen_source_id, "source")), json2({ etag: r.etag, legacy_id: r.id }), r.created_at, r.updated_at] },
-        { table: "apple_contacts", query: "SELECT * FROM apple_contacts ORDER BY id", convert: (r) => ["apple", r.account_key, "contact", `${r.store_key}:${r.contact_identifier}`, personFor(number(r.person_id, "apple person")), null, null, 0, 1, null, r.removed === 1 ? 0 : 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json2({ store_key: r.store_key, contact_identifier: r.contact_identifier, legacy_id: r.id }), r.created_at, r.updated_at] },
-        { table: "linkedin_connections", query: "SELECT * FROM linkedin_connections ORDER BY id", convert: (r) => ["linkedin", r.account_key, "profile", r.profile_url, personFor(number(r.person_id, "linkedin person")), null, r.profile_url, 1, 1, [r.first_name, r.last_name].filter(Boolean).join(" ") || null, r.removed === 1 ? 0 : 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json2({ company: r.company, position: r.position, connected_on: r.connected_on, legacy_id: r.id }), r.created_at, r.updated_at] },
-        { table: "telegram_contacts", query: "SELECT * FROM telegram_contacts ORDER BY id", convert: (r) => ["telegram", r.account_key, "contact", r.contact_key, personFor(number(r.person_id, "telegram person")), null, null, 0, 0, null, 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json2({ telegram_user_id: r.telegram_user_id, phone: r.phone_normalized, legacy_id: r.id }), r.created_at, r.updated_at] },
-        { table: "whatsapp_contacts", query: "SELECT * FROM whatsapp_contacts ORDER BY id", convert: (r) => ["whatsapp", r.account_subject, "jid", r.contact_jid, personFor(number(r.person_id, "whatsapp person")), null, null, 0, 0, r.display_name, 1, null, null, json2({ jid_kind: r.jid_kind, phone: r.normalized_phone, display_name_basis: r.display_name_basis, legacy_id: r.id }), r.created_at, r.updated_at] },
-        { table: "instagram_identities", query: "SELECT * FROM instagram_identities ORDER BY id", convert: (r) => ["instagram", r.account_key, r.provider_user_id === null ? "profile" : "user", r.provider_user_id ?? r.profile_href, personFor(number(r.person_id, "instagram person")), r.current_username, r.profile_href, 1, 0, r.current_username, 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json2({ legacy_id: r.id }), r.created_at, r.updated_at] }
+        { table: "google_contacts", query: "SELECT * FROM google_contacts ORDER BY id", convert: (r) => ["google", r.account_subject, r.collection, r.resource_name, personFor(number(r.person_id, "google person")), null, null, 0, r.collection === "contacts" || r.collection === "other-contacts" ? 1 : 0, null, r.deleted === 1 ? 0 : 1, r.first_seen_source_id === null ? null : sourceMap.get(number(r.first_seen_source_id, "source")), r.last_seen_source_id === null ? null : sourceMap.get(number(r.last_seen_source_id, "source")), json3({ etag: r.etag, legacy_id: r.id }), r.created_at, r.updated_at] },
+        { table: "apple_contacts", query: "SELECT * FROM apple_contacts ORDER BY id", convert: (r) => ["apple", r.account_key, "contact", `${r.store_key}:${r.contact_identifier}`, personFor(number(r.person_id, "apple person")), null, null, 0, 1, null, r.removed === 1 ? 0 : 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json3({ store_key: r.store_key, contact_identifier: r.contact_identifier, legacy_id: r.id }), r.created_at, r.updated_at] },
+        { table: "linkedin_connections", query: "SELECT * FROM linkedin_connections ORDER BY id", convert: (r) => ["linkedin", r.account_key, "profile", r.profile_url, personFor(number(r.person_id, "linkedin person")), null, r.profile_url, 1, 1, [r.first_name, r.last_name].filter(Boolean).join(" ") || null, r.removed === 1 ? 0 : 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json3({ company: r.company, position: r.position, connected_on: r.connected_on, legacy_id: r.id }), r.created_at, r.updated_at] },
+        { table: "telegram_contacts", query: "SELECT * FROM telegram_contacts ORDER BY id", convert: (r) => ["telegram", r.account_key, "contact", r.contact_key, personFor(number(r.person_id, "telegram person")), null, null, 0, 0, null, 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json3({ telegram_user_id: r.telegram_user_id, phone: r.phone_normalized, legacy_id: r.id }), r.created_at, r.updated_at] },
+        { table: "whatsapp_contacts", query: "SELECT * FROM whatsapp_contacts ORDER BY id", convert: (r) => ["whatsapp", r.account_subject, "jid", r.contact_jid, personFor(number(r.person_id, "whatsapp person")), null, null, 0, 0, r.display_name, 1, null, null, json3({ jid_kind: r.jid_kind, phone: r.normalized_phone, display_name_basis: r.display_name_basis, legacy_id: r.id }), r.created_at, r.updated_at] },
+        { table: "instagram_identities", query: "SELECT * FROM instagram_identities ORDER BY id", convert: (r) => ["instagram", r.account_key, r.provider_user_id === null ? "profile" : "user", r.provider_user_id ?? r.profile_href, personFor(number(r.person_id, "instagram person")), r.current_username, r.profile_href, 1, 0, r.current_username, 1, sourceMap.get(number(r.first_seen_source_id, "source")), sourceMap.get(number(r.last_seen_source_id, "source")), json3({ legacy_id: r.id }), r.created_at, r.updated_at] }
       ];
       for (const spec of resourceSpecs)
         if (tableExists2(source, spec.table))
@@ -10187,7 +10747,7 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
           addMetric("instagram", text(r.account_key, "account"), number(r.person_id, "person"), number(r.outgoing_messages, "sent"), number(r.incoming_messages, "received"), number(r.outgoing_messages, "sent") + number(r.incoming_messages, "received"), number(r.conversation_count, "conversations"), nullableText2(r.first_message_at), nullableText2(r.last_message_at), number(r.outgoing_messages, "sent") > 0 && number(r.incoming_messages, "received") > 0, "unknown");
       const insertMetric = target.query(`INSERT INTO interaction_metrics(provider,account_key,person_id,sent_count,received_count,interaction_count,conversation_count,first_interaction_at,last_interaction_at,reciprocal,completeness,metadata_json) VALUES (?,?,?,?,?,?,?,?,?,?,?,?)`);
       for (const metric of metrics.values()) {
-        insertMetric.run(metric.provider, metric.account, metric.person, metric.sent, metric.received, metric.count, metric.conversations, metric.first, metric.last, metric.reciprocal ? 1 : 0, metric.completeness, json2(metric.metadata));
+        insertMetric.run(metric.provider, metric.account, metric.person, metric.sent, metric.received, metric.count, metric.conversations, metric.first, metric.last, metric.reciprocal ? 1 : 0, metric.completeness, json3(metric.metadata));
         interactionMetrics += 1;
       }
       if (tableExists2(source, "tags") && tableExists2(source, "person_tags")) {
@@ -10203,16 +10763,16 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
       if (tableExists2(source, "publications") && tableExists2(source, "publication_memberships")) {
         const collectionMap = new Map;
         for (const r of source.query("SELECT * FROM publications ORDER BY id").all()) {
-          const result2 = target.query("INSERT INTO collections(provider,account_key,resource_id,name,metadata_json) VALUES (?,?,?,?,?)").run(text(r.platform, "platform"), "legacy", text(r.slug, "slug"), text(r.name, "name"), json2({ legacy_publication_id: r.id }));
+          const result2 = target.query("INSERT INTO collections(provider,account_key,resource_id,name,metadata_json) VALUES (?,?,?,?,?)").run(text(r.platform, "platform"), "legacy", text(r.slug, "slug"), text(r.name, "name"), json3({ legacy_publication_id: r.id }));
           collectionMap.set(number(r.id, "publication"), number(result2.lastInsertRowid, "collection"));
           collections += 1;
         }
         for (const r of source.query("SELECT * FROM publication_memberships").all())
-          target.query("INSERT INTO collection_memberships(collection_id,person_id,state,metadata_json,updated_at) VALUES (?,?,?,?,?)").run(collectionMap.get(number(r.publication_id, "publication")) ?? null, personFor(number(r.person_id, "person")), text(r.state, "state"), json2(r), text(r.updated_at, "membership timestamp"));
+          target.query("INSERT INTO collection_memberships(collection_id,person_id,state,metadata_json,updated_at) VALUES (?,?,?,?,?)").run(collectionMap.get(number(r.publication_id, "publication")) ?? null, personFor(number(r.person_id, "person")), text(r.state, "state"), json3(r), text(r.updated_at, "membership timestamp"));
       }
       renormalizePhoneIdentities(target, { transaction: false });
       const result = { people: targetByCanonical.size, contactMethods, providerResources, sourceRuns, sourceRecords, interactionMetrics, tags, collections };
-      target.query("INSERT INTO legacy_migrations(source_format,source_sha256,source_locator_sha256,result_json) VALUES ('rolodex-v1',?,?,?)").run(sourceSha256, sha256(sourcePhysical), json2(result));
+      target.query("INSERT INTO legacy_migrations(source_format,source_sha256,source_locator_sha256,result_json) VALUES ('rolodex-v1',?,?,?)").run(sourceSha256, sha256(sourcePhysical), json3(result));
       target.exec("COMMIT");
       return { ...result, cached: false };
     } catch (error) {
@@ -11734,7 +12294,7 @@ function addConfirmedPerson(database, args) {
 }
 
 // src/local/menubar.ts
-import { existsSync as existsSync3 } from "fs";
+import { lstatSync as lstatSync5 } from "fs";
 import { dirname as dirname4, resolve as resolve3 } from "path";
 var SETTLE_MS = 400;
 function resolveMenubarBinary(environment = process.env) {
@@ -11745,11 +12305,19 @@ function resolveMenubarBinary(environment = process.env) {
     resolve3(import.meta.dir, "../../desktop/target/debug/peopleblade-menubar")
   ];
   for (const candidate of candidates) {
-    if (candidate !== undefined && candidate !== "" && existsSync3(candidate))
+    if (candidate !== undefined && candidate !== "" && qualifiedBinary(candidate))
       return candidate;
   }
   return null;
 }
+function qualifiedBinary(path) {
+  try {
+    const info = lstatSync5(path);
+    return info.isFile() && (info.mode & 73) !== 0 && (info.mode & 18) === 0;
+  } catch {
+    return false;
+  }
+}
 async function launchMenubar(asJson) {
   const binary = resolveMenubarBinary();
   if (binary === null) {
@@ -11762,7 +12330,7 @@ async function launchMenubar(asJson) {
   }
   let child;
   try {
-    child = Bun.spawn([binary], { stdin: "ignore", stdout: "ignore", stderr: "pipe" });
+    child = Bun.spawn([binary], { stdin: "ignore", stdout: "ignore", stderr: "ignore" });
   } catch {
     console.error("The PeopleBlade menu bar could not start.");
     return 1;
@@ -11788,12 +12356,12 @@ async function launchMenubar(asJson) {
 import { Database as Database3 } from "bun:sqlite";
 import { createHash as createHash3 } from "crypto";
 import {
-  lstatSync as lstatSync5,
+  lstatSync as lstatSync6,
   readdirSync as readdirSync2,
   realpathSync as realpathSync4
 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join5, resolve as resolve4 } from "path";
+import { homedir as homedir3 } from "os";
+import { join as join6, resolve as resolve4 } from "path";
 var EMAIL_PATTERN2 = /^(?=[\x21-\x7E]+$)[^@\s]+@[^@\s]+\.[^@\s]+$/u;
 function clean(value) {
   if (typeof value !== "string")
@@ -11804,7 +12372,7 @@ function clean(value) {
 function normalizeEmail(value) {
   return value.trim().toLocaleLowerCase("en-US");
 }
-var DEFAULT_APPLE_CONTACTS_DIRECTORY = join5(homedir2(), "Library", "Application Support", "AddressBook");
+var DEFAULT_APPLE_CONTACTS_DIRECTORY = join6(homedir3(), "Library", "Application Support", "AddressBook");
 var DEFAULT_APPLE_CONTACTS_ACCOUNT = "apple-contacts-main";
 var MAX_SOURCE_DATABASES = 64;
 var MAX_SOURCE_DATABASE_BYTES = 512 * 1024 * 1024;
@@ -11893,10 +12461,10 @@ function optionalText(value) {
     throw new Error("Apple Contacts text field is too large");
   return clean(value);
 }
-function appleBirthday(record) {
-  const rawBirthday = record.ZBIRTHDAY;
-  const rawYear = record.ZBIRTHDAYYEAR;
-  const rawYearless = record.ZBIRTHDAYYEARLESS;
+function appleBirthday(record2) {
+  const rawBirthday = record2.ZBIRTHDAY;
+  const rawYear = record2.ZBIRTHDAYYEAR;
+  const rawYearless = record2.ZBIRTHDAYYEARLESS;
   if (rawBirthday === null && rawYear === null && rawYearless === null)
     return null;
   if (typeof rawBirthday !== "number" || !Number.isSafeInteger(rawBirthday) || typeof rawYear !== "number" || !Number.isSafeInteger(rawYear) || rawYear < 1 || rawYear > 9999 || typeof rawYearless !== "number" || !Number.isSafeInteger(rawYearless))
@@ -11945,8 +12513,8 @@ function stableJson(value) {
     return JSON.stringify(value);
   if (Array.isArray(value))
     return `[${value.map(stableJson).join(",")}]`;
-  const record = value;
-  return `{${Object.keys(record).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record[key])}`).join(",")}}`;
+  const record2 = value;
+  return `{${Object.keys(record2).sort().map((key) => `${JSON.stringify(key)}:${stableJson(record2[key])}`).join(",")}}`;
 }
 function exactMessageHandleIdentity(value) {
   const text2 = value.trim();
@@ -11997,8 +12565,8 @@ function rowsByOwner(database, table, names) {
 }
 function sourceDatabasePaths(directory) {
   const base = realpathSync4(resolve4(directory));
-  const sourceDirectory = join5(base, "Sources");
-  const sourceIdentity = lstatSync5(sourceDirectory);
+  const sourceDirectory = join6(base, "Sources");
+  const sourceIdentity = lstatSync6(sourceDirectory);
   if (!sourceIdentity.isDirectory() || sourceIdentity.isSymbolicLink()) {
     throw new Error("Apple Contacts Sources must be a real directory");
   }
@@ -12009,7 +12577,7 @@ function sourceDatabasePaths(directory) {
     if (!/^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/u.test(entry.name)) {
       throw new Error("Apple Contacts source directory name is invalid");
     }
-    const candidateDirectory = join5(sourceDirectory, entry.name);
+    const candidateDirectory = join6(sourceDirectory, entry.name);
     const databases = readdirSync2(candidateDirectory, { withFileTypes: true }).filter((item) => item.isFile() && /^AddressBook-v\d+\.abcddb$/u.test(item.name));
     if (databases.length === 0)
       continue;
@@ -12018,8 +12586,8 @@ function sourceDatabasePaths(directory) {
     const databaseName = databases[0]?.name;
     if (databaseName === undefined)
       throw new Error("Apple Contacts database name is missing");
-    const candidate = join5(candidateDirectory, databaseName);
-    const identity = lstatSync5(candidate);
+    const candidate = join6(candidateDirectory, databaseName);
+    const identity = lstatSync6(candidate);
     const uid = typeof process.getuid === "function" ? process.getuid() : null;
     if (!identity.isFile() || identity.isSymbolicLink() || identity.size < 1 || identity.size > MAX_SOURCE_DATABASE_BYTES || uid !== null && identity.uid !== uid) {
       throw new Error(`Apple Contacts store ${entry.name} is not a supported private database`);
@@ -12107,12 +12675,12 @@ function readStore(storeKey, path) {
       throw new Error("Apple Contacts snapshot exceeds its row limit");
     const identifiers = new Set;
     const entries = [];
-    for (const record of records) {
-      const primaryKey = record.Z_PK;
+    for (const record2 of records) {
+      const primaryKey = record2.Z_PK;
       if (typeof primaryKey !== "number" || !Number.isSafeInteger(primaryKey) || primaryKey < 1) {
         throw new Error("Apple Contacts record has an invalid primary key");
       }
-      const identifier = strictText(record.ZUNIQUEID, "Apple Contacts identifier", 1024);
+      const identifier = strictText(record2.ZUNIQUEID, "Apple Contacts identifier", 1024);
       if (identifiers.has(identifier))
         throw new Error("Apple Contacts identifiers are duplicated");
       identifiers.add(identifier);
@@ -12131,7 +12699,7 @@ function readStore(storeKey, path) {
         schemaVersion: 1,
         storeKey,
         contactIdentifier: identifier,
-        record: stableObject(record, metrics),
+        record: stableObject(record2, metrics),
         values
       });
       if (byteLength(rawJson) > MAX_CONTACT_JSON_BYTES) {
@@ -12154,12 +12722,12 @@ function readStore(storeKey, path) {
       entries.push({
         storeKey,
         identifier,
-        displayName: optionalText(record.ZNAME),
-        givenName: optionalText(record.ZFIRSTNAME),
-        familyName: optionalText(record.ZLASTNAME),
-        organization: optionalText(record.ZORGANIZATION),
-        title: optionalText(record.ZJOBTITLE),
-        birthday: appleBirthday(record),
+        displayName: optionalText(record2.ZNAME),
+        givenName: optionalText(record2.ZFIRSTNAME),
+        familyName: optionalText(record2.ZLASTNAME),
+        organization: optionalText(record2.ZORGANIZATION),
+        title: optionalText(record2.ZJOBTITLE),
+        birthday: appleBirthday(record2),
         emails,
         phones,
         rawJson,
@@ -12870,7 +13438,7 @@ function isProviderPluginOperationName(value) {
 
 // node_modules/@hraness/ghostget/dist/index-gwk7rbyj.js
 import { createHash as createHash4 } from "crypto";
-function isRecord(value) {
+function isRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function canonicalJson2(value) {
@@ -12886,7 +13454,7 @@ function canonicalJson2(value) {
   if (Array.isArray(value)) {
     return `[${value.map((item) => canonicalJson2(item)).join(",")}]`;
   }
-  if (isRecord(value)) {
+  if (isRecord2(value)) {
     const entries = Object.entries(value).filter(([, item]) => item !== undefined).sort(([left], [right]) => left.localeCompare(right));
     return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${canonicalJson2(item)}`).join(",")}}`;
   }
@@ -12898,7 +13466,7 @@ function sha2563(value) {
 
 // node_modules/@hraness/ghostget/dist/client.js
 import { spawn, spawnSync } from "child_process";
-import { existsSync as existsSync4 } from "fs";
+import { existsSync as existsSync3 } from "fs";
 import { fileURLToPath as fileURLToPath2 } from "url";
 import { types as nodeTypes } from "util";
 var PORTABLE_OPERATION_IDENTITY_VERSION = 1;
@@ -12947,22 +13515,22 @@ function identityRecord(value) {
   return result;
 }
 function parsePortableOperationIdentityV1(value) {
-  const record = identityRecord(value);
-  if (typeof record.pluginId !== "string" || record.pluginId.length > 128 || !pluginIdPattern.test(record.pluginId) || typeof record.pluginVersion !== "string" || record.pluginVersion.length > 128 || !pluginVersionPattern.test(record.pluginVersion) || record.hostApiVersion !== 1 || typeof record.bundleSha256 !== "string" || !sha256Pattern.test(record.bundleSha256) || typeof record.manifestSha256 !== "string" || !sha256Pattern.test(record.manifestSha256) || typeof record.adapterId !== "string" || !adapterIdPattern.test(record.adapterId) || record.transport !== "provider-api" && record.transport !== "web-session-api" && record.transport !== "linked-device" || typeof record.surfaceId !== "string" || record.surfaceId.length > 128 || !pluginIdPattern.test(record.surfaceId) || typeof record.operation !== "string" || !operationPattern.test(record.operation) || typeof record.contractVersion !== "number" || !Number.isSafeInteger(record.contractVersion) || record.contractVersion < 1 || record.contractVersion > 1e6 || typeof record.descriptorSha256 !== "string" || !sha256Pattern.test(record.descriptorSha256)) {
+  const record2 = identityRecord(value);
+  if (typeof record2.pluginId !== "string" || record2.pluginId.length > 128 || !pluginIdPattern.test(record2.pluginId) || typeof record2.pluginVersion !== "string" || record2.pluginVersion.length > 128 || !pluginVersionPattern.test(record2.pluginVersion) || record2.hostApiVersion !== 1 || typeof record2.bundleSha256 !== "string" || !sha256Pattern.test(record2.bundleSha256) || typeof record2.manifestSha256 !== "string" || !sha256Pattern.test(record2.manifestSha256) || typeof record2.adapterId !== "string" || !adapterIdPattern.test(record2.adapterId) || record2.transport !== "provider-api" && record2.transport !== "web-session-api" && record2.transport !== "linked-device" || typeof record2.surfaceId !== "string" || record2.surfaceId.length > 128 || !pluginIdPattern.test(record2.surfaceId) || typeof record2.operation !== "string" || !operationPattern.test(record2.operation) || typeof record2.contractVersion !== "number" || !Number.isSafeInteger(record2.contractVersion) || record2.contractVersion < 1 || record2.contractVersion > 1e6 || typeof record2.descriptorSha256 !== "string" || !sha256Pattern.test(record2.descriptorSha256)) {
     throw new Error("portable operation identity is malformed");
   }
   return Object.freeze({
-    pluginId: record.pluginId,
-    pluginVersion: record.pluginVersion,
+    pluginId: record2.pluginId,
+    pluginVersion: record2.pluginVersion,
     hostApiVersion: 1,
-    bundleSha256: record.bundleSha256,
-    manifestSha256: record.manifestSha256,
-    adapterId: record.adapterId,
-    transport: record.transport,
-    surfaceId: record.surfaceId,
-    operation: record.operation,
-    contractVersion: record.contractVersion,
-    descriptorSha256: record.descriptorSha256
+    bundleSha256: record2.bundleSha256,
+    manifestSha256: record2.manifestSha256,
+    adapterId: record2.adapterId,
+    transport: record2.transport,
+    surfaceId: record2.surfaceId,
+    operation: record2.operation,
+    contractVersion: record2.contractVersion,
+    descriptorSha256: record2.descriptorSha256
   });
 }
 var MAX_INPUT_BYTES = 1024 * 1024;
@@ -12999,14 +13567,14 @@ function expectedRequestAuthId(request, authKind) {
   }
   return request.authId ?? request.adapterId;
 }
-function isRecord2(value) {
+function isRecord3(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function isUnknownArray(value) {
   return Array.isArray(value);
 }
-function record(value, label) {
-  if (!isRecord2(value) || nodeTypes.isProxy(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
+function record2(value, label) {
+  if (!isRecord3(value) || nodeTypes.isProxy(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
     throw new Error(`${label} must be a plain data object`);
   const descriptors = Object.getOwnPropertyDescriptors(value);
   if (Reflect.ownKeys(descriptors).some((key) => typeof key !== "string")) {
@@ -13043,13 +13611,13 @@ var clientReadFailureRetryDisposition = Object.freeze({
   "cleanup-required": "do-not-retry"
 });
 function parseClientReadFailure(value) {
-  const failure = record(value, "Ghostget read failure");
-  assertExactKeys(failure, ["category", "retryDisposition"], [], "Ghostget read failure");
-  const category = failure.category;
+  const failure2 = record2(value, "Ghostget read failure");
+  assertExactKeys(failure2, ["category", "retryDisposition"], [], "Ghostget read failure");
+  const category = failure2.category;
   if (typeof category !== "string" || !Object.hasOwn(clientReadFailureRetryDisposition, category))
     throw new Error("Ghostget read failure category is malformed");
   const retryDisposition = clientReadFailureRetryDisposition[category];
-  if (failure.retryDisposition !== retryDisposition) {
+  if (failure2.retryDisposition !== retryDisposition) {
     throw new Error("Ghostget read failure retry disposition is inconsistent");
   }
   return Object.freeze({ category, retryDisposition });
@@ -13180,7 +13748,7 @@ function safeInteger(value, label, minimum, maximum) {
   }
   return value;
 }
-function timestamp2(value, label) {
+function timestamp3(value, label) {
   const text2 = safeString(value, label, 64);
   const date = new Date(text2);
   if (!Number.isFinite(date.getTime()) || date.toISOString() !== text2) {
@@ -13196,10 +13764,10 @@ function boundedMessage(value) {
 }
 function cliSourcePath() {
   const besideSource = fileURLToPath2(new URL("./cli.ts", import.meta.url));
-  if (existsSync4(besideSource))
+  if (existsSync3(besideSource))
     return besideSource;
   const packagedSource = fileURLToPath2(new URL("../src/cli.ts", import.meta.url));
-  if (existsSync4(packagedSource))
+  if (existsSync3(packagedSource))
     return packagedSource;
   throw new Error("the installed Ghostget CLI source is unavailable");
 }
@@ -13230,7 +13798,7 @@ 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) {
+  if (!isRecord3(overrides) || nodeTypes.isProxy(overrides) || Object.getPrototypeOf(overrides) !== Object.prototype && Object.getPrototypeOf(overrides) !== null) {
     throw new Error("Ghostget client environment must use a plain, non-proxy object");
   }
   const descriptors = Object.getOwnPropertyDescriptors(overrides);
@@ -13269,7 +13837,7 @@ function isBrandedAbortSignal(value) {
   }
 }
 function snapshotClientOptions(optionsValue, mode) {
-  if (!isRecord2(optionsValue) || nodeTypes.isProxy(optionsValue) || Object.getPrototypeOf(optionsValue) !== Object.prototype && Object.getPrototypeOf(optionsValue) !== null)
+  if (!isRecord3(optionsValue) || nodeTypes.isProxy(optionsValue) || Object.getPrototypeOf(optionsValue) !== Object.prototype && Object.getPrototypeOf(optionsValue) !== null)
     throw new Error("Ghostget client options must use a plain, non-proxy object");
   const descriptors = Object.getOwnPropertyDescriptors(optionsValue);
   const keys = Reflect.ownKeys(descriptors);
@@ -13323,13 +13891,13 @@ function snapshotClientOptions(optionsValue, mode) {
 }
 function prepareRequest(requestValue) {
   const snapshot = snapshotJson(requestValue, "Ghostget client request");
-  const request = record(snapshot, "Ghostget client request");
+  const request = record2(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))
+  if (!isRecord3(rawInput))
     throw new Error("input must be a JSON object");
   const input = canonicalJson2(rawInput);
   if (Buffer.byteLength(input, "utf8") > MAX_INPUT_BYTES) {
@@ -13377,7 +13945,7 @@ function parseOutput(text2, label) {
     throw new Error(`${label} exceeds its byte bound`);
   }
   try {
-    return record(JSON.parse(text2), label);
+    return record2(JSON.parse(text2), label);
   } catch (error) {
     if (error instanceof Error && error.message === `${label} must be an object`)
       throw error;
@@ -13424,7 +13992,7 @@ function observeProjectionIdentity(request, options) {
       "inputHash",
       "projection"
     ], [], "Ghostget projection identity response");
-    const projection = record(value.projection, "Ghostget projection identity");
+    const projection = record2(value.projection, "Ghostget projection identity");
     assertExactKeys(projection, ["key"], [], "Ghostget projection identity");
     return Object.freeze({
       status: "ready",
@@ -13473,9 +14041,9 @@ function parseExecutionPreview(value, request) {
   ], [], "Ghostget execution identity preview");
   if (value.ok !== true || value.status !== "preview" || value.requiresConfirmation !== false || value.risk !== "R1")
     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");
+  const adapterValue = record2(value.adapter, "Ghostget execution identity preview adapter");
+  const auth = record2(value.auth, "Ghostget execution identity preview auth");
+  const binding2 = record2(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");
@@ -13526,7 +14094,7 @@ function parseCatalogExecutionIdentity(value, request, preview) {
   if (value.adapters.length !== 1) {
     throw new Error("Ghostget execution identity catalog is ambiguous");
   }
-  const adapterValue = record(value.adapters[0], "Ghostget execution identity catalog adapter");
+  const adapterValue = record2(value.adapters[0], "Ghostget execution identity catalog adapter");
   assertExactKeys(adapterValue, [
     "id",
     "version",
@@ -13543,7 +14111,7 @@ function parseCatalogExecutionIdentity(value, request, preview) {
   });
   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("Ghostget execution identity preflights disagreed");
-  const operations = adapterValue.operations.filter((candidate) => isRecord2(candidate) && candidate.id === request.operationId);
+  const operations = adapterValue.operations.filter((candidate) => isRecord3(candidate) && candidate.id === request.operationId);
   if (operations.length !== 1) {
     throw new Error("Ghostget execution identity catalog operation is ambiguous");
   }
@@ -13756,7 +14324,7 @@ function runLiveCommandSync(command, options) {
   return parseOutput(stdout, "Ghostget live response");
 }
 function parsePublication(value) {
-  const publication = record(value, "Ghostget cache publication");
+  const publication = record2(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")
@@ -13766,8 +14334,8 @@ function parsePublication(value) {
   return Object.freeze({
     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"),
+    validatedAt: timestamp3(publication.validatedAt, "Ghostget cache publication validation time"),
+    dataChangedAt: timestamp3(publication.dataChangedAt, "Ghostget cache publication data-change time"),
     disposition,
     ...publication.currentDataRevision === undefined ? {} : {
       currentDataRevision: digest(publication.currentDataRevision, "Ghostget current cache data revision")
@@ -13775,7 +14343,7 @@ function parsePublication(value) {
   });
 }
 function parseCacheOutcome(value) {
-  const outcome = record(value, "Ghostget cache outcome");
+  const outcome = record2(value, "Ghostget cache outcome");
   if (outcome.status === "stored") {
     assertExactKeys(outcome, ["status", "publication"], [], "Ghostget cache outcome");
     return Object.freeze({ status: "stored", publication: parsePublication(outcome.publication) });
@@ -13950,7 +14518,7 @@ function parseLocalCliToolIdentity(value) {
   });
 }
 function parseLocalCliContractIdentity(value) {
-  const identity = record(value, "Ghostget local CLI contract identity");
+  const identity = record2(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");
@@ -13963,7 +14531,7 @@ function parseLocalCliContractIdentity(value) {
   });
 }
 function parseLiveReceipt(value, request, expectedInputHash) {
-  const receipt = record(value, "Ghostget live receipt");
+  const receipt = record2(value, "Ghostget live receipt");
   const commonKeys = [
     "schemaVersion",
     "runId",
@@ -13997,9 +14565,9 @@ function parseLiveReceipt(value, request, expectedInputHash) {
   } else {
     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");
+  const adapter = record2(receipt.adapter, "Ghostget live receipt adapter");
+  const auth = record2(receipt.auth, "Ghostget live receipt auth");
+  const dispatch = record2(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");
@@ -14024,8 +14592,8 @@ function parseLiveReceipt(value, request, expectedInputHash) {
   if (receipt.planDigest !== null) {
     throw new Error("Ghostget live receipt plan digest is malformed");
   }
-  const startedAt = timestamp2(receipt.startedAt, "Ghostget live receipt start time");
-  const finishedAt = timestamp2(receipt.finishedAt, "Ghostget live receipt finish time");
+  const startedAt = timestamp3(receipt.startedAt, "Ghostget live receipt start time");
+  const finishedAt = timestamp3(receipt.finishedAt, "Ghostget live receipt finish time");
   if (startedAt > finishedAt) {
     throw new Error("Ghostget live receipt finished before it started");
   }
@@ -14210,7 +14778,7 @@ var GHOSTGET_VERSION = "0.17.3";
 
 // node_modules/@hraness/ghostget/dist/beeper-client.js
 import { spawnSync as spawnSync2 } from "child_process";
-import { existsSync as existsSync5 } from "fs";
+import { existsSync as existsSync4 } from "fs";
 import { fileURLToPath as fileURLToPath3 } from "url";
 import { types as nodeTypes3 } from "util";
 import { types as nodeTypes2 } from "util";
@@ -15776,7 +16344,7 @@ function hasWellFormedUnicode(value) {
   }
   return true;
 }
-function record2(value, label) {
+function record3(value, label) {
   if (nodeTypes4.isProxy(value) || typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null)
     throw new Error(`${label} must be a plain data object`);
   const descriptors = Object.getOwnPropertyDescriptors(value);
@@ -15926,7 +16494,7 @@ function surfaceCanonicalJson(value) {
   return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${surfaceCanonicalJson(item)}`).join(",")}}`;
 }
 function parseDefault(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   const kind = exactEnum(source.kind, `${label}.kind`, [
     "none",
     "literal",
@@ -15963,7 +16531,7 @@ function parseDefault(value, label) {
   return Object.freeze({ kind, name });
 }
 function parseDecision(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, [
     "disposition",
     "rationale",
@@ -15995,7 +16563,7 @@ function parseDecision(value, label) {
   });
 }
 function parsePathSemanticInputs(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   const entries = Object.entries(source);
   if (entries.length > 128) {
     throw new Error(`${label} exceeds its semantic input bound`);
@@ -16023,7 +16591,7 @@ function parsePredicate(value, label, traversal, depth = 0) {
   if (traversal.nodes > 1e4) {
     throw new Error("local CLI surface predicates exceed the whole-contract node bound");
   }
-  const source = record2(value, label);
+  const source = record3(value, label);
   const op = exactEnum(source.op, `${label}.op`, [
     "true",
     "present",
@@ -16062,7 +16630,7 @@ function parsePredicate(value, label, traversal, depth = 0) {
   return Object.freeze({ op, predicates: Object.freeze(predicates) });
 }
 function parseRule(value, label, predicateTraversal) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, [
     "namespace",
     "when",
@@ -16093,7 +16661,7 @@ function parseRule(value, label, predicateTraversal) {
   });
 }
 function parseArgument(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, [
     "name",
     "position",
@@ -16131,7 +16699,7 @@ function parseArgument(value, label) {
   });
 }
 function parseFlag(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, [
     "name",
     "aliases",
@@ -16184,7 +16752,7 @@ function parseFlag(value, label) {
   });
 }
 function parseOutput2(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, [
     "shape",
     "completeness",
@@ -16209,7 +16777,7 @@ function parseOutput2(value, label) {
   });
 }
 function parseReconciliation(value, label, predicateTraversal) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, ["availability", "namespace", "predicate", "rationale"], [], label);
   const availability = exactEnum(source.availability, `${label}.availability`, [
     "none",
@@ -16232,7 +16800,7 @@ function parseReconciliation(value, label, predicateTraversal) {
   });
 }
 function parseCommand(value, label, predicateTraversal) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, [
     "path",
     "provenance",
@@ -16305,7 +16873,7 @@ function parseCommand(value, label, predicateTraversal) {
   });
 }
 function parseAdditionalEntry(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, [
     "path",
     "provenance",
@@ -16381,7 +16949,7 @@ function ruleFieldNames(rule) {
   ]);
 }
 function parseArtifact(value, label) {
-  const source = record2(value, label);
+  const source = record3(value, label);
   exactKeys(source, ["platform", "arch", "archiveSha256", "executableSha256"], [], label);
   return Object.freeze({
     platform: string(source.platform, `${label}.platform`, 32),
@@ -16391,7 +16959,7 @@ function parseArtifact(value, label) {
   });
 }
 function parseDefinition(value) {
-  const source = record2(value, "local CLI surface contract");
+  const source = record3(value, "local CLI surface contract");
   exactKeys(source, [
     "schemaVersion",
     "format",
@@ -16407,7 +16975,7 @@ function parseDefinition(value) {
   if (source.schemaVersion !== 1 || source.format !== "wrench.local-cli-surface") {
     throw new Error("local CLI surface contract version is unsupported");
   }
-  const executable = record2(source.executable, "local CLI surface executable");
+  const executable = record3(source.executable, "local CLI surface executable");
   exactKeys(executable, [
     "id",
     "implementation",
@@ -16420,7 +16988,7 @@ function parseDefinition(value) {
     "runtimeReportedVersion",
     "artifacts"
   ], [], "local CLI surface executable");
-  const sourceIdentity = record2(source.source, "local CLI surface source");
+  const sourceIdentity = record3(source.source, "local CLI surface source");
   exactKeys(sourceIdentity, [
     "package",
     "packagePath",
@@ -16432,9 +17000,9 @@ function parseDefinition(value) {
     "generatedCanonicalEntries",
     "registeredKeys"
   ], [], "local CLI surface source");
-  const sdk = record2(source.sdk, "local CLI surface SDK");
+  const sdk = record3(source.sdk, "local CLI surface SDK");
   exactKeys(sdk, ["package", "version", "commit"], [], "local CLI surface SDK");
-  const runtime = record2(source.runtime, "local CLI surface runtime");
+  const runtime = record3(source.runtime, "local CLI surface runtime");
   exactKeys(runtime, [
     "providerPluginId",
     "providerPluginVersion",
@@ -16446,7 +17014,7 @@ function parseDefinition(value) {
     "realm",
     "compatibility"
   ], [], "local CLI surface runtime");
-  const rawOperationContractVersions = record2(runtime.operationContractVersions, "local CLI surface runtime.operationContractVersions");
+  const rawOperationContractVersions = record3(runtime.operationContractVersions, "local CLI surface runtime.operationContractVersions");
   const operationContractVersionKeys = Object.keys(rawOperationContractVersions).sort(codePointCompare);
   if (operationContractVersionKeys.length < 1 || operationContractVersionKeys.length > 1000) {
     throw new Error("local CLI surface runtime.operationContractVersions must contain 1 to 1000 operations");
@@ -16460,12 +17028,12 @@ function parseDefinition(value) {
       integer(rawOperationContractVersions[operation], `local CLI surface runtime.operationContractVersions.${operation}`, 1, 1e6)
     ];
   })));
-  const rawOperationInputTypes = record2(runtime.operationInputTypes, "local CLI surface runtime.operationInputTypes");
+  const rawOperationInputTypes = record3(runtime.operationInputTypes, "local CLI surface runtime.operationInputTypes");
   const operationInputTypeKeys = Object.keys(rawOperationInputTypes).sort(codePointCompare);
   if (operationInputTypeKeys.length !== operationContractVersionKeys.length || operationInputTypeKeys.some((operation, index) => operation !== operationContractVersionKeys[index]))
     throw new Error("local CLI surface runtime input fields must exactly cover operation versions");
   const operationInputTypes = Object.freeze(Object.fromEntries(operationInputTypeKeys.map((operation) => {
-    const rawFields = record2(rawOperationInputTypes[operation], `local CLI surface runtime.operationInputTypes.${operation}`);
+    const rawFields = record3(rawOperationInputTypes[operation], `local CLI surface runtime.operationInputTypes.${operation}`);
     const fields = Object.keys(rawFields).sort(codePointCompare);
     if (fields.length > 256 || fields.some((field) => !/^[a-z][a-z0-9]*(?:_[a-z0-9]+)*$/u.test(field)))
       throw new Error("local CLI surface runtime contains invalid semantic input fields");
@@ -18218,7 +18786,7 @@ function integer2(value, label) {
     return fail2(`${label} must be a non-negative integer`);
   return value;
 }
-function timestamp3(value, label) {
+function timestamp4(value, label) {
   const parsed = coordinate(value, label);
   const date = new Date(parsed);
   if (!Number.isFinite(date.getTime()) || date.toISOString() !== parsed) {
@@ -18227,7 +18795,7 @@ function timestamp3(value, label) {
   return parsed;
 }
 function nullableTimestamp(value, label) {
-  return value === null ? null : timestamp3(value, label);
+  return value === null ? null : timestamp4(value, label);
 }
 function providerId(kind, ...parts) {
   return `beeper-${kind}:${sha2563(canonicalJson2(parts))}`;
@@ -18353,7 +18921,7 @@ function parseBeeperContactInteractionSummary(value) {
       network: token(account.network, `summary.accounts[${String(index)}].network`, MAX_NETWORK_BYTES),
       selfParticipantId,
       selfParticipantProviderId,
-      observedAt: timestamp3(account.observedAt, `summary.accounts[${String(index)}].observedAt`)
+      observedAt: timestamp4(account.observedAt, `summary.accounts[${String(index)}].observedAt`)
     });
   }));
   const accountKeys = accounts.map((account) => account.accountId);
@@ -18404,8 +18972,8 @@ function parseBeeperContactInteractionSummary(value) {
     const conversationCount = integer2(interaction.conversationCount, `summary.interactions[${String(index)}].conversationCount`);
     if (interactionCount !== sentCount + receivedCount || interactionCount < 1 || conversationCount < 1 || conversationCount > interactionCount || interaction.reciprocal !== (sentCount > 0 && receivedCount > 0) || interaction.completeness !== "lower-bound")
       return fail2("an interaction has inconsistent counts or completeness");
-    const firstInteractionAt = timestamp3(interaction.firstInteractionAt, `summary.interactions[${String(index)}].firstInteractionAt`);
-    const lastInteractionAt = timestamp3(interaction.lastInteractionAt, `summary.interactions[${String(index)}].lastInteractionAt`);
+    const firstInteractionAt = timestamp4(interaction.firstInteractionAt, `summary.interactions[${String(index)}].firstInteractionAt`);
+    const lastInteractionAt = timestamp4(interaction.lastInteractionAt, `summary.interactions[${String(index)}].lastInteractionAt`);
     if (firstInteractionAt > lastInteractionAt)
       return fail2("interaction timestamps are reversed");
     const provenance = record22(interaction.provenance, `summary.interactions[${String(index)}].provenance`);
@@ -18437,7 +19005,7 @@ function parseBeeperContactInteractionSummary(value) {
         sourceVersion: BEEPER_CONTACT_INTERACTION_TRANSFORM.sourceVersion,
         providerId: "beeper",
         providerVersion,
-        observedAt: timestamp3(provenance.observedAt, `summary.interactions[${String(index)}].provenance.observedAt`)
+        observedAt: timestamp4(provenance.observedAt, `summary.interactions[${String(index)}].provenance.observedAt`)
       })
     });
   }));
@@ -18550,8 +19118,8 @@ function parseBeeperContactInteractionExportResult(value) {
   if (!/^[a-f0-9]{8}-[a-f0-9]{4}-4[a-f0-9]{3}-[89ab][a-f0-9]{3}-[a-f0-9]{12}$/u.test(runId)) {
     return fail2("export receipt.runId must be a lowercase UUID v4");
   }
-  const startedAt = timestamp3(source.startedAt, "export receipt.startedAt");
-  const finishedAt = timestamp3(source.finishedAt, "export receipt.finishedAt");
+  const startedAt = timestamp4(source.startedAt, "export receipt.startedAt");
+  const finishedAt = timestamp4(source.finishedAt, "export receipt.finishedAt");
   if (startedAt > finishedAt)
     return fail2("export receipt timestamps are reversed");
   const auth = record22(source.auth, "export receipt.auth");
@@ -18656,10 +19224,10 @@ function fail22(message) {
 }
 function cliSourcePath2() {
   const besideSource = fileURLToPath3(new URL("./cli.ts", import.meta.url));
-  if (existsSync5(besideSource))
+  if (existsSync4(besideSource))
     return besideSource;
   const packagedSource = fileURLToPath3(new URL("../src/cli.ts", import.meta.url));
-  if (existsSync5(packagedSource))
+  if (existsSync4(packagedSource))
     return packagedSource;
   return fail22("the installed Ghostget CLI source is unavailable");
 }
@@ -18822,7 +19390,7 @@ function digest3(value, label) {
     throw new Error(`${label} must be a SHA-256 digest.`);
   return value;
 }
-function timestamp4(value, label) {
+function timestamp5(value, label) {
   if (value === null)
     return null;
   const milliseconds = Date.parse(value);
@@ -18830,7 +19398,7 @@ function timestamp4(value, label) {
     throw new Error(`${label} must be an ISO timestamp.`);
   return new Date(milliseconds).toISOString();
 }
-function json3(value, label) {
+function json4(value, label) {
   const encoded = canonicalJson(value);
   if (Buffer.byteLength(encoded, "utf8") > 64 * 1024)
     throw new Error(`${label} exceeds its byte limit.`);
@@ -18852,13 +19420,13 @@ function recordSourceExecutionReceipt(database, input) {
   if (!DIGEST2.test(input.inputSha256))
     throw new Error("Execution input identity must be a SHA-256 digest.");
   const externalRunIdSha256 = sha256(token2(input.externalRunId, "External execution ID", 512));
-  const startedAt = timestamp4(input.startedAt, "Execution start");
-  const completedAt = timestamp4(input.completedAt, "Execution completion");
+  const startedAt = timestamp5(input.startedAt, "Execution start");
+  const completedAt = timestamp5(input.completedAt, "Execution completion");
   if (completedAt !== null && completedAt < startedAt)
     throw new Error("Execution timing is invalid.");
-  const usageJson = json3(input.usage, "Execution usage");
-  const costJson = json3(input.cost, "Execution cost");
-  const metadataJson = json3(input.metadata, "Execution metadata");
+  const usageJson = json4(input.usage, "Execution usage");
+  const costJson = json4(input.cost, "Execution cost");
+  const metadataJson = json4(input.metadata, "Execution metadata");
   const existing = database.query(`SELECT id,provider,account_key,capability,operation,transport,
       implementation_id,implementation_version,implementation_sha256,contract_sha256,
       external_run_id_sha256,input_sha256,outcome,usage_json,cost_json,metadata_json,
@@ -19396,7 +19964,7 @@ var AUTH_ID = /^[a-z][a-z0-9-]{0,127}$/u;
 var EMAIL = /^[^@\s]+@[^@\s]+$/u;
 var DEFAULT_BEEPER_AUTH = "beeper-main";
 var DEFAULT_BEEPER_CONTACT_LIMIT = 200;
-function record3(value, label) {
+function record4(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value))
     throw new Error(`${label} must be an object`);
   let prototype;
@@ -19453,7 +20021,7 @@ var CONTACTS_LIST_BLENDED_WARNING = "beeper-desktop-blended-contact-list-has-no-
 function parseContinuation(value) {
   if (value === null)
     return null;
-  const parsed = record3(value, "Beeper continuation");
+  const parsed = record4(value, "Beeper continuation");
   exact(parsed, ["direction", "cursor"], "Beeper continuation");
   const direction = text2(parsed.direction, "Beeper continuation.direction", 16);
   if (direction !== "before" && direction !== "after")
@@ -19461,7 +20029,7 @@ function parseContinuation(value) {
   return { direction, cursor: text2(parsed.cursor, "Beeper continuation.cursor", 2048) };
 }
 function parseUser(value, label) {
-  const parsed = record3(value, label);
+  const parsed = record4(value, label);
   exact(parsed, ["id", "fullName", "username", "phoneNumber", "email", "isSelf", "cannotMessage"], label);
   return {
     id: text2(parsed.id, `${label}.id`, 2048),
@@ -19474,9 +20042,9 @@ function parseUser(value, label) {
   };
 }
 function parseAccount(value, label) {
-  const parsed = record3(value, label);
+  const parsed = record4(value, label);
   exact(parsed, ["accountId", "bridge", "network", "loginId", "status", "statusText", "user"], label);
-  const bridge = record3(parsed.bridge, `${label}.bridge`);
+  const bridge = record4(parsed.bridge, `${label}.bridge`);
   exact(bridge, ["id", "type", "provider"], `${label}.bridge`);
   const provider = text2(bridge.provider, `${label}.bridge.provider`, 64);
   if (!["cloud", "self-hosted", "local", "platform-sdk"].includes(provider))
@@ -19514,7 +20082,7 @@ var CONTACT_STATS_KEYS = [
   "receivedStatsIncompleteReasons"
 ];
 function parseContact(value, label) {
-  const parsed = record3(value, label);
+  const parsed = record4(value, label);
   exact(parsed, [
     "accountId",
     "id",
@@ -19570,7 +20138,7 @@ function parseBeeperContactPage(value, input, authId) {
     }
   });
   const execution = validated.execution;
-  const output = record3(validated.output, "Beeper contact output");
+  const output = record4(validated.output, "Beeper contact output");
   exact(output, [
     "provider",
     "operation",
@@ -19607,7 +20175,7 @@ function parseBeeperContactPage(value, input, authId) {
   }
   if (new Set(contacts.map((contact) => `${contact.accountId}\x00${contact.id}`)).size !== contacts.length)
     throw new Error("Beeper contacts repeat an account-scoped stable ID");
-  const completeness = record3(output.completeness, "Beeper completeness");
+  const completeness = record4(output.completeness, "Beeper completeness");
   exact(completeness, [
     "localPageComplete",
     "resultWindowComplete",
@@ -20293,7 +20861,7 @@ var MAX_QUERIES = 50;
 var MAX_RESULTS = 20;
 var SHA2562 = /^[a-f0-9]{64}$/u;
 var AUTH_ID2 = /^[a-z][a-z0-9-]{0,127}$/u;
-function record4(value, label) {
+function record5(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
     throw new Error(`${label} must be an object`);
   }
@@ -20387,7 +20955,7 @@ function sourceRealm2(account) {
   };
 }
 function parseContact2(value, label) {
-  const parsed = record4(value, label);
+  const parsed = record5(value, label);
   exact2(parsed, ["accountId", "network", "id", "fullName", "username", "isSelf"], label);
   return {
     accountId: text3(parsed.accountId, `${label}.accountId`, 512),
@@ -20399,7 +20967,7 @@ function parseContact2(value, label) {
   };
 }
 function parseParticipant(value, label) {
-  const parsed = record4(value, label);
+  const parsed = record5(value, label);
   exact2(parsed, ["id", "fullName", "username", "isSelf"], label);
   return {
     id: text3(parsed.id, `${label}.id`, 2048),
@@ -20409,11 +20977,11 @@ function parseParticipant(value, label) {
   };
 }
 function parseConversation(value, label) {
-  const parsed = record4(value, label);
+  const parsed = record5(value, label);
   exact2(parsed, ["id", "accountId", "network", "title", "type", "direct", "participants"], label);
   if (parsed.type !== "single" && parsed.type !== "group")
     throw new Error(`${label}.type is unsupported`);
-  const participants = record4(parsed.participants, `${label}.participants`);
+  const participants = record5(parsed.participants, `${label}.participants`);
   exact2(participants, ["items", "total", "hasMore"], `${label}.participants`);
   const items = boundedArray2(participants.items, `${label}.participants.items`, 2000).map((item, index) => parseParticipant(item, `${label}.participants.items[${index}]`));
   return {
@@ -20456,7 +21024,7 @@ function parseSearchPage(value, operation, input, authId) {
     }
   });
   const execution = validated.execution;
-  const output = record4(validated.output, "Beeper search output");
+  const output = record5(validated.output, "Beeper search output");
   const itemsKey = operation === "contacts.search" ? "contacts" : "conversations";
   exact2(output, [
     "provider",
@@ -20489,7 +21057,7 @@ function parseSearchPage(value, operation, input, authId) {
   if (new Set(items.map((item) => `${item.accountId}\x00${item.id}`)).size !== items.length) {
     throw new Error("Beeper search repeated an account-scoped coordinate");
   }
-  const completeness = record4(output.completeness, "Beeper search completeness");
+  const completeness = record5(output.completeness, "Beeper search completeness");
   const remoteKey = operation === "contacts.search" ? "remoteContactSetComplete" : "remoteConversationSetComplete";
   exact2(completeness, [
     "resultWindowComplete",
@@ -20835,7 +21403,7 @@ function parseCandidateProjection(value) {
   } catch {
     throw new Error("Stored search candidate projection is malformed.");
   }
-  const parsed = record4(decoded, "Stored search candidate");
+  const parsed = record5(decoded, "Stored search candidate");
   exact2(parsed, [
     "schemaVersion",
     "accountKey",
@@ -20872,7 +21440,7 @@ function parseAcceptanceResult(value) {
   } catch {
     throw new Error("Stored candidate acceptance result is malformed.");
   }
-  const parsed = record4(decoded, "Stored candidate acceptance result");
+  const parsed = record5(decoded, "Stored candidate acceptance result");
   exact2(parsed, [
     "candidate_token",
     "person_id",
@@ -21085,7 +21653,7 @@ function collectionSpec(collection) {
     throw new Error("Google contact collection is unsupported");
   return spec;
 }
-function record5(value, label) {
+function record6(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
     throw new Error(`${label} must be a plain object`);
   }
@@ -21155,7 +21723,7 @@ function stableJson2(value) {
   }
   if (Array.isArray(value))
     return `[${value.map(stableJson2).join(",")}]`;
-  const parsed = record5(value, "canonical JSON");
+  const parsed = record6(value, "canonical JSON");
   return `{${Object.keys(parsed).sort().map((key) => `${JSON.stringify(key)}:${stableJson2(parsed[key])}`).join(",")}}`;
 }
 function array2(value, label, maximum = 100) {
@@ -21166,11 +21734,11 @@ function array2(value, label, maximum = 100) {
 function parseFieldMetadata(value, label) {
   if (value === null)
     return null;
-  const parsed = record5(value, label);
+  const parsed = record6(value, label);
   exact3(parsed, ["primary", "sourcePrimary", "verified", "source"], label);
   let source = null;
   if (parsed.source !== null) {
-    const item = record5(parsed.source, `${label}.source`);
+    const item = record6(parsed.source, `${label}.source`);
     exact3(item, ["type", "id"], `${label}.source`);
     const type = text4(item.type, `${label}.source.type`, 64);
     if (!SOURCE_TYPES.has(type))
@@ -21185,7 +21753,7 @@ function parseFieldMetadata(value, label) {
   };
 }
 function parseDateObject(value, label) {
-  const parsed = record5(value, label);
+  const parsed = record6(value, label);
   exact3(parsed, ["year", "month", "day"], label);
   const year = integer5(parsed.year, `${label}.year`, 0, 9999);
   const month = integer5(parsed.month, `${label}.month`, 0, 12);
@@ -21204,7 +21772,7 @@ function parseDateObject(value, label) {
   return { year, month, day };
 }
 function parseGoogleDate(value, label) {
-  const parsed = record5(value, label);
+  const parsed = record6(value, label);
   exact3(parsed, ["date", "text", "metadata"], label);
   const date = parsed.date === null ? null : parseDateObject(parsed.date, `${label}.date`);
   const dateText = optionalText2(parsed.text, `${label}.text`, 1024);
@@ -21215,7 +21783,7 @@ function parseGoogleDate(value, label) {
   return { date, text: dateText === "" ? null : dateText, metadata: metadata2 };
 }
 function parseGoogleEvent(value, label) {
-  const parsed = record5(value, label);
+  const parsed = record6(value, label);
   exact3(parsed, ["date", "text", "metadata", "type", "formattedType"], label);
   if (parsed.text !== null)
     throw new Error(`${label}.text must be null`);
@@ -21228,7 +21796,7 @@ function parseGoogleEvent(value, label) {
   };
 }
 function parseContact3(value, label, spec) {
-  const parsed = record5(value, label);
+  const parsed = record6(value, label);
   exact3(parsed, [
     "resourceName",
     "etag",
@@ -21245,10 +21813,10 @@ function parseContact3(value, label, spec) {
     throw new Error(`${label}.resourceName is invalid for ${spec.id}`);
   let metadata2 = null;
   if (parsed.metadata !== null) {
-    const item = record5(parsed.metadata, `${label}.metadata`);
+    const item = record6(parsed.metadata, `${label}.metadata`);
     exact3(item, ["deleted", "sources"], `${label}.metadata`);
     const sources = array2(item.sources, `${label}.metadata.sources`).map((sourceValue, index) => {
-      const source = record5(sourceValue, `${label}.metadata.sources[${index}]`);
+      const source = record6(sourceValue, `${label}.metadata.sources[${index}]`);
       exact3(source, ["type", "id", "etag", "updateTime"], `${label}.metadata.sources[${index}]`);
       const type = text4(source.type, `${label}.metadata.sources[${index}].type`, 64);
       if (!SOURCE_TYPES.has(type))
@@ -21262,7 +21830,7 @@ function parseContact3(value, label, spec) {
   }
   let name = null;
   if (spec.includeDates && parsed.name !== null) {
-    const item = record5(parsed.name, `${label}.name`);
+    const item = record6(parsed.name, `${label}.name`);
     exact3(item, ["displayName", "givenName", "middleName", "familyName", "honorificPrefix", "honorificSuffix", "metadata"], `${label}.name`);
     name = {
       displayName: optionalText2(item.displayName, `${label}.name.displayName`, 2048),
@@ -21275,7 +21843,7 @@ function parseContact3(value, label, spec) {
     };
   }
   const emailAddresses = array2(parsed.emailAddresses, `${label}.emailAddresses`).map((entry, index) => {
-    const item = record5(entry, `${label}.emailAddresses[${index}]`);
+    const item = record6(entry, `${label}.emailAddresses[${index}]`);
     exact3(item, ["value", "canonicalValue", "type", "metadata"], `${label}.emailAddresses[${index}]`);
     const canonicalValue = optionalText2(item.canonicalValue, `${label}.emailAddresses[${index}].canonicalValue`, 254);
     if (canonicalValue !== null && (!EMAIL2.test(canonicalValue) || canonicalValue !== canonicalValue.toLowerCase())) {
@@ -21289,7 +21857,7 @@ function parseContact3(value, label, spec) {
     };
   });
   const phoneNumbers = array2(parsed.phoneNumbers, `${label}.phoneNumbers`).map((entry, index) => {
-    const item = record5(entry, `${label}.phoneNumbers[${index}]`);
+    const item = record6(entry, `${label}.phoneNumbers[${index}]`);
     exact3(item, ["value", "canonicalForm", "type", "metadata"], `${label}.phoneNumbers[${index}]`);
     return {
       value: text4(item.value, `${label}.phoneNumbers[${index}].value`, 256),
@@ -21299,7 +21867,7 @@ function parseContact3(value, label, spec) {
     };
   });
   const organizations = array2(parsed.organizations, `${label}.organizations`).map((entry, index) => {
-    const item = record5(entry, `${label}.organizations[${index}]`);
+    const item = record6(entry, `${label}.organizations[${index}]`);
     exact3(item, ["name", "title", "department", "type", "current"], `${label}.organizations[${index}]`);
     return {
       name: optionalText2(item.name, `${label}.organizations[${index}].name`, 2048),
@@ -21344,7 +21912,7 @@ function parsePage(value, input, auth, spec) {
     finalOrigin: null
   });
   const execution = validated.execution;
-  const output = record5(validated.output, "Ghostget output");
+  const output = record6(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("Ghostget Gmail contact projection drifted");
@@ -21545,7 +22113,7 @@ function upsertMethod(database, account, personId, providerResourceId, kind, val
     active=1`, personId, kind, value, normalized, label, primary ? 1 : 0, runId, runId, stableJson2(metadata2), providerResourceId);
 }
 function parseResult(value, collection) {
-  const parsed = record5(JSON.parse(value), "stored Google result");
+  const parsed = record6(JSON.parse(value), "stored Google result");
   exact3(parsed, ["collection", "source_rows", "people_created", "people_matched", "contacts_created", "contacts_updated", "emails_touched", "phones_touched", "birthdays_touched", "birthday_conflicts", "events_touched", "removed", "reconciled"], "stored Google result");
   for (const key of ["source_rows", "people_created", "people_matched", "contacts_created", "contacts_updated", "emails_touched", "phones_touched", "birthdays_touched", "birthday_conflicts", "events_touched", "removed"]) {
     integer5(parsed[key], `stored Google result.${key}`, 0, Number.MAX_SAFE_INTEGER);
@@ -21809,10 +22377,10 @@ function googleContactStats(database) {
 // src/local/providers/imessage.ts
 import { Database as Database4 } from "bun:sqlite";
 import { createHash as createHash6 } from "crypto";
-import { lstatSync as lstatSync6, realpathSync as realpathSync5 } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join6, resolve as resolve5 } from "path";
-var DEFAULT_IMESSAGE_DATABASE = join6(homedir3(), "Library", "Messages", "chat.db");
+import { lstatSync as lstatSync7, realpathSync as realpathSync5 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join7, resolve as resolve5 } from "path";
+var DEFAULT_IMESSAGE_DATABASE = join7(homedir4(), "Library", "Messages", "chat.db");
 var DEFAULT_IMESSAGE_ACCOUNT = "imessage-main";
 var DEFAULT_IMESSAGE_PAGE_SIZE = 1000;
 var MAX_DATABASE_BYTES = 4 * 1024 * 1024 * 1024;
@@ -21853,8 +22421,8 @@ function stableJson3(value) {
     return JSON.stringify(value);
   if (Array.isArray(value))
     return `[${value.map(stableJson3).join(",")}]`;
-  const record6 = value;
-  return `{${Object.keys(record6).sort().map((key) => `${JSON.stringify(key)}:${stableJson3(record6[key])}`).join(",")}}`;
+  const record7 = value;
+  return `{${Object.keys(record7).sort().map((key) => `${JSON.stringify(key)}:${stableJson3(record7[key])}`).join(",")}}`;
 }
 function sha2566(value) {
   return createHash6("sha256").update(value).digest("hex");
@@ -22256,7 +22824,7 @@ function syncIMessageRelationships(database, options = {}) {
   if (!Number.isSafeInteger(pageSize) || pageSize < 1 || pageSize > MAX_PAGE_SIZE)
     throw new Error(`iMessage page size must be between 1 and ${MAX_PAGE_SIZE}`);
   const requestedPath = resolve5(options.messagesDatabase ?? DEFAULT_IMESSAGE_DATABASE);
-  const identity = lstatSync6(requestedPath);
+  const identity = lstatSync7(requestedPath);
   const uid = typeof process.getuid === "function" ? process.getuid() : null;
   if (!identity.isFile() || identity.isSymbolicLink() || identity.size < 1 || identity.size > MAX_DATABASE_BYTES || uid !== null && identity.uid !== uid) {
     throw new Error("iMessage source must be a supported database owned by the current user");
@@ -22350,7 +22918,7 @@ function syncIMessageRelationships(database, options = {}) {
 
 // src/local/providers/instagram.ts
 import { createHash as createHash7 } from "crypto";
-import { closeSync as closeSync6, constants as constants6, fstatSync as fstatSync5, openSync as openSync6, readFileSync as readFileSync5, realpathSync as realpathSync6 } from "fs";
+import { closeSync as closeSync6, constants as constants7, fstatSync as fstatSync5, openSync as openSync6, readFileSync as readFileSync5, realpathSync as realpathSync6 } from "fs";
 
 // src/local/archive/zip.ts
 import { inflateRawSync } from "zlib";
@@ -22804,8 +23372,8 @@ function stableJson4(value) {
     return JSON.stringify(value);
   if (Array.isArray(value))
     return `[${value.map(stableJson4).join(",")}]`;
-  const record6 = value;
-  return `{${Object.keys(record6).sort().map((key) => `${JSON.stringify(key)}:${stableJson4(record6[key])}`).join(",")}}`;
+  const record7 = value;
+  return `{${Object.keys(record7).sort().map((key) => `${JSON.stringify(key)}:${stableJson4(record7[key])}`).join(",")}}`;
 }
 function plain(value, label) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
@@ -23102,7 +23670,7 @@ function parseArchive(bytes) {
 function readArchive(path) {
   if (typeof path !== "string" || path.length < 1 || path.includes("\x00"))
     throw new Error("Instagram archive path is invalid");
-  const descriptor = openSync6(path, constants6.O_RDONLY | (constants6.O_NOFOLLOW ?? 0));
+  const descriptor = openSync6(path, constants7.O_RDONLY | (constants7.O_NOFOLLOW ?? 0));
   try {
     const before = fstatSync5(descriptor);
     const uid = typeof process.getuid === "function" ? process.getuid() : null;
@@ -23340,7 +23908,7 @@ function instagramStatsAll(database) {
 
 // src/local/providers/x-archive.ts
 import { createHash as createHash8 } from "crypto";
-import { closeSync as closeSync7, constants as constants7, fstatSync as fstatSync6, openSync as openSync7, readSync as readSync2 } from "fs";
+import { closeSync as closeSync7, constants as constants8, fstatSync as fstatSync6, openSync as openSync7, readSync as readSync2 } from "fs";
 import { resolve as resolve6 } from "path";
 
 // src/local/archive/x-zip-file.ts
@@ -23874,8 +24442,8 @@ function stableJson5(value) {
     return JSON.stringify(value);
   if (Array.isArray(value))
     return `[${value.map(stableJson5).join(",")}]`;
-  const record6 = value;
-  return `{${Object.keys(record6).sort().map((key) => `${JSON.stringify(key)}:${stableJson5(record6[key])}`).join(",")}}`;
+  const record7 = value;
+  return `{${Object.keys(record7).sort().map((key) => `${JSON.stringify(key)}:${stableJson5(record7[key])}`).join(",")}}`;
 }
 function plain2(value, label) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
@@ -23925,7 +24493,7 @@ function username2(value, label) {
     throw new Error(`${label} is not an exact X username`);
   return parsed.toLowerCase();
 }
-function timestamp5(value, label) {
+function timestamp6(value, label) {
   const parsed = text5(value, label, 128, true);
   const milliseconds2 = Date.parse(parsed);
   if (!Number.isFinite(milliseconds2))
@@ -23978,7 +24546,7 @@ function parseAccount2(member) {
   text5(account.email, `${member.memberName}.email`);
   text5(account.createdVia, `${member.memberName}.createdVia`, 1024);
   if (account.createdAt !== undefined)
-    timestamp5(account.createdAt, `${member.memberName}.createdAt`);
+    timestamp6(account.createdAt, `${member.memberName}.createdAt`);
   const displayName = text5(account.accountDisplayName, `${member.memberName}.accountDisplayName`, 1024);
   const safe = { kind: "account", memberName: member.memberName, providerUserId, username: handle, displayName };
   return { ...safe, hash: sha2568(stableJson5(safe)) };
@@ -24074,7 +24642,7 @@ function parseTweetIdentities(member) {
     exactKeys5(wrapper, ["tweet"], label);
     const tweet = plain2(wrapper.tweet, `${label}.tweet`);
     exactKeys5(tweet, REVIEWED_TWEET_KEYS, `${label}.tweet`);
-    const observedAt = timestamp5(tweet.created_at, `${label}.tweet.created_at`);
+    const observedAt = timestamp6(tweet.created_at, `${label}.tweet.created_at`);
     let identityRecord2 = 0;
     const replyId = optionalOpaqueProviderId(tweet.in_reply_to_user_id, `${label}.tweet.in_reply_to_user_id`);
     const replyIdString = optionalOpaqueProviderId(tweet.in_reply_to_user_id_str, `${label}.tweet.in_reply_to_user_id_str`);
@@ -24149,7 +24717,7 @@ function validateMessageCreate(value, label) {
   const senderId = providerId3(message.senderId, `${label}.senderId`);
   const recipientId = optionalProviderId(message.recipientId, `${label}.recipientId`);
   const messageId = providerId3(message.id, `${label}.id`);
-  const createdAt = timestamp5(message.createdAt, `${label}.createdAt`);
+  const createdAt = timestamp6(message.createdAt, `${label}.createdAt`);
   return { senderId, recipientId, messageId, createdAt };
 }
 function validateMembershipEvent(value, label, kind) {
@@ -24168,7 +24736,7 @@ function validateMembershipEvent(value, label, kind) {
   if ((kind === "joinConversation" || kind === "participantsJoin") && event.participantsSnapshot === undefined && event.userIds === undefined) {
     throw new Error(`${label} has no participant inventory`);
   }
-  timestamp5(event.createdAt, `${label}.createdAt`);
+  timestamp6(event.createdAt, `${label}.createdAt`);
   return ids;
 }
 function parseMessages(member, selfId, group, seenMessageIds, conversationMembers) {
@@ -24315,7 +24883,7 @@ async function readArchive2(path) {
   if (typeof path !== "string" || path.length < 1 || path.includes("\x00"))
     throw new Error("X archive path is invalid");
   const locator = resolve6(path);
-  const descriptor = openSync7(locator, constants7.O_RDONLY | (constants7.O_NOFOLLOW ?? 0));
+  const descriptor = openSync7(locator, constants8.O_RDONLY | (constants8.O_NOFOLLOW ?? 0));
   try {
     const before = fstatSync6(descriptor, { bigint: true });
     const uid = typeof process.getuid === "function" ? BigInt(process.getuid()) : null;
@@ -24432,7 +25000,7 @@ function storedHistoricalIdentity(metadataJson, expectedProviderUserId) {
     throw new Error("stored X historical username is not canonical");
   }
   const rawObservedAt = text5(value.observedAt, "stored X historical timestamp", 128, true);
-  const observedAt = timestamp5(rawObservedAt, "stored X historical timestamp");
+  const observedAt = timestamp6(rawObservedAt, "stored X historical timestamp");
   if (observedAt !== rawObservedAt) {
     throw new Error("stored X historical timestamp is not canonical");
   }
@@ -24766,7 +25334,7 @@ function xArchiveStatsAll(database) {
 }
 
 // src/local/providers/linkedin.ts
-import { closeSync as closeSync8, constants as constants8, fstatSync as fstatSync7, openSync as openSync8, readFileSync as readFileSync6, realpathSync as realpathSync7 } from "fs";
+import { closeSync as closeSync8, constants as constants9, fstatSync as fstatSync7, openSync as openSync8, readFileSync as readFileSync6, realpathSync as realpathSync7 } from "fs";
 var PROVIDER10 = "linkedin";
 var MODE7 = "data-export-csv";
 var MAX_RECORDS3 = 1e6;
@@ -24889,16 +25457,16 @@ function selectedCsvRows(member, headers, selectedHeaders, maximumPreambleRows)
     } else {
       if (fields.length !== headers.length)
         throw new Error(`${member.memberName} row ${rowNumber} has the wrong column count`);
-      const record6 = {};
+      const record7 = {};
       for (const [index, header] of headers.entries()) {
         if (!selectedIndexes.has(index))
           continue;
         const value = fields[index];
         if (value === null)
           throw new Error(`${member.memberName} failed to retain an allowlisted field`);
-        record6[header] = value;
+        record7[header] = value;
       }
-      rows.push(record6);
+      rows.push(record7);
       if (rows.length > MAX_RECORDS3)
         throw new Error(`${member.memberName} exceeds its record limit`);
     }
@@ -25119,7 +25687,7 @@ function parseMessages2(member) {
 function readArchive3(path) {
   if (typeof path !== "string" || path.length < 1 || path.includes("\x00"))
     throw new Error("LinkedIn archive path is invalid");
-  const descriptor = openSync8(path, constants8.O_RDONLY | (constants8.O_NOFOLLOW ?? 0));
+  const descriptor = openSync8(path, constants9.O_RDONLY | (constants9.O_NOFOLLOW ?? 0));
   try {
     const before = fstatSync7(descriptor);
     const uid = typeof process.getuid === "function" ? process.getuid() : null;
@@ -25188,7 +25756,7 @@ function resultFromJson(value) {
   const parsed = JSON.parse(value);
   if (parsed === null || Array.isArray(parsed) || typeof parsed !== "object")
     throw new Error("stored LinkedIn result is malformed");
-  const record6 = parsed;
+  const record7 = parsed;
   const countKeys = [
     "connection_records",
     "connections_linked",
@@ -25206,18 +25774,18 @@ function resultFromJson(value) {
     "interaction_events"
   ];
   const expected = ["account_key", ...countKeys, "owner_profile_inferred", "remote_set_complete"].sort();
-  if (Object.keys(record6).sort().join("\x00") !== expected.join("\x00"))
+  if (Object.keys(record7).sort().join("\x00") !== expected.join("\x00"))
     throw new Error("stored LinkedIn result shape is malformed");
-  if (typeof record6.account_key !== "string" || record6.account_key.length < 1)
+  if (typeof record7.account_key !== "string" || record7.account_key.length < 1)
     throw new Error("stored LinkedIn account key is malformed");
   for (const key of countKeys) {
-    if (!Number.isSafeInteger(record6[key]) || Number(record6[key]) < 0)
+    if (!Number.isSafeInteger(record7[key]) || Number(record7[key]) < 0)
       throw new Error("stored LinkedIn result count is malformed");
   }
-  if (typeof record6.owner_profile_inferred !== "boolean" || record6.remote_set_complete !== false) {
+  if (typeof record7.owner_profile_inferred !== "boolean" || record7.remote_set_complete !== false) {
     throw new Error("stored LinkedIn result flags are malformed");
   }
-  return record6;
+  return record7;
 }
 function metadata2(value) {
   const parsed = JSON.parse(value);
@@ -25588,7 +26156,7 @@ function run8(database, sql, ...bindings) {
 function insertedId9(value) {
   return Number(value.lastInsertRowid);
 }
-function record6(value, label) {
+function record7(value, label) {
   if (value === null || typeof value !== "object" || Array.isArray(value))
     throw new Error(`${label} must be an object`);
   return value;
@@ -25611,7 +26179,7 @@ function text6(value, label, maximum) {
 function optionalText3(value, label, maximum) {
   return value === null ? null : text6(value, label, maximum);
 }
-function timestamp6(value, label) {
+function timestamp7(value, label) {
   const parsed = text6(value, label, 64);
   const milliseconds2 = Date.parse(parsed);
   if (!Number.isFinite(milliseconds2) || new Date(milliseconds2).toISOString() !== parsed) {
@@ -25650,7 +26218,7 @@ function normalizedEmail3(value, label) {
   return value.toLowerCase();
 }
 function parseFields(value, label) {
-  const parsed = record6(value, label);
+  const parsed = record7(value, label);
   exact4(parsed, ["email", "profileUrl", "connectedSince", "phones", "websites", "birthday"], label);
   const email2 = optionalText3(parsed.email, `${label}.email`, 320);
   if (email2 !== null)
@@ -25674,11 +26242,11 @@ function parseFields(value, label) {
   return Object.freeze({ email: email2, profileUrl: profileUrl2, connectedSince, phones, websites, birthday: birthday2 });
 }
 function projectLinkedInContactInfo(value, expectedProfileUrl) {
-  const output = record6(value, "Ghostget LinkedIn contact output");
+  const output = record7(value, "Ghostget LinkedIn contact output");
   exact4(output, ["schemaVersion", "provider", "profile", "viewer", "observedAt", "completeness", "contact"], "contact output");
   if (output.schemaVersion !== 1 || output.provider !== PROVIDER11)
     throw new Error("Ghostget LinkedIn contact semantics drifted");
-  const profile = record6(output.profile, "contact output.profile");
+  const profile = record7(output.profile, "contact output.profile");
   exact4(profile, ["vanity", "profileUrn", "url", "relationship"], "contact output.profile");
   const vanity = text6(profile.vanity, "contact output.profile.vanity", 1024);
   if (!VANITY.test(vanity))
@@ -25692,12 +26260,12 @@ function projectLinkedInContactInfo(value, expectedProfileUrl) {
   }
   if (profile.relationship !== "first-degree")
     throw new Error("Ghostget LinkedIn contact output is not a first-degree read");
-  const viewer = record6(output.viewer, "contact output.viewer");
+  const viewer = record7(output.viewer, "contact output.viewer");
   exact4(viewer, ["subject"], "contact output.viewer");
   const viewerSubject = text6(viewer.subject, "contact output.viewer.subject", 64);
   if (!VIEWER_SUBJECT.test(viewerSubject))
     throw new Error("Ghostget LinkedIn viewer subject is invalid");
-  const observedAt = timestamp6(output.observedAt, "contact output.observedAt");
+  const observedAt = timestamp7(output.observedAt, "contact output.observedAt");
   if (output.completeness !== "complete" && output.completeness !== "partial") {
     throw new Error("Ghostget LinkedIn contact completeness is invalid");
   }
@@ -25738,7 +26306,7 @@ function envelope(value, input, auth) {
   });
 }
 function storedResultFromJson(value) {
-  const parsed = record6(JSON.parse(value), "stored LinkedIn contact-info result");
+  const parsed = record7(JSON.parse(value), "stored LinkedIn contact-info result");
   exact4(parsed, [
     "account_key",
     "person_id",
@@ -25757,7 +26325,7 @@ function storedResultFromJson(value) {
   return parsed;
 }
 function metadata3(value) {
-  return record6(JSON.parse(value), "LinkedIn resource metadata");
+  return record7(JSON.parse(value), "LinkedIn resource metadata");
 }
 function readLinkedInContactInfo(database, options) {
   const account = linkedInAccountKey(options.accountKey);
@@ -25922,7 +26490,7 @@ function run9(database, sql, ...values) {
 function insertedId10(value) {
   return Number(value.lastInsertRowid);
 }
-function record7(value, label) {
+function record8(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype && Object.getPrototypeOf(value) !== null) {
     throw new Error(`${label} must be a plain object`);
   }
@@ -25976,10 +26544,10 @@ function stableJson6(value) {
   }
   if (Array.isArray(value))
     return `[${value.map(stableJson6).join(",")}]`;
-  const parsed = record7(value, "canonical JSON");
+  const parsed = record8(value, "canonical JSON");
   return `{${Object.keys(parsed).sort().map((key) => `${JSON.stringify(key)}:${stableJson6(parsed[key])}`).join(",")}}`;
 }
-function timestamp7(value, label) {
+function timestamp8(value, label) {
   const parsed = text7(value, label, 40);
   if (!/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d{1,9})?Z$/u.test(parsed))
     throw new Error(`${label} is invalid`);
@@ -26042,11 +26610,11 @@ function envelope2(value, input, auth) {
     contractSha256: CONTACTS_CONTRACT_SHA2562,
     finalOrigin: "https://web.whatsapp.com"
   });
-  return { output: record7(parsed.output, "Ghostget output"), execution: parsed.execution };
+  return { output: record8(parsed.output, "Ghostget output"), execution: parsed.execution };
 }
 var CONTACT_KEYS = ["providerId", "jidKind", "phone", "redactedPhone", "firstName", "fullName", "pushName", "businessName", "displayName", "displayNameBasis", "alias", "tags", "updatedAt", "localProjectionStatsComplete", "sentCount", "sentCountComplete", "sentCountLowerBound", "sentCountTruncated", "receivedCount", "receivedCountComplete", "receivedCountLowerBound", "receivedCountTruncated", "lastSentAt", "lastSentAtComplete", "lastSentAtBasis", "sentStatsIncompleteReasons", "lastReceivedAt", "lastReceivedAtComplete", "lastReceivedAtBasis", "receivedStatsIncompleteReasons"];
 function parseContact4(value, label) {
-  const parsed = record7(value, label);
+  const parsed = record8(value, label);
   exact5(parsed, CONTACT_KEYS, label);
   const identity = directJid(parsed.providerId, `${label}.providerId`);
   if (parsed.jidKind !== identity.kind)
@@ -26100,9 +26668,9 @@ function parseContactPage(value, input, auth) {
   return { input, accountSubject, contacts, nextCursor, localPageComplete: complete, safeOutputSha256, execution: parsed.execution };
 }
 function generation(value) {
-  const parsed = record7(value, "projection generation");
+  const parsed = record8(value, "projection generation");
   exact5(parsed, ["messageStoreIdentity", "schemaFingerprint"], "projection generation");
-  const identity = record7(parsed.messageStoreIdentity, "message-store identity");
+  const identity = record8(parsed.messageStoreIdentity, "message-store identity");
   exact5(identity, ["dev", "ino"], "message-store identity");
   const dev = decimal(identity.dev, "message-store dev");
   const ino = decimal(identity.ino, "message-store ino");
@@ -26111,7 +26679,7 @@ function generation(value) {
   return { messageStoreIdentity: { dev, ino }, schemaFingerprint: PROJECTION_SCHEMA_FINGERPRINT };
 }
 function checkpoint(value, label) {
-  const parsed = record7(value, label);
+  const parsed = record8(value, label);
   exact5(parsed, ["cursor", "anchor"], label);
   const cursor = decimal(parsed.cursor, `${label}.cursor`);
   const anchor = parsed.anchor === null ? null : digest5(parsed.anchor, `${label}.anchor`);
@@ -26120,7 +26688,7 @@ function checkpoint(value, label) {
   return { cursor, anchor };
 }
 function parseInteraction(value, label) {
-  const parsed = record7(value, label);
+  const parsed = record8(value, label);
   exact5(parsed, ["rowid", "chatJid", "messageId", "senderJid", "timestamp", "fromMe", "chatKind"], label);
   const rowid = decimal(parsed.rowid, `${label}.rowid`);
   if (rowid === "0")
@@ -26141,7 +26709,7 @@ function parseInteraction(value, label) {
     chatJid: chat.jid,
     messageId,
     senderJid: sender,
-    timestamp: timestamp7(parsed.timestamp, `${label}.timestamp`),
+    timestamp: timestamp8(parsed.timestamp, `${label}.timestamp`),
     fromMe: bool3(parsed.fromMe, `${label}.fromMe`),
     chatKind: parsed.chatKind
   };
@@ -26300,7 +26868,7 @@ function ensureResource2(database, account, sourceRealmId, jid, name, basis, run
   return { personId, resourceId, imported: true };
 }
 function parseStoredGeneration(value) {
-  const parsed = record7(JSON.parse(value), "stored WhatsApp checkpoint metadata");
+  const parsed = record8(JSON.parse(value), "stored WhatsApp checkpoint metadata");
   exact5(parsed, ["generation", "coverage"], "stored WhatsApp checkpoint metadata");
   if (parsed.coverage !== "local-insert-rowid-scan")
     throw new Error("stored WhatsApp coverage drifted");
@@ -26326,7 +26894,7 @@ function refreshMetrics2(database, account, runId) {
     GROUP BY person_id`, PROVIDER12, account, runId, PROVIDER12, account);
 }
 function resultFromJson2(value) {
-  const parsed = record7(JSON.parse(value), "stored WhatsApp result");
+  const parsed = record8(JSON.parse(value), "stored WhatsApp result");
   exact5(parsed, ["account_subject", "contacts_seen", "contacts_imported", "contacts_matched", "contacts_skipped_self", "messages_seen", "messages_inserted", "matched_messages", "skipped_messages", "checkpoint_cursor", "local_insert_scan_complete", "remote_history_complete", "counts_complete", "counts_lower_bound"], "stored WhatsApp result");
   const numeric = ["contacts_seen", "contacts_imported", "contacts_matched", "contacts_skipped_self", "messages_seen", "messages_inserted", "matched_messages", "skipped_messages"];
   for (const key of numeric)
@@ -26596,7 +27164,7 @@ function syncWhatsAppRelationships(database, options = {}) {
 }
 
 // src/cli/version.ts
-var peoplebladeVersion = "0.3.5";
+var peoplebladeVersion = "0.3.6";
 
 // src/cli/intro.ts
 function terminalIntro(terminal) {
@@ -26615,6 +27183,8 @@ function terminalIntro(terminal) {
 var usage = `PeopleBlade \u2014 local-first contact intelligence
 
 Usage: peopleblade [--db PATH] <command>
+  support [protocol --json|offer --json|shown ID|release ID|dismiss|snooze|enable|status --json]
+    Optional support and updates; agents use support protocol --json at closeout.
 
 Core:
   init                              Create or migrate the local database
@@ -26764,7 +27334,7 @@ function yesNo(value, label) {
 async function readNoteMarkdown(path) {
   const maximum = 65536;
   if (path !== "-") {
-    const descriptor = openSync9(resolve7(path), constants9.O_RDONLY | constants9.O_NONBLOCK | (constants9.O_NOFOLLOW ?? 0));
+    const descriptor = openSync9(resolve7(path), constants10.O_RDONLY | constants10.O_NONBLOCK | (constants10.O_NOFOLLOW ?? 0));
     try {
       const before = fstatSync8(descriptor);
       if (!before.isFile() || before.nlink !== 1 || before.size > maximum || typeof process.getuid === "function" && before.uid !== process.getuid()) {
@@ -26840,7 +27410,11 @@ var AUTO_ACCEPT_SOURCE_COMMANDS = new Set([
   "instagram import",
   "notes import"
 ]);
-async function main(argv) {
+async function main(argv, onUsefulResult, supportEnv) {
+  if (argv[0] === "support") {
+    process.exitCode = await runProductSupportCommand(argv.slice(1), { stdout: (text8) => process.stdout.write(text8), stderr: (text8) => process.stderr.write(text8) }, { env: supportEnv });
+    return;
+  }
   const args = [...argv];
   const databasePath = valueAfter(args, "--db") ?? peoplebladeDatabasePath();
   const asJson = flag(args, "--json");
@@ -26858,20 +27432,26 @@ async function main(argv) {
     return;
   }
   const [command, subcommand, ...rest] = args;
+  const useful = ["list", "query", "stats", "backup"].includes(command ?? "") || ["people show", "notes add", "notes list", "notes show", "notes update", "notes history", "notes search", "ensoul prepare", "research prepare", "research apply", "contacts sync", "beeper sync", "beeper search", "google sync", "imessage sync", "whatsapp sync", "linkedin import", "linkedin contact-info", "x import", "instagram import"].includes(`${command} ${subcommand}`);
+  const printResult = (value, json5) => {
+    print(value, json5);
+    if (useful)
+      onUsefulResult();
+  };
   if (autoAccept && !AUTO_ACCEPT_SOURCE_COMMANDS.has(`${command} ${subcommand}`)) {
     fail3("--auto-accept is valid only with a local source sync or import command; use `identity auto-accept` directly otherwise.");
   }
   if (command === "capabilities") {
     if (args.length !== 1)
       fail3("capabilities takes no arguments.");
-    print(peoplebladeCapabilities, true);
+    printResult(peoplebladeCapabilities, true);
     return;
   }
   if (command === "init") {
     if (args.length !== 1)
       fail3("init takes no arguments.");
     const result = initializeLocalDatabase(databasePath);
-    print({ database: databasePath, initialized: true, ...result }, asJson);
+    printResult({ database: databasePath, initialized: true, ...result }, asJson);
     return;
   }
   if (command === "menubar") {
@@ -26883,10 +27463,10 @@ async function main(argv) {
   if (command === "outputs") {
     if (args.length !== 1)
       fail3("outputs takes no arguments.");
-    const directory = join7(peoplebladeDirectory(), "outputs");
+    const directory = join8(peoplebladeDirectory(), "outputs");
     mkdirSync3(directory, { recursive: true, mode: 448 });
     if (asJson)
-      print({ outputs: directory }, true);
+      printResult({ outputs: directory }, true);
     else
       console.log(directory);
     return;
@@ -26897,10 +27477,10 @@ async function main(argv) {
     const backup = valueAfter(options, "--backup") ?? standardBackupPath("legacy-rolodex", databasePath);
     if (options.length > 0)
       fail3(`Unknown argument: ${options[0]}`);
-    if (!existsSync6(source))
+    if (!existsSync5(source))
       fail3(`Legacy Rolodex does not exist: ${source}`);
     backupLocalDatabase(source, backup);
-    print({ database: databasePath, legacyBackup: backup, ...migrateLegacyRolodex(source, databasePath) }, asJson);
+    printResult({ database: databasePath, legacyBackup: backup, ...migrateLegacyRolodex(source, databasePath) }, asJson);
     return;
   }
   if (command === "cloud" && subcommand === "signin") {
@@ -26908,13 +27488,13 @@ async function main(argv) {
       fail3(`Unknown argument: ${rest[0]}`);
     const result = await signInCloud(undefined, { onCode: (code, verification) => console.error(`Authorize code ${code}
 ${verification}`) });
-    print(result, asJson);
+    printResult(result, asJson);
     return;
   }
   if (command === "cloud" && subcommand === "devices") {
     if (rest.length)
       fail3(`Unknown argument: ${rest[0]}`);
-    print(await listCloudDevices(), asJson);
+    printResult(await listCloudDevices(), asJson);
     return;
   }
   if (command === "cloud" && subcommand === "revoke") {
@@ -26922,33 +27502,33 @@ ${verification}`) });
     const deviceId = options.shift() ?? fail3("cloud revoke requires DEVICE_ID.");
     if (options.length)
       fail3(`Unknown argument: ${options[0]}`);
-    print(await revokeCloudDevice(deviceId), asJson);
+    printResult(await revokeCloudDevice(deviceId), asJson);
     return;
   }
   if (command === "cloud" && subcommand === "signout") {
     if (rest.length)
       fail3(`Unknown argument: ${rest[0]}`);
-    print(await signOutCloud(), asJson);
+    printResult(await signOutCloud(), asJson);
     return;
   }
-  if (!existsSync6(databasePath))
+  if (!existsSync5(databasePath))
     fail3("Run `peopleblade init` or `peopleblade migrate rolodex --from PATH` first.");
   if (command === "backup") {
     const destination = subcommand ?? standardBackupPath("manual", databasePath);
     if (rest.length)
       fail3(`Unknown argument: ${rest[0]}`);
     backupLocalDatabase(databasePath, destination);
-    print({ database: databasePath, backup: destination }, asJson);
+    printResult({ database: databasePath, backup: destination }, asJson);
     return;
   }
   initializeLocalDatabase(databasePath);
   const database = connectLocalDatabase(databasePath);
-  const printImport = (result, json4) => {
+  const printImport = (result, json5) => {
     if (!autoAccept) {
-      print(result, json4);
+      printResult(result, json5);
       return;
     }
-    print({ ...result, identityAutoAccept: autoAcceptIdentities(database) }, json4);
+    printResult({ ...result, identityAutoAccept: autoAcceptIdentities(database) }, json5);
   };
   try {
     if (command === "ui") {
@@ -26965,7 +27545,7 @@ ${verification}`) });
       const limit = positive(valueAfter(options, "--limit"), "--limit", 50, 1000);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(listLocalContacts(database, search, limit), asJson);
+      printResult(listLocalContacts(database, search, limit), asJson);
       return;
     }
     if (command === "query") {
@@ -26982,14 +27562,14 @@ ${verification}`) });
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
       const input = contactQueryInputSchema.parse({ search, source, doNotContact, sort, direction, hasEmail, hasPhone, limit, offset });
-      print(queryLocalContacts(database, input), true);
+      printResult(queryLocalContacts(database, input), true);
       return;
     }
     if (command === "people") {
       if (subcommand === "show") {
         if (rest.length !== 1)
           fail3("people show requires one ID.");
-        print(getLocalContactDetail(database, positive(rest[0], "ID", 0, Number.MAX_SAFE_INTEGER)), true);
+        printResult(getLocalContactDetail(database, positive(rest[0], "ID", 0, Number.MAX_SAFE_INTEGER)), true);
         return;
       }
       if (subcommand !== "add")
@@ -27008,7 +27588,7 @@ ${verification}`) });
         fail3("people add requires --confirm after the user confirmed this identity.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(addConfirmedPerson(database, {
+      printResult(addConfirmedPerson(database, {
         displayName: displayName2,
         confirmed: true,
         ...email2 === undefined ? {} : { email: email2 },
@@ -27020,7 +27600,7 @@ ${verification}`) });
     if (command === "stats") {
       if (args.length !== 1)
         fail3("stats takes no arguments.");
-      print(localStats(database), asJson);
+      printResult(localStats(database), asJson);
       return;
     }
     if (command === "identity" && subcommand === "audit") {
@@ -27030,7 +27610,7 @@ ${verification}`) });
         fail3("--source must be a lowercase provider name.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(auditObservedIdentityLinks(database, { ...source === undefined ? {} : { source } }), asJson);
+      printResult(auditObservedIdentityLinks(database, { ...source === undefined ? {} : { source } }), asJson);
       return;
     }
     if (command === "identity" && subcommand === "decisions") {
@@ -27043,7 +27623,7 @@ ${verification}`) });
         fail3("--source must be a lowercase provider name.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(listObservedIdentityDecisions(database, { ...source === undefined ? {} : { source }, ...stale ? { stale: true } : {} }), asJson);
+      printResult(listObservedIdentityDecisions(database, { ...source === undefined ? {} : { source }, ...stale ? { stale: true } : {} }), asJson);
       return;
     }
     if (command === "identity" && subcommand === "suggest") {
@@ -27066,7 +27646,7 @@ ${verification}`) });
         fail3("--ambiguity must be unique, ambiguous, or all.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(suggestIdentities(database, {
+      printResult(suggestIdentities(database, {
         ...kind === undefined ? {} : { kind },
         limit,
         ...source === undefined ? {} : { source },
@@ -27083,7 +27663,7 @@ ${verification}`) });
         fail3("identity decide requires TOKEN and accept, reject, or defer.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(decideIdentity(database, token3, action, note), asJson);
+      printResult(decideIdentity(database, token3, action, note), asJson);
       return;
     }
     if (command === "identity" && subcommand === "auto-accept") {
@@ -27103,7 +27683,7 @@ ${verification}`) });
         fail3("--kinds requires a comma-separated list of evidence kinds.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(autoAcceptIdentities(database, {
+      printResult(autoAcceptIdentities(database, {
         ...kinds === undefined ? {} : { kinds },
         limit,
         dryRun,
@@ -27121,7 +27701,7 @@ ${verification}`) });
       const decisionId = positive(decisionIdValue, "DECISION_ID", 0, Number.MAX_SAFE_INTEGER);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(separateIdentityDecision(database, decisionId, note), asJson);
+      printResult(separateIdentityDecision(database, decisionId, note), asJson);
       return;
     }
     if (command === "identity" && subcommand === "attest-email") {
@@ -27143,7 +27723,7 @@ ${verification}`) });
       const confirmPersonId = confirmPersonIdValue === undefined ? undefined : positive(confirmPersonIdValue, "--confirm-person-id", 0, Number.MAX_SAFE_INTEGER);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(attestIdentityEmail(database, {
+      printResult(attestIdentityEmail(database, {
         personId,
         email: email2,
         ...note === undefined ? {} : { note },
@@ -27161,7 +27741,7 @@ ${verification}`) });
       const methodId = positive(methodIdValue, "METHOD_ID", 0, Number.MAX_SAFE_INTEGER);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(retractIdentityEmailAttestation(database, { methodId, ...note === undefined ? {} : { note } }), asJson);
+      printResult(retractIdentityEmailAttestation(database, { methodId, ...note === undefined ? {} : { note } }), asJson);
       return;
     }
     if (command === "identity" && subcommand === "accept-candidate") {
@@ -27171,13 +27751,13 @@ ${verification}`) });
         fail3("identity accept-candidate requires RUN_ID:ORDINAL.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(acceptBeeperSearchCandidate(database, token3), asJson);
+      printResult(acceptBeeperSearchCandidate(database, token3), asJson);
       return;
     }
     if (command === "cloud" && subcommand === "sync") {
       if (rest.length)
         fail3(`Unknown argument: ${rest[0]}`);
-      print(await syncCloud(database), asJson);
+      printResult(await syncCloud(database), asJson);
       return;
     }
     if (command === "cloud" && subcommand === "enrich") {
@@ -27211,24 +27791,24 @@ ${verification}`) });
         fail3("--revalidate-historical cannot be combined with --confirm, --prioritize, --person-id, or --no-wait.");
       }
       if (statusJobId !== undefined) {
-        print(await cloudEnrichmentStatus(statusJobId), asJson);
+        printResult(await cloudEnrichmentStatus(statusJobId), asJson);
         return;
       }
       if (detailsJobId !== undefined) {
-        print(await cloudEnrichmentDetails(detailsJobId), asJson);
+        printResult(await cloudEnrichmentDetails(detailsJobId), asJson);
         return;
       }
       if (publicEmails) {
         const leftovers = await cloudEnrichmentPublicEmails();
         if (asJson) {
-          print(leftovers, true);
+          printResult(leftovers, true);
           return;
         }
-        print({ count: leftovers.publicEmails.length, sample: leftovers.publicEmails.slice(0, 5) }, false);
+        printResult({ count: leftovers.publicEmails.length, sample: leftovers.publicEmails.slice(0, 5) }, false);
         return;
       }
       if (revalidateHistorical) {
-        print(await revalidateHistoricalCloudEnrichment(), asJson);
+        printResult(await revalidateHistoricalCloudEnrichment(), asJson);
         return;
       }
       if (prioritizeValue !== undefined) {
@@ -27238,27 +27818,27 @@ ${verification}`) });
         const requestedCount = positive(prioritizeValue, "--prioritize", 0, 100);
         const preview2 = await previewPrioritizedCloudEnrichment(database, requestedCount);
         const selectedFlags2 = preview2.contacts.map((contact) => `--person-id ${contact.personId}`).join(" ");
-        print({ ...preview2, nextCommand: `peopleblade cloud enrich --confirm ${preview2.confirmation} ${selectedFlags2}` }, asJson);
+        printResult({ ...preview2, nextCommand: `peopleblade cloud enrich --confirm ${preview2.confirmation} ${selectedFlags2}` }, asJson);
         return;
       }
       if (personIdValues.length === 0)
         fail3("cloud enrich requires one or more --person-id values.");
       const personIds = personIdValues.map((value) => positive(value, "--person-id", 0, Number.MAX_SAFE_INTEGER));
       if (confirmation !== undefined) {
-        print(await startCloudEnrichment(database, confirmation, personIds, { wait: !noWait }), asJson);
+        printResult(await startCloudEnrichment(database, confirmation, personIds, { wait: !noWait }), asJson);
         return;
       }
       if (noWait)
         fail3("--no-wait is valid only with --confirm.");
       const preview = await previewCloudEnrichment(database, personIds);
       const selectedFlags = preview.contacts.map((contact) => `--person-id ${contact.personId}`).join(" ");
-      print({ ...preview, nextCommand: `peopleblade cloud enrich --confirm ${preview.confirmation} ${selectedFlags}` }, asJson);
+      printResult({ ...preview, nextCommand: `peopleblade cloud enrich --confirm ${preview.confirmation} ${selectedFlags}` }, asJson);
       return;
     }
     if (command === "notes" && subcommand === "show") {
       if (rest.length !== 1)
         fail3("notes show requires one ID.");
-      print(getPersonNote(database, positive(rest[0], "ID", 0, Number.MAX_SAFE_INTEGER)), true);
+      printResult(getPersonNote(database, positive(rest[0], "ID", 0, Number.MAX_SAFE_INTEGER)), true);
       return;
     }
     if (command === "notes" && subcommand === "update") {
@@ -27289,7 +27869,7 @@ ${verification}`) });
         currentTitle = expected.title;
       }
       const body = await readNoteMarkdown(path);
-      print(revisePersonNote(database, { noteId, expectedRevision, expectedContextSha256, requestId, title: currentTitle, body }), true);
+      printResult(revisePersonNote(database, { noteId, expectedRevision, expectedContextSha256, requestId, title: currentTitle, body }), true);
       return;
     }
     if (command === "notes" && subcommand === "history") {
@@ -27299,7 +27879,7 @@ ${verification}`) });
       const limit = positive(valueAfter(options, "--limit"), "--limit", 50, 100);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(listPersonNoteRevisions(database, { noteId, limit, ...before === undefined ? {} : {
+      printResult(listPersonNoteRevisions(database, { noteId, limit, ...before === undefined ? {} : {
         beforeRevision: positive(before, "--before-revision", 0, Number.MAX_SAFE_INTEGER)
       } }), true);
       return;
@@ -27314,7 +27894,7 @@ ${verification}`) });
       const sourceId = valueAfter(options, "--source-id");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(addPersonNote(database, {
+      printResult(addPersonNote(database, {
         personId: positive(personIdValue, "--person-id", 0, Number.MAX_SAFE_INTEGER),
         occurredAt,
         body,
@@ -27333,7 +27913,7 @@ ${verification}`) });
       const limitValue = valueAfter(options, "--limit");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(listPersonNotes(database, {
+      printResult(listPersonNotes(database, {
         personId: positive(personIdValue, "--person-id", 0, Number.MAX_SAFE_INTEGER),
         ...since === undefined ? {} : { since },
         ...until === undefined ? {} : { until },
@@ -27354,7 +27934,7 @@ ${verification}`) });
       const limitValue = valueAfter(options, "--limit");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(searchPersonNotes(database, {
+      printResult(searchPersonNotes(database, {
         query,
         ...personIdValue === undefined ? {} : { personId: positive(personIdValue, "--person-id", 0, Number.MAX_SAFE_INTEGER) },
         ...since === undefined ? {} : { since },
@@ -27377,13 +27957,13 @@ ${verification}`) });
       const id2 = positive(rest[0], "PERSON_ID", 0, Number.MAX_SAFE_INTEGER);
       if (rest.length !== 1)
         fail3("research prepare requires one person ID.");
-      print(researchTemplate(database, id2), true);
+      printResult(researchTemplate(database, id2), true);
       return;
     }
     if (command === "research" && subcommand === "apply") {
       if (rest.length !== 1 || rest[0] === undefined)
         fail3("research apply requires one JSON file.");
-      print(applyManualResearch(database, rest[0]), asJson);
+      printResult(applyManualResearch(database, rest[0]), asJson);
       return;
     }
     if (command === "ensoul" && subcommand === "prepare") {
@@ -27395,7 +27975,7 @@ ${verification}`) });
       const personId = positive(personIdValue, "PERSON_ID", 0, Number.MAX_SAFE_INTEGER);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(preparePeoplebladeEnsoulSource(database, personId, output), asJson);
+      printResult(preparePeoplebladeEnsoulSource(database, personId, output), asJson);
       return;
     }
     if (command === "contacts" && subcommand === "sync") {
@@ -27440,7 +28020,7 @@ ${verification}`) });
     if (command === "beeper" && subcommand === "stats") {
       if (rest.length)
         fail3(`Unknown argument: ${rest[0]}`);
-      print(beeperStats(database), asJson);
+      printResult(beeperStats(database), asJson);
       return;
     }
     if (command === "beeper" && subcommand === "rebind") {
@@ -27454,7 +28034,7 @@ ${verification}`) });
       if (!confirm)
         fail3("beeper rebind requires --confirm after reviewing the current Ghostget binding, release, and connected-account inventory.");
       console.error("Beeper binding \xB7 verifying the complete connected-account inventory before an append-only transition");
-      print(rebindBeeperSource(database, { ...authId4 === undefined ? {} : { authId: authId4 } }), asJson);
+      printResult(rebindBeeperSource(database, { ...authId4 === undefined ? {} : { authId: authId4 } }), asJson);
       return;
     }
     if (command === "beeper" && subcommand === "search") {
@@ -27467,7 +28047,7 @@ ${verification}`) });
         fail3("beeper search requires one or more --query values.");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(backfillBeeperSearch(database, {
+      printResult(backfillBeeperSearch(database, {
         queries,
         ...services.length === 0 ? {} : { services },
         ...authId4 === undefined ? {} : { authId: authId4 },
@@ -27487,7 +28067,7 @@ ${verification}`) });
     if (command === "google" && subcommand === "stats") {
       if (rest.length)
         fail3(`Unknown argument: ${rest[0]}`);
-      print(googleContactStats(database), asJson);
+      printResult(googleContactStats(database), asJson);
       return;
     }
     if (command === "imessage" && subcommand === "sync") {
@@ -27545,7 +28125,7 @@ ${verification}`) });
       const authId4 = valueAfter(options, "--auth");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(readLinkedInContactInfo(database, {
+      printResult(readLinkedInContactInfo(database, {
         personId,
         ...accountKey5 === undefined ? {} : { accountKey: accountKey5 },
         ...authId4 === undefined ? {} : { authId: authId4 }
@@ -27555,7 +28135,7 @@ ${verification}`) });
     if (command === "linkedin" && subcommand === "stats") {
       if (rest.length)
         fail3(`Unknown argument: ${rest[0]}`);
-      print(linkedInStatsAll(database), asJson);
+      printResult(linkedInStatsAll(database), asJson);
       return;
     }
     if (command === "x" && subcommand === "import") {
@@ -27572,7 +28152,7 @@ ${verification}`) });
     if (command === "x" && subcommand === "stats") {
       if (rest.length)
         fail3(`Unknown argument: ${rest[0]}`);
-      print(xArchiveStatsAll(database), asJson);
+      printResult(xArchiveStatsAll(database), asJson);
       return;
     }
     if (command === "instagram" && subcommand === "import") {
@@ -27590,11 +28170,11 @@ ${verification}`) });
     if (command === "instagram" && subcommand === "stats") {
       if (rest.length)
         fail3(`Unknown argument: ${rest[0]}`);
-      print(instagramStatsAll(database), asJson);
+      printResult(instagramStatsAll(database), asJson);
       return;
     }
     if (command === "telegram" && subcommand === "status") {
-      print({ status: "waiting-for-first-real-export", next: "In Telegram Desktop, repeat Export Telegram data on the same device after the 24-hour security delay; choose machine-readable JSON. PeopleBlade will validate the first real artifact before enabling the importer." }, asJson);
+      printResult({ status: "waiting-for-first-real-export", next: "In Telegram Desktop, repeat Export Telegram data on the same device after the 24-hour security delay; choose machine-readable JSON. PeopleBlade will validate the first real artifact before enabling the importer." }, asJson);
       return;
     }
     if (command === "x" && subcommand === "mutuals" && rest[0] === "sync")
@@ -27606,7 +28186,14 @@ ${usage}`);
     database.close();
   }
 }
-main(process.argv.slice(2)).catch((error) => {
+var supportEnv = standaloneSupportEnvironment();
+var usefulResult = false;
+main(process.argv.slice(2), () => {
+  usefulResult = true;
+}, supportEnv).then(async () => {
+  if (usefulResult && (process.exitCode === undefined || process.exitCode === 0))
+    await showProductSupportInvitation({ env: supportEnv });
+}).catch((error) => {
   const message = error instanceof Error ? error.message.slice(0, 2000) : "Unexpected failure.";
   if (process.argv.slice(2).includes("--json")) {
     console.error(JSON.stringify({