@hraness/peopleblade 0.1.2 → 0.2.1

package/dist/peopleblade.js

@@ -3,8 +3,9 @@
 var __require = import.meta.require;
 
 // src/cli/main.ts
-import { existsSync as existsSync5 } from "fs";
+import { closeSync as closeSync9, constants as constants9, existsSync as existsSync5, fstatSync as fstatSync8, openSync as openSync9, readSync as readSync3 } from "fs";
 import { resolve as resolve6 } from "path";
+import { ZodError } from "zod";
 
 // src/local/contacts.ts
 import { closeSync, constants, fstatSync, openSync, readFileSync } from "fs";
@@ -363,6 +364,7 @@ var serverCliEnrichmentStartSchema = z.object({
 var cliEnrichmentStatusSchema = z.object({
   jobId: z.uuid()
 }).strict();
+var cliEnrichmentPublicEmailsRequestSchema = z.object({}).strict();
 var cliEnrichmentRevalidationSchema = z.object({
   limit: z.number().int().min(1).max(100)
 }).strict();
@@ -2857,8 +2859,8 @@ function exactProfileSupersessionConflictsWithClaim(subject, output, clause, fie
     if (clause.tokens.some((token) => LOCATION_SUPERSESSION_MARKERS.has(token))) {
       return true;
     }
-    const location = normalizedEvidenceText(output.location).split(" ").filter(Boolean);
-    return location.length === 0 || normalizedPhraseStarts(clause.tokens, location).length > 0;
+    const location2 = normalizedEvidenceText(output.location).split(" ").filter(Boolean);
+    return location2.length === 0 || normalizedPhraseStarts(clause.tokens, location2).length > 0;
   }
   if (!exactProfileClauseSupersedesEmployment(subject, clause))
     return false;
@@ -3836,6 +3838,26 @@ var researchFileSchema = z3.object({
   researcher: z3.enum(["agent-public-web", "human-public-web"]),
   result: manualResearchSchema
 }).strict();
+var researchInstructions = "Search only public pages. A same-name page is never enough: one identity-evidence row must use a trusted profile URL from identityAnchors, or contain the exact full name plus a stored organization or title or a trusted email or phone from identityAnchors. providerHandles are display/search hints only. Do not guess emails. Cite every non-null field with evidence indexes.";
+var researchSubjectSchema = z3.object({
+  name: z3.string(),
+  organization: z3.string().nullable(),
+  title: z3.string().nullable(),
+  emails: z3.array(z3.string()).max(100),
+  phones: z3.array(z3.string()).max(100),
+  identityAnchors: z3.object({
+    emails: z3.array(z3.string()).max(100),
+    phones: z3.array(z3.string()).max(100),
+    profileUrls: z3.array(z3.string()).max(100)
+  }).strict(),
+  providerHandles: z3.record(z3.string(), z3.string())
+}).strict();
+var preparedResearchSchema = researchFileSchema.extend({
+  schemaVersion: z3.literal("peopleblade.research.v1"),
+  inputSha256: z3.string().regex(/^[a-f0-9]{64}$/u),
+  subject: researchSubjectSchema,
+  instructions: z3.literal(researchInstructions)
+}).strict();
 var MAX_RESEARCH_FILE_BYTES = 2 * 1024 * 1024;
 var MAX_RESEARCH_EMAILS = 100;
 var MAX_RESEARCH_EMAIL_CANDIDATES = 1e4;
@@ -3980,53 +4002,582 @@ function readResearchFile(path) {
   }
 }
 function applyManualResearch(database, path) {
-  const parsed = researchFileSchema.parse(readResearchFile(path));
-  const { evidence, ...output } = parsed.result;
-  const context = currentResearchContext(database, parsed.personId);
-  validateEnrichmentIdentityBinding({
-    displayName: context.displayName,
+  const parsed = z3.union([preparedResearchSchema, researchFileSchema]).parse(readResearchFile(path));
+  return database.transaction(() => {
+    const { evidence, ...output } = parsed.result;
+    const context = currentResearchContext(database, parsed.personId);
+    if ("schemaVersion" in parsed) {
+      const current = preparedResearchContext(database, context);
+      if (parsed.personId !== context.personId || parsed.inputSha256 !== current.inputSha256 || canonicalJson(parsed.subject) !== canonicalJson(current.subject)) {
+        throw new Error("Research preparation is stale or belongs to a different database. Prepare this contact again.");
+      }
+    }
+    validateEnrichmentIdentityBinding({
+      displayName: context.displayName,
+      emails: context.emails,
+      phones: context.phones,
+      identityAnchors: {
+        state: "available",
+        emails: [...context.emails],
+        phones: [...context.phones],
+        profileUrls: [...context.profileUrls]
+      },
+      organization: context.organization,
+      title: context.title,
+      providerHandles: context.providerHandles
+    }, output, evidence);
+    const evidenceSha = sha256(canonicalJson(parsed.result.evidence));
+    const existing = database.query("SELECT id,output_json FROM public_enrichments WHERE person_id=? AND provider=? AND input_sha256=? AND evidence_sha256=?").get(context.personId, parsed.researcher, context.inputSha256, evidenceSha);
+    if (existing !== null) {
+      if (canonicalJson(JSON.parse(existing.output_json)) !== canonicalJson(parsed.result)) {
+        throw new Error("Research evidence already has a different reviewed result. Existing evidence is immutable; do not treat this as a successful replay.");
+      }
+      return { enrichmentId: existing.id, cached: true };
+    }
+    const result = database.query(`INSERT INTO public_enrichments(person_id,provider,input_sha256,evidence_sha256,evidence_json,output_json)
+      VALUES (?,?,?,?,?,?)`).run(context.personId, parsed.researcher, context.inputSha256, evidenceSha, canonicalJson(parsed.result.evidence), canonicalJson(parsed.result));
+    return { enrichmentId: Number(result.lastInsertRowid), cached: false };
+  }).immediate();
+}
+function preparedResearchContext(database, context) {
+  const subject = {
+    name: context.displayName,
+    organization: context.organization,
+    title: context.title,
     emails: context.emails,
     phones: context.phones,
     identityAnchors: {
-      state: "available",
-      emails: [...context.emails],
-      phones: [...context.phones],
-      profileUrls: [...context.profileUrls]
+      emails: context.emails,
+      phones: context.phones,
+      profileUrls: context.profileUrls
     },
-    organization: context.organization,
-    title: context.title,
     providerHandles: context.providerHandles
-  }, output, evidence);
-  const evidenceSha = sha256(canonicalJson(parsed.result.evidence));
-  const existing = database.query("SELECT id FROM public_enrichments WHERE person_id=? AND provider=? AND input_sha256=? AND evidence_sha256=?").get(context.personId, parsed.researcher, context.inputSha256, evidenceSha);
-  if (existing !== null)
-    return { enrichmentId: existing.id, cached: true };
-  const result = database.query(`INSERT INTO public_enrichments(person_id,provider,input_sha256,evidence_sha256,evidence_json,output_json)
-    VALUES (?,?,?,?,?,?)`).run(context.personId, parsed.researcher, context.inputSha256, evidenceSha, canonicalJson(parsed.result.evidence), canonicalJson(parsed.result));
-  return { enrichmentId: Number(result.lastInsertRowid), cached: false };
+  };
+  return {
+    subject,
+    inputSha256: sha256(canonicalJson({
+      schemaVersion: "peopleblade.research.v1",
+      databaseInstanceId: localDatabaseInstanceId(database),
+      personId: context.personId,
+      contextSha256: context.inputSha256,
+      subject,
+      instructions: researchInstructions
+    }))
+  };
 }
 function researchTemplate(database, personId) {
-  const context = currentResearchContext(database, personId);
+  return database.transaction(() => {
+    const context = currentResearchContext(database, personId);
+    return {
+      schemaVersion: "peopleblade.research.v1",
+      personId: context.personId,
+      researcher: "agent-public-web",
+      ...preparedResearchContext(database, context),
+      instructions: researchInstructions,
+      result: { identityMatch: "insufficient", identityEvidenceIndexes: [], confidence: 0, headline: null, organization: null, role: null, location: null, website: null, publicEmail: null, publicEmailEvidenceIndex: null, notes: "", claims: [], evidence: [] }
+    };
+  }).deferred();
+}
+
+// src/local/contact-query.ts
+import { z as z4 } from "zod";
+var contactQueryInputSchema = z4.object({
+  search: z4.string().max(200).default(""),
+  source: z4.string().regex(/^[a-z][a-z0-9-]{0,63}$/u).optional(),
+  doNotContact: z4.enum(["all", "exclude", "only"]).default("all"),
+  hasEmail: z4.boolean().optional(),
+  hasPhone: z4.boolean().optional(),
+  sort: z4.enum(["name", "organization", "interactions", "last-contact"]).default("interactions"),
+  direction: z4.enum(["asc", "desc"]).default("desc"),
+  limit: z4.number().int().min(1).max(100).default(50),
+  offset: z4.number().int().min(0).max(1e6).default(0)
+}).strict();
+var contactCtes = `
+  -- Resolve the existing canonical view once, including reviewed representatives.
+  -- The schema qualifier avoids a recursive reference to this local CTE.
+  person_identity_components AS MATERIALIZED (
+    SELECT * FROM main.person_identity_components
+  ),
+  ${canonicalInteractionRollupCtesSql},
+  active_resources AS MATERIALIZED (
+    SELECT resource.*, member.canonical_person_id, realm.service
+    FROM provider_resources resource
+    JOIN person_identity_components member ON member.person_id=resource.person_id
+    LEFT JOIN source_realms realm ON realm.id=resource.source_realm_id
+    WHERE resource.active=1 AND (realm.id IS NULL OR realm.active=1)
+  ),
+  active_methods AS MATERIALIZED (
+    SELECT method.*,member.canonical_person_id
+    FROM contact_methods method
+    JOIN person_identity_components member ON member.person_id=method.person_id
+    LEFT JOIN provider_resources resource ON resource.id=method.provider_resource_id
+    LEFT JOIN source_realms realm ON realm.id=resource.source_realm_id
+    WHERE method.active=1 AND (method.provider_resource_id IS NULL OR (
+      resource.active=1 AND (realm.id IS NULL OR realm.active=1)
+    ))
+  ),
+  component_rollup AS (
+    SELECT member.canonical_person_id AS person_id,max(person.do_not_contact) AS do_not_contact,
+      CASE WHEN count(DISTINCT person.birthday)=1 THEN min(person.birthday) ELSE NULL END AS birthday
+    FROM person_identity_components member JOIN people person ON person.id=member.person_id
+    GROUP BY member.canonical_person_id
+  ),
+  source_values AS (
+    SELECT canonical_person_id AS person_id,provider FROM active_resources
+    UNION SELECT person_id,provider FROM canonical_interaction_inputs
+  ),
+  ranked_methods AS (
+    SELECT canonical_person_id,kind,value,
+      row_number() OVER (
+        PARTITION BY canonical_person_id,kind ORDER BY is_primary DESC,id
+      ) AS preference
+    FROM active_methods WHERE kind IN ('email','phone')
+  ),
+  primary_methods AS (
+    SELECT canonical_person_id,
+      max(CASE WHEN kind='email' THEN value END) AS primary_email,
+      max(CASE WHEN kind='phone' THEN value END) AS primary_phone
+    FROM ranked_methods WHERE preference=1 GROUP BY canonical_person_id
+  ),
+  source_rollup AS (
+    SELECT person_id,json_group_array(provider) AS sources_json
+    FROM source_values GROUP BY person_id
+  ),
+  -- Recursive-view cardinality estimates can make SQLite repeatedly scan each
+  -- aggregated LEFT JOIN for every contact. Union the independent fact lanes
+  -- and group once instead; each lane contributes at most one row per person.
+  summary_facts(person_id,birthday,do_not_contact,interaction_count,reciprocal,
+    last_interaction_at,primary_email,primary_phone,sources_json) AS (
+    SELECT person_id,birthday,do_not_contact,NULL,NULL,NULL,NULL,NULL,NULL FROM component_rollup
+    UNION ALL
+    SELECT person_id,NULL,NULL,interaction_count,reciprocal,last_interaction_at,NULL,NULL,NULL
+      FROM canonical_interaction_rollup
+    UNION ALL
+    SELECT canonical_person_id,NULL,NULL,NULL,NULL,NULL,primary_email,primary_phone,NULL
+      FROM primary_methods
+    UNION ALL
+    SELECT person_id,NULL,NULL,NULL,NULL,NULL,NULL,NULL,sources_json FROM source_rollup
+  ),
+  summary_rollup AS (
+    SELECT person_id,max(birthday) AS birthday,max(do_not_contact) AS do_not_contact,
+      coalesce(max(interaction_count),0) AS interaction_count,
+      coalesce(max(reciprocal),0) AS reciprocal,max(last_interaction_at) AS last_interaction_at,
+      max(primary_email) AS primary_email,max(primary_phone) AS primary_phone,
+      coalesce(max(sources_json),'[]') AS sources_json
+    FROM summary_facts GROUP BY person_id
+  ),
+  summaries AS (
+    SELECT person.id,coalesce(person.display_name,'Unnamed contact') AS display_name,
+      person.organization,person.title,contact.birthday,contact.do_not_contact,
+      contact.interaction_count,contact.reciprocal,contact.last_interaction_at,
+      contact.primary_email,contact.primary_phone,contact.sources_json
+    FROM people person
+    JOIN summary_rollup contact ON contact.person_id=person.id
+  )
+`;
+function summary(row) {
+  const sources = JSON.parse(row.sources_json);
   return {
-    personId: context.personId,
-    researcher: "agent-public-web",
-    subject: {
-      name: context.displayName,
-      organization: context.organization,
-      title: context.title,
-      emails: context.emails,
-      phones: context.phones,
-      identityAnchors: {
-        emails: context.emails,
-        phones: context.phones,
-        profileUrls: context.profileUrls
-      },
-      providerHandles: context.providerHandles
-    },
-    instructions: "Search only public pages. A same-name page is never enough: one identity-evidence row must use a trusted profile URL from identityAnchors, or contain the exact full name plus a stored organization or title or a trusted email or phone from identityAnchors. providerHandles are display/search hints only. Do not guess emails. Cite every non-null field with evidence indexes.",
-    result: { identityMatch: "insufficient", identityEvidenceIndexes: [], confidence: 0, headline: null, organization: null, role: null, location: null, website: null, publicEmail: null, publicEmailEvidenceIndex: null, notes: "", claims: [], evidence: [] }
+    id: row.id,
+    displayName: row.display_name,
+    organization: row.organization,
+    title: row.title,
+    birthday: row.birthday,
+    primaryEmail: row.primary_email,
+    primaryPhone: row.primary_phone,
+    interactionCount: row.interaction_count,
+    reciprocal: row.reciprocal === 1,
+    lastInteractionAt: row.last_interaction_at,
+    doNotContact: row.do_not_contact === 1,
+    sources: z4.array(z4.string().max(64)).parse(sources).sort((left, right) => Buffer.compare(Buffer.from(left, "utf8"), Buffer.from(right, "utf8")))
+  };
+}
+function filter(input) {
+  const clauses = [];
+  const bindings = [];
+  const search = input.search.trim();
+  if (search.length > 0) {
+    const pattern = `%${search.replaceAll("\\", "\\\\").replaceAll("%", "\\%").replaceAll("_", "\\_")}%`;
+    clauses.push(`contact.id IN (
+      SELECT member.canonical_person_id FROM people alias
+      JOIN person_identity_components member ON member.person_id=alias.id
+      WHERE (
+        coalesce(alias.display_name,'') LIKE ? ESCAPE '\\' COLLATE NOCASE OR
+        coalesce(alias.organization,'') LIKE ? ESCAPE '\\' COLLATE NOCASE OR
+        coalesce(alias.title,'') LIKE ? ESCAPE '\\' COLLATE NOCASE)
+      UNION SELECT method.canonical_person_id FROM active_methods method
+        WHERE method.value LIKE ? ESCAPE '\\' COLLATE NOCASE
+      UNION SELECT resource.canonical_person_id FROM active_resources resource
+        WHERE (coalesce(resource.username,'') LIKE ? ESCAPE '\\' COLLATE NOCASE OR
+          coalesce(resource.profile_url,'') LIKE ? ESCAPE '\\' COLLATE NOCASE))`);
+    bindings.push(pattern, pattern, pattern, pattern, pattern, pattern);
+  }
+  if (input.source !== undefined) {
+    clauses.push("contact.id IN (SELECT person_id FROM source_values WHERE provider=?)");
+    bindings.push(input.source);
+  }
+  if (input.doNotContact !== "all") {
+    clauses.push("contact.do_not_contact=?");
+    bindings.push(input.doNotContact === "only" ? 1 : 0);
+  }
+  if (input.hasEmail !== undefined)
+    clauses.push(`contact.primary_email IS ${input.hasEmail ? "NOT " : ""}NULL`);
+  if (input.hasPhone !== undefined)
+    clauses.push(`contact.primary_phone IS ${input.hasPhone ? "NOT " : ""}NULL`);
+  return { sql: clauses.length === 0 ? "" : `WHERE ${clauses.join(" AND ")}`, bindings };
+}
+function queryLocalContacts(database, value = {}) {
+  const input = contactQueryInputSchema.parse(value);
+  const where = filter(input);
+  const sortColumns = {
+    name: "display_name COLLATE NOCASE",
+    organization: "organization COLLATE NOCASE",
+    interactions: "interaction_count",
+    "last-contact": "last_interaction_at"
+  };
+  const column = sortColumns[input.sort];
+  const direction = input.direction === "asc" ? "ASC" : "DESC";
+  return database.transaction(() => {
+    const total = database.query(`WITH ${contactCtes}
+      SELECT count(*) AS count FROM summaries contact ${where.sql}`).get(...where.bindings)?.count ?? 0;
+    const rows = database.query(`WITH ${contactCtes}
+      SELECT contact.* FROM summaries contact ${where.sql}
+      ORDER BY ${column} ${direction},id ASC LIMIT ? OFFSET ?
+    `).all(...where.bindings, input.limit, input.offset);
+    const sources = database.query(`WITH ${contactCtes}
+      SELECT provider AS source,count(*) AS count FROM source_values GROUP BY provider ORDER BY provider`).all();
+    return {
+      schemaVersion: "peopleblade.contact-query.v1",
+      consistency: "live",
+      items: rows.map(summary),
+      total,
+      limit: input.limit,
+      offset: input.offset,
+      nextOffset: input.offset + rows.length < total ? input.offset + rows.length : null,
+      facets: { sources }
+    };
+  }).deferred();
+}
+function getLocalContactDetail(database, requestedPersonId) {
+  const id = z4.number().int().positive().max(Number.MAX_SAFE_INTEGER).parse(requestedPersonId);
+  return database.transaction(() => {
+    const canonical = database.query("SELECT canonical_person_id FROM person_identity_components WHERE person_id=?").get(id)?.canonical_person_id;
+    if (canonical === undefined)
+      throw new Error("Contact not found.");
+    const row = database.query(`WITH ${contactCtes}
+      SELECT * FROM summaries WHERE id=?`).get(canonical);
+    if (row === null)
+      throw new Error("Contact not found.");
+    const totals = database.query(`WITH ${contactCtes} SELECT
+        (SELECT count(*) FROM person_identity_components WHERE canonical_person_id=?) AS members,
+        (SELECT count(*) FROM active_methods WHERE canonical_person_id=?) AS methods,
+        (SELECT count(*) FROM active_resources WHERE canonical_person_id=?) AS sources`).get(canonical, canonical, canonical);
+    const methods = database.query(`WITH ${contactCtes} SELECT id,kind,value,label,is_primary,identity_eligible,confidence
+      FROM active_methods WHERE canonical_person_id=? ORDER BY is_primary DESC,kind,id LIMIT 100`).all(canonical);
+    const sources = database.query(`WITH ${contactCtes} SELECT provider,service,resource_type,profile_url,profile_url_identity_eligible
+      FROM active_resources WHERE canonical_person_id=? ORDER BY provider,id LIMIT 100`).all(canonical);
+    return {
+      schemaVersion: "peopleblade.contact-detail.v1",
+      consistency: "live",
+      requestedPersonId: id,
+      canonicalPersonId: canonical,
+      contact: summary(row),
+      memberCount: totals.members,
+      methods: { total: totals.methods, truncated: totals.methods > methods.length, items: methods.map((method) => ({
+        id: method.id,
+        kind: method.kind,
+        value: method.value,
+        label: method.label,
+        primary: method.is_primary === 1,
+        identityEligible: method.identity_eligible === 1 && method.confidence === "exact",
+        confidence: method.confidence
+      })) },
+      sources: { total: totals.sources, truncated: totals.sources > sources.length, items: sources.map((source) => ({
+        provider: source.provider,
+        service: source.service,
+        resourceType: source.resource_type,
+        profileUrl: source.profile_url,
+        identityEligible: source.profile_url_identity_eligible === 1
+      })) }
+    };
+  }).deferred();
+}
+
+// src/local/capabilities.ts
+var peoplebladeCapabilities = Object.freeze({
+  schemaVersion: "peopleblade.capabilities.v1",
+  availability: "declarative-not-configured",
+  localAuthority: true,
+  discoveryPerformsNetworkRequests: false,
+  sources: [
+    { id: "apple-contacts", command: "contacts sync", status: "supported", transport: "local-database", requirement: "macOS Contacts access" },
+    { id: "imessage", command: "imessage sync", status: "supported", transport: "local-metadata", requirement: "macOS Messages access; no message bodies" },
+    { id: "google-contacts", command: "google sync", status: "supported", transport: "wrench", requirement: "Reviewed Gmail/People contacts.list and contact scopes" },
+    { id: "beeper", command: "beeper sync", status: "supported", transport: "wrench", requirement: "Wrench 0.16.8, Beeper adapter 2.4.0, CLI 0.6.2; body-free relationships require macOS arm64" },
+    { id: "whatsapp", command: "whatsapp sync", status: "supported", transport: "wrench", requirement: "Reviewed linked-device contacts.list v2" },
+    { id: "linkedin", command: "linkedin import", status: "supported", transport: "official-archive", requirement: "Owner-selected official ZIP; no authenticated browser collection" },
+    { id: "instagram", command: "instagram import", status: "supported", transport: "official-archive", requirement: "Owner-selected JSON ZIP and exact owner username" },
+    { id: "x-archive", command: "x import", status: "bounded", transport: "official-archive", requirement: "Owner-selected ZIP; unresolved IDs remain inert" },
+    { id: "x-live", command: "x mutuals sync", status: "blocked", transport: "unavailable", requirement: "A reviewed bounded Wrench mutuals capability is not yet available" },
+    { id: "telegram", command: "telegram status", status: "planned", transport: "unavailable", requirement: "First real export and importer validation remain pending" }
+  ],
+  enrichment: [
+    { id: "local-anchors", priority: 1, status: "supported", commands: ["identity audit", "identity suggest", "identity decide"], paid: false, boundary: "Exact source evidence first; joins require reversible evidence-bound decisions" },
+    { id: "manual-public-research", priority: 2, status: "supported", commands: ["research prepare", "research apply"], paid: false, boundary: "Agent or human supplies cited public evidence; PeopleBlade performs no provider calls" },
+    { id: "cloud-professional-research", priority: 3, status: "optional", commands: ["cloud enrich --person-id ID", "cloud enrich --confirm TOKEN"], paid: true, boundary: "Exa exact profiles or bounded search, then cited model extraction; device-bound preview approval required" },
+    { id: "cloud-email-fallback", priority: 4, status: "optional", commands: ["cloud enrich --person-id ID"], paid: true, boundary: "Hunter is a separately configured narrow fallback, not a substitute for identity evidence" }
+  ],
+  interfaces: {
+    workspace: { command: "ui [--port N]", availability: "included-in-this-build", binding: "127.0.0.1", defaultPort: "random", authentication: "per-process capability file", remoteAssets: false, noteUpload: false },
+    query: { command: "query", schemaVersion: "peopleblade.contact-query.v1", consistency: "live", defaultLimit: 50, maximumLimit: 100, pagination: "offset", sorts: ["name", "organization", "interactions", "last-contact"] },
+    detail: { command: "people show ID", schemaVersion: "peopleblade.contact-detail.v1", maximumMethods: 100, maximumSources: 100 },
+    notes: { commands: ["notes add", "notes show ID", "notes update ID", "notes history ID", "notes list", "notes search"], cloudSync: false, edits: "append-only-compare-and-swap" },
+    research: { schemaVersion: "peopleblade.research.v1", commands: ["research prepare ID", "research apply FILE"], legacyInputAccepted: true },
+    errors: { schemaVersion: "peopleblade.error.v1", stream: "stderr", enabledBy: "--json" }
+  },
+  boundaries: [
+    "Supported does not mean configured or authorized; discovery does not inspect private configuration.",
+    "Notes, archives, credentials, provider payloads, and message bodies are not cloud-sync inputs.",
+    "Provider availability never authorizes contact, outreach, account automation, or a paid request.",
+    "Query pagination is a live view; concurrent imports and identity decisions can move rows between pages."
+  ]
+});
+
+// src/local/workspace.ts
+import { randomBytes } from "crypto";
+import { chmodSync, lstatSync, mkdtempSync, rmdirSync, unlinkSync, writeFileSync } from "fs";
+import { join } from "path";
+import { tmpdir } from "os";
+import { z as z5 } from "zod";
+
+// src/local/markdown.ts
+function previewNoteMarkdown(source) {
+  if (Buffer.byteLength(source, "utf8") > 65536)
+    throw new Error("Markdown exceeds 64 KiB.");
+  return Bun.markdown.render(source, {
+    text: (text) => Bun.escapeHTML(text),
+    html: (text) => Bun.escapeHTML(text),
+    paragraph: (children) => `<p>${children}</p>`,
+    heading: (children, { level }) => `<h${level}>${children}</h${level}>`,
+    strong: (children) => `<strong>${children}</strong>`,
+    emphasis: (children) => `<em>${children}</em>`,
+    strikethrough: (children) => `<del>${children}</del>`,
+    codespan: (children) => `<code>${children}</code>`,
+    code: (children) => `<pre><code>${children}</code></pre>`,
+    blockquote: (children) => `<blockquote>${children}</blockquote>`,
+    list: (children, meta) => meta.ordered ? `<ol>${children}</ol>` : `<ul>${children}</ul>`,
+    listItem: (children, meta) => `<li>${meta.checked === undefined ? "" : meta.checked ? "\u2611 " : "\u2610 "}${children}</li>`,
+    hr: () => "<hr>",
+    table: (children) => `<table>${children}</table>`,
+    thead: (children) => `<thead>${children}</thead>`,
+    tbody: (children) => `<tbody>${children}</tbody>`,
+    tr: (children) => `<tr>${children}</tr>`,
+    th: (children) => `<th>${children}</th>`,
+    td: (children) => `<td>${children}</td>`,
+    image: (children) => `<span>[Image omitted${children ? `: ${children}` : ""}]</span>`,
+    link: (children, { href }) => {
+      try {
+        const url = new URL(href);
+        if (!["http:", "https:"].includes(url.protocol) || url.username || url.password)
+          return children;
+        return `<a href="${Bun.escapeHTML(url.href)}" target="_blank" rel="noopener noreferrer">${children}</a>`;
+      } catch {
+        return children;
+      }
+    }
+  }, { tables: true, strikethrough: true, tasklists: true, noHtmlBlocks: true, noHtmlSpans: true, autolinks: false });
+}
+
+// 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 SHA256 = /^[0-9a-f]{64}$/u;
+var UNSUPPORTED_CONTROLS = /[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F]/u;
+
+class NoteRevisionError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "NoteRevisionError";
+    this.code = code;
+  }
+}
+function invalid(message) {
+  throw new NoteRevisionError("invalid_input", message);
+}
+function positiveInteger(value, label) {
+  if (!Number.isSafeInteger(value) || value < 1)
+    invalid(`${label} must be a positive safe integer.`);
+}
+function validatePersonNoteMutationRequest(requestId, expectedContextSha256) {
+  if (typeof requestId !== "string" || !UUID.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.");
+}
+function personNoteCreationContext(database, personId) {
+  positiveInteger(personId, "Person ID");
+  const row = database.query(`
+    WITH components AS MATERIALIZED (SELECT * FROM person_identity_components)
+    SELECT target.canonical_person_id,
+      (SELECT instance_id FROM local_state WHERE singleton=1) AS database_instance_id,
+      (SELECT identity_revision FROM local_revisions WHERE singleton=1) AS identity_revision,
+      (SELECT json_group_array(person_id) FROM (
+        SELECT person_id FROM components WHERE canonical_person_id=target.canonical_person_id ORDER BY person_id
+      )) AS component_person_ids
+    FROM components target WHERE target.person_id=?
+  `).get(personId);
+  if (row === null)
+    throw new NoteRevisionError("not_found", "Person not found.");
+  const members = JSON.parse(row.component_person_ids);
+  if (!Array.isArray(members) || !members.every((id) => typeof id === "number" && Number.isSafeInteger(id) && id > 0)) {
+    throw new Error("Stored note person context is malformed.");
+  }
+  const canonicalPersonId = Number(row.canonical_person_id);
+  const contextJson = canonicalJson({
+    schemaVersion: 1,
+    databaseInstanceId: row.database_instance_id,
+    personId,
+    canonicalPersonId,
+    componentPersonIds: members,
+    identityRevision: Number(row.identity_revision)
+  });
+  return { personId, canonicalPersonId, contextJson, contextSha256: sha256(contextJson) };
+}
+function validatePersonNoteContent(title, body) {
+  if (typeof body !== "string" || body.trim().length === 0)
+    invalid("Note body must not be empty.");
+  if (Buffer.byteLength(body, "utf8") > 65536)
+    invalid("Note body exceeds 64 KiB.");
+  if (UNSUPPORTED_CONTROLS.test(body) || Buffer.from(body, "utf8").toString("utf8") !== body) {
+    invalid("Note body contains unsupported control characters or malformed Unicode.");
+  }
+  if (title !== null && (typeof title !== "string" || title.trim().length === 0 || [...title].length > 1024 || UNSUPPORTED_CONTROLS.test(title) || /[\r\n]/u.test(title) || Buffer.from(title, "utf8").toString("utf8") !== title)) {
+    invalid("Note title must be null or nonblank text of at most 1024 characters.");
+  }
+}
+function personNoteContexts(database, noteIds) {
+  if (noteIds.length > 1001)
+    invalid("Note context request exceeds its bounded page limit.");
+  for (const noteId of noteIds)
+    positiveInteger(noteId, "Note ID");
+  if (noteIds.length === 0)
+    return new Map;
+  const rows = database.query(`
+    WITH components AS MATERIALIZED (SELECT * FROM person_identity_components)
+    SELECT note.id,note.revision,original.person_id AS original_person_id,
+      (SELECT instance_id FROM local_state WHERE singleton=1) AS database_instance_id,
+      note.person_id AS attributed_person_id,
+      coalesce((SELECT max(id) FROM person_note_attribution_revisions WHERE note_id=note.id),0) AS attribution_revision_id,
+      (SELECT identity_revision FROM local_revisions WHERE singleton=1) AS identity_revision,
+      target.canonical_person_id,
+      (SELECT json_group_array(person_id) FROM (
+        SELECT member.person_id FROM components member
+        WHERE member.canonical_person_id=target.canonical_person_id ORDER BY member.person_id
+      )) AS component_person_ids
+    FROM person_notes_effective note JOIN person_notes original ON original.id=note.id
+    JOIN components target ON target.person_id=note.person_id
+    WHERE note.id IN (${noteIds.map(() => "?").join(",")})
+  `).all(...noteIds);
+  return new Map(rows.map((row) => {
+    const members = JSON.parse(row.component_person_ids);
+    if (!Array.isArray(members) || !members.every((id) => typeof id === "number" && Number.isSafeInteger(id) && id > 0)) {
+      throw new Error("Stored note component context is malformed.");
+    }
+    const contextJson = canonicalJson({
+      schemaVersion: 1,
+      databaseInstanceId: row.database_instance_id,
+      noteId: Number(row.id),
+      revision: Number(row.revision),
+      originalPersonId: Number(row.original_person_id),
+      attributedPersonId: Number(row.attributed_person_id),
+      attributionRevisionId: Number(row.attribution_revision_id),
+      identityRevision: Number(row.identity_revision),
+      canonicalPersonId: Number(row.canonical_person_id),
+      componentPersonIds: members
+    });
+    return [Number(row.id), { revision: Number(row.revision), contextJson, contextSha256: sha256(contextJson) }];
+  }));
+}
+function mapRevision(row) {
+  return {
+    noteId: Number(row.note_id),
+    revision: Number(row.revision),
+    expectedRevision: row.expected_revision === null ? null : Number(row.expected_revision),
+    expectedContextSha256: row.expected_context_sha256,
+    requestId: row.request_id,
+    provenance: Number(row.revision) === 0 ? "original" : "user-edit",
+    title: row.title,
+    body: row.body,
+    createdAt: row.created_at
   };
 }
+function revisePersonNote(database, input) {
+  positiveInteger(input.noteId, "Note ID");
+  if (!Number.isSafeInteger(input.expectedRevision) || input.expectedRevision < 0 || input.expectedRevision >= Number.MAX_SAFE_INTEGER)
+    invalid("Expected revision must be a nonnegative safe integer below the revision ceiling.");
+  validatePersonNoteMutationRequest(input.requestId, input.expectedContextSha256);
+  validatePersonNoteContent(input.title, input.body);
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const prior = database.query("SELECT * FROM person_note_content_revisions WHERE request_id=?").get(input.requestId);
+    if (prior !== null) {
+      if (Number(prior.note_id) !== input.noteId || Number(prior.expected_revision) !== input.expectedRevision || prior.expected_context_sha256 !== input.expectedContextSha256 || prior.title !== input.title || prior.body !== input.body) {
+        throw new NoteRevisionError("request_conflict", "Request ID already belongs to a different note edit. Use its original payload or a new request ID.");
+      }
+      database.exec("COMMIT");
+      return { kind: "replayed", revision: mapRevision(prior) };
+    }
+    const context = personNoteContexts(database, [input.noteId]).get(input.noteId);
+    if (context === undefined)
+      throw new NoteRevisionError("not_found", "Note not found.");
+    if (context.revision !== input.expectedRevision) {
+      throw new NoteRevisionError("revision_conflict", "Note content changed. Reload the note and review your draft before saving again.");
+    }
+    if (context.contextSha256 !== input.expectedContextSha256) {
+      throw new NoteRevisionError("context_conflict", "Note attribution or identity context changed. Reload the note and review its owner before saving again.");
+    }
+    const revision = input.expectedRevision + 1;
+    database.query(`INSERT INTO person_note_content_revisions(
+      note_id,revision,expected_revision,request_id,expected_context_sha256,context_json,title,body
+    ) VALUES (?,?,?,?,?,?,?,?)`).run(input.noteId, revision, input.expectedRevision, input.requestId, input.expectedContextSha256, context.contextJson, input.title, input.body);
+    const inserted = database.query("SELECT * FROM person_note_content_revisions WHERE note_id=? AND revision=?").get(input.noteId, revision);
+    if (inserted === null)
+      throw new Error("Note revision was not recorded.");
+    database.exec("COMMIT");
+    return { kind: "created", revision: mapRevision(inserted) };
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
+function listPersonNoteRevisions(database, input) {
+  positiveInteger(input.noteId, "Note ID");
+  const limit = input.limit ?? 50;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > 1000)
+    invalid("Note history limit must be between 1 and 1000.");
+  if (input.beforeRevision !== undefined && (!Number.isSafeInteger(input.beforeRevision) || input.beforeRevision < 1)) {
+    invalid("Before revision must be a positive safe integer.");
+  }
+  return database.transaction(() => {
+    const original = database.query("SELECT id FROM person_notes WHERE id=?").get(input.noteId);
+    if (original === null)
+      throw new NoteRevisionError("not_found", "Note not found.");
+    const current = database.query("SELECT coalesce(max(revision),0) AS revision FROM person_note_content_revisions WHERE note_id=?").get(input.noteId);
+    const before = input.beforeRevision ?? null;
+    const rows = database.query(`
+      SELECT note_id,revision,expected_revision,expected_context_sha256,request_id,title,body,created_at
+      FROM person_note_content_revisions WHERE note_id=? AND (? IS NULL OR revision<?)
+      UNION ALL SELECT id,0,NULL,NULL,NULL,title,body,created_at FROM person_notes WHERE id=?
+      ORDER BY revision DESC LIMIT ?
+    `).all(input.noteId, before, before, input.noteId, limit + 1);
+    const items = rows.slice(0, limit).map(mapRevision);
+    return {
+      items,
+      currentRevision: Number(current.revision),
+      nextBeforeRevision: rows.length > limit ? items.at(-1).revision : null
+    };
+  }).deferred();
+}
 
 // src/local/notes.ts
 import { closeSync as closeSync2, constants as constants2, fstatSync as fstatSync2, openSync as openSync2, readFileSync as readFileSync2 } from "fs";
@@ -4896,24 +5447,6 @@ function parseLimit(value) {
   }
   return limit;
 }
-function boundedBody(value, label) {
-  const body = value.normalize("NFKC").trim();
-  if (body.length === 0)
-    fail(`${label} must not be empty.`);
-  if (/[\u0000\r]/u.test(body))
-    fail(`${label} contains an unsupported control character.`);
-  if (Buffer.byteLength(body, "utf8") > MAX_BODY_BYTES)
-    fail(`${label} exceeds 64 KiB.`);
-  if (body.length > MAX_BODY_BYTES)
-    fail(`${label} exceeds the stored character limit.`);
-  return body;
-}
-function boundedTitle(value) {
-  if (value === undefined)
-    return null;
-  const title = cleanText(value, MAX_TITLE_CHARS);
-  return title;
-}
 function metadataObject(value) {
   if (value === undefined)
     return {};
@@ -4931,7 +5464,7 @@ function canonicalPersonId2(database, personId) {
     fail("Person not found.");
   return Number(row.canonical_person_id);
 }
-function mapNote(row) {
+function mapNote(row, context) {
   let metadata = {};
   try {
     const parsed = JSON.parse(row.metadata_json);
@@ -4950,9 +5483,90 @@ function mapNote(row) {
     title: row.title === null ? null : String(row.title),
     body: String(row.body),
     metadata,
-    createdAt: String(row.created_at)
+    createdAt: String(row.created_at),
+    revision: context.revision,
+    revisedAt: row.revised_at ?? null,
+    contextSha256: context.contextSha256
   };
 }
+function mapEffectiveNotes(database, rows) {
+  const contexts = personNoteContexts(database, rows.map((row) => Number(row.id)));
+  return rows.map((row) => {
+    const context = contexts.get(Number(row.id));
+    if (context === undefined || context.revision !== Number(row.revision ?? 0)) {
+      throw new Error("Stored note content and identity context disagree.");
+    }
+    return mapNote(row, context);
+  });
+}
+function getPersonNote(database, noteId) {
+  parsePersonId(noteId, "Note ID");
+  return database.transaction(() => {
+    const row = database.query("SELECT * FROM person_notes_effective WHERE id=?").get(noteId);
+    if (row === null)
+      throw new NoteRevisionError("not_found", "Note not found.");
+    return mapEffectiveNotes(database, [row])[0];
+  }).deferred();
+}
+function personNoteContext(database, personId) {
+  const context = personNoteCreationContext(database, personId);
+  return { personId: context.personId, canonicalPersonId: context.canonicalPersonId, contextSha256: context.contextSha256 };
+}
+function workspaceOccurredAt(value) {
+  if (typeof value !== "string" || value.length > 80) {
+    throw new NoteRevisionError("invalid_input", "Occurred-at must be an ISO date or canonical UTC datetime.");
+  }
+  const date = new Date(DATE_ONLY.test(value) ? `${value}T00:00:00.000Z` : value);
+  if (!Number.isFinite(date.valueOf()) || (DATE_ONLY.test(value) ? date.toISOString().slice(0, 10) !== value : date.toISOString() !== value)) {
+    throw new NoteRevisionError("invalid_input", "Occurred-at must be an ISO date or canonical UTC datetime.");
+  }
+  return date.toISOString();
+}
+function createWorkspaceNote(database, input) {
+  if (!Number.isSafeInteger(input.personId) || input.personId < 1) {
+    throw new NoteRevisionError("invalid_input", "Person ID must be a positive safe integer.");
+  }
+  validatePersonNoteMutationRequest(input.requestId, input.expectedPersonContextSha256);
+  validatePersonNoteContent(input.title, input.body);
+  const occurredAt = workspaceOccurredAt(input.occurredAt);
+  database.exec("BEGIN IMMEDIATE");
+  try {
+    const prior = database.query(`SELECT receipt.note_id,receipt.requested_person_id,
+      receipt.expected_context_sha256,receipt.occurred_at_input,note.title,note.body
+      FROM person_note_creation_requests receipt JOIN person_notes note ON note.id=receipt.note_id
+      WHERE receipt.request_id=?`).get(input.requestId);
+    if (prior !== null) {
+      if (Number(prior.requested_person_id) !== input.personId || prior.expected_context_sha256 !== input.expectedPersonContextSha256 || prior.occurred_at_input !== input.occurredAt || prior.title !== input.title || prior.body !== input.body) {
+        throw new NoteRevisionError("request_conflict", "Request ID already belongs to a different note creation.");
+      }
+      database.exec("COMMIT");
+      return { kind: "replayed", noteId: Number(prior.note_id) };
+    }
+    const context = personNoteCreationContext(database, input.personId);
+    if (context.contextSha256 !== input.expectedPersonContextSha256) {
+      throw new NoteRevisionError("context_conflict", "Person identity context changed. Reload and review the person before creating a note.");
+    }
+    const inserted = insertNote(database, {
+      personId: context.canonicalPersonId,
+      occurredAt,
+      source: "manual",
+      sourceId: input.requestId,
+      title: input.title,
+      body: input.body,
+      metadata: {}
+    });
+    if (!inserted.inserted)
+      throw new NoteRevisionError("request_conflict", "A source note already uses this request ID without a workspace creation receipt.");
+    database.query(`INSERT INTO person_note_creation_requests(
+      request_id,note_id,requested_person_id,expected_context_sha256,context_json,occurred_at_input
+    ) VALUES (?,?,?,?,?,?)`).run(input.requestId, inserted.id, input.personId, input.expectedPersonContextSha256, context.contextJson, input.occurredAt);
+    database.exec("COMMIT");
+    return { kind: "created", noteId: inserted.id };
+  } catch (error) {
+    database.exec("ROLLBACK");
+    throw error;
+  }
+}
 function storedGranolaAttendeeIdentity(metadataJson) {
   let metadata;
   try {
@@ -5179,8 +5793,9 @@ function addPersonNote(database, args) {
   const occurredAt = parseOccurredAt(args.occurredAt, "occurred-at");
   const source = parseSource(args.source);
   const sourceId = args.sourceId === undefined ? null : cleanText(args.sourceId, 256);
-  const title = boundedTitle(args.title);
-  const body = boundedBody(args.body, "Note body");
+  const title = args.title ?? null;
+  const body = args.body;
+  validatePersonNoteContent(title, body);
   const metadata = metadataObject(args.metadata);
   database.exec("BEGIN IMMEDIATE");
   try {
@@ -5196,9 +5811,10 @@ function addPersonNote(database, args) {
     });
     if (!inserted.inserted)
       fail("A note for this source identity already exists.");
-    const row = database.query("SELECT * FROM person_notes_current WHERE id=?").get(inserted.id);
+    const row = database.query("SELECT * FROM person_notes_effective WHERE id=?").get(inserted.id);
+    const note = mapEffectiveNotes(database, [row])[0];
     database.exec("COMMIT");
-    return mapNote(row);
+    return note;
   } catch (error) {
     database.exec("ROLLBACK");
     throw error;
@@ -5235,16 +5851,18 @@ function noteFiltersSql(args) {
   };
 }
 function listPersonNotes(database, args) {
-  canonicalPersonId2(database, parsePersonId(args.personId));
   const filters = noteFiltersSql(args);
   const limit = parseLimit(args.limit);
-  const rows = database.query(`
-    SELECT note.* FROM person_notes_current note
-    ${filters.sql}
-    ORDER BY note.occurred_at DESC, note.id DESC
-    LIMIT ?
-  `).all(...filters.bindings, limit);
-  return rows.map(mapNote);
+  return database.transaction(() => {
+    canonicalPersonId2(database, parsePersonId(args.personId));
+    const rows = database.query(`
+      SELECT note.* FROM person_notes_effective note
+      ${filters.sql}
+      ORDER BY note.occurred_at DESC, note.id DESC
+      LIMIT ?
+    `).all(...filters.bindings, limit);
+    return mapEffectiveNotes(database, rows);
+  }).deferred();
 }
 function ftsMatch(query) {
   const tokens = query.normalize("NFKC").trim().slice(0, MAX_QUERY_CHARS).split(/[^\p{L}\p{N}]+/u).map((token) => token.toLocaleLowerCase("en-US")).filter((token) => token.length > 0);
@@ -5256,8 +5874,6 @@ function searchPersonNotes(database, args) {
   if (typeof args.query !== "string" || args.query.trim().length === 0) {
     fail("Search query is required.");
   }
-  if (args.personId !== undefined)
-    canonicalPersonId2(database, parsePersonId(args.personId));
   const match = ftsMatch(args.query);
   const filters = noteFiltersSql({
     ...args.personId === undefined ? {} : { personId: args.personId },
@@ -5266,15 +5882,19 @@ function searchPersonNotes(database, args) {
     ...args.source === undefined ? {} : { source: args.source }
   });
   const limit = parseLimit(args.limit);
-  const where = filters.sql.length === 0 ? "WHERE person_notes_fts MATCH ?" : `${filters.sql} AND person_notes_fts MATCH ?`;
-  const rows = database.query(`
-    SELECT note.* FROM person_notes_fts
-    JOIN person_notes_current note ON note.id=person_notes_fts.rowid
-    ${where}
-    ORDER BY note.occurred_at DESC, note.id DESC
-    LIMIT ?
-  `).all(...filters.bindings, match, limit);
-  return rows.map(mapNote);
+  const where = filters.sql.length === 0 ? "WHERE person_notes_effective_fts MATCH ?" : `${filters.sql} AND person_notes_effective_fts MATCH ?`;
+  return database.transaction(() => {
+    if (args.personId !== undefined)
+      canonicalPersonId2(database, parsePersonId(args.personId));
+    const rows = database.query(`
+      SELECT note.* FROM person_notes_effective_fts
+      JOIN person_notes_effective note ON note.id=person_notes_effective_fts.rowid
+      ${where}
+      ORDER BY note.occurred_at DESC, note.id DESC
+      LIMIT ?
+    `).all(...filters.bindings, match, limit);
+    return mapEffectiveNotes(database, rows);
+  }).deferred();
 }
 function recordValue(record, ...keys) {
   for (const key of keys) {
@@ -5360,8 +5980,8 @@ function firstCleanText(record, keys, maximum) {
 }
 function granolaBody(record) {
   const privateNotes = firstCleanText(record, ["privateNotes", "private_notes", "notes"], MAX_BODY_BYTES);
-  const summary = firstCleanText(record, ["summary_markdown", "summary", "summary_text", "aiSummary", "ai_summary"], MAX_BODY_BYTES);
-  const parts = [privateNotes, summary].filter((part) => part !== null);
+  const summary2 = firstCleanText(record, ["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;
   const joined = parts.join(`
@@ -5371,8 +5991,8 @@ function granolaBody(record) {
     return joined;
   if (privateNotes !== null && Buffer.byteLength(privateNotes, "utf8") <= MAX_BODY_BYTES)
     return privateNotes;
-  if (summary !== null && Buffer.byteLength(summary, "utf8") <= MAX_BODY_BYTES)
-    return summary;
+  if (summary2 !== null && Buffer.byteLength(summary2, "utf8") <= MAX_BODY_BYTES)
+    return summary2;
   return joined.slice(0, MAX_BODY_BYTES);
 }
 function inviteeEmailByName(record) {
@@ -5788,55 +6408,774 @@ function readGranolaImportFile(path) {
     closeSync2(descriptor);
   }
 }
-function parseGranolaImportJson(raw) {
-  if (Buffer.byteLength(raw, "utf8") > MAX_IMPORT_BYTES) {
-    fail("Granola import exceeds the bounded size limit.");
+function parseGranolaImportJson(raw) {
+  if (Buffer.byteLength(raw, "utf8") > MAX_IMPORT_BYTES) {
+    fail("Granola import exceeds the bounded size limit.");
+  }
+  try {
+    return JSON.parse(raw);
+  } catch {
+    fail("Granola import is not valid JSON.");
+  }
+}
+
+// src/local/workspace-assets.ts
+var workspaceHtml = `<!doctype html>
+<html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>PeopleBlade \xB7 Local workspace</title><link rel="stylesheet" href="/workspace.css"><script src="/workspace.js" defer></script></head>
+<body><a class="skip" href="#workspace">Skip to contacts</a><header><a class="brand" href="/">PeopleBlade<span>LOCAL WORKSPACE</span></a><p>Your people. Your machine.</p><span class="privacy">No cloud sync \xB7 no enrichment calls</span></header>
+<main id="workspace"><section id="unlock" class="unlock"><span class="eyebrow">PRIVATE BY DEFAULT</span><h1>Open your local contact book.</h1><p>Select the access file printed by <code>peopleblade ui</code>. It connects this tab to that running process only. The file is not uploaded to a remote service.</p><label class="file-label">Workspace access file<input id="access-file" type="file" accept="application/json,.json"></label><p class="muted">Keep the terminal running. Closing it locks the workspace. Notes never leave this machine.</p></section>
+<section id="book" hidden><div class="page-heading"><div><span class="eyebrow">YOUR RELATIONSHIPS</span><h1>Contact book</h1></div><button id="lock" type="button">Lock workspace</button></div>
+<form id="filters" class="filters"><label class="search">Search contacts<input id="search" name="search" type="search" placeholder="Name, company, title, email, phone\u2026" maxlength="200"></label><label>Source<select id="source"><option value="">All sources</option><option>apple</option><option>beeper</option><option>google</option><option>imessage</option><option>linkedin</option><option>instagram</option><option>whatsapp</option><option>x</option></select></label><label>Email<select id="email"><option value="">Any email</option><option value="yes">Has email</option><option value="no">Needs email</option></select></label><label>Contact preference<select id="dnc"><option value="all">All contacts</option><option value="exclude">May contact</option><option value="only">Do not contact</option></select></label><button type="submit">Search</button><button id="reset" type="button">Reset</button></form>
+<div class="workspace-grid"><section class="records" aria-label="Contacts"><div class="table-toolbar"><span id="range" aria-live="polite"></span><div><label>Sort <select id="sort"><option value="interactions">Interactions</option><option value="name">Name</option><option value="organization">Company</option><option value="last-contact">Last interaction</option></select></label><button id="direction" type="button" aria-label="Toggle sort direction">Descending \u2193</button></div></div><div class="table-scroll" tabindex="0" aria-label="Scrollable contacts"><table><caption class="sr-only">Local contacts; open a person to inspect details and notes.</caption><thead><tr><th scope="col">Person</th><th scope="col">Company</th><th scope="col">Interactions</th></tr></thead><tbody id="rows"></tbody></table></div><div id="empty" class="empty" hidden>No matches. Try another search or import a source with the CLI.</div><nav class="pagination" aria-label="Contact pages"><button id="previous" type="button">\u2190 Previous</button><span id="page"></span><button id="next" type="button">Next \u2192</button></nav><p class="live-note">Live view: imports and identity reviews can move rows between pages. Refresh after changes.</p></section>
+<aside id="detail" class="detail" aria-label="Contact details"><div class="empty"><h2>A little context goes a long way.</h2><p>Open a person to see their contact methods, sources and private notes.</p></div></aside></div></section>
+<p id="status" role="status" aria-live="polite"></p></main><footer>PeopleBlade \xB7 Local authority, reviewable identity, private notes.</footer></body></html>`;
+var workspaceCss = `
+:root{color-scheme:light dark;--bg:#f6f5f1;--panel:#fffefa;--text:#232721;--muted:#647064;--line:#dedfd6;--accent:#375a42;--soft:#edf1e8;--danger:#9c342d}*{box-sizing:border-box}body{margin:0;background:var(--bg);color:var(--text);font:14px/1.55 system-ui,-apple-system,BlinkMacSystemFont,"Segoe UI",sans-serif}button,input,select,textarea{font:inherit;color:inherit}button,input,select,textarea{border:1px solid var(--line);border-radius:7px;background:var(--panel);padding:9px 12px}button{cursor:pointer;font-weight:550}button:hover{border-color:var(--accent);background:var(--soft)}button:disabled{opacity:.45;cursor:default}a{color:var(--accent)}:focus-visible{outline:3px solid var(--accent);outline-offset:3px}header{display:flex;align-items:center;gap:30px;padding:22px 32px;border-bottom:1px solid var(--line);background:var(--panel)}header p{color:var(--muted);margin:0}.brand{color:var(--text);font-size:22px;line-height:1.1;text-decoration:none;font-weight:650;letter-spacing:-.7px}.brand span{display:block;font-size:9px;letter-spacing:1.8px;color:var(--muted);margin-top:8px}.privacy{margin-left:auto;border:1px solid var(--line);border-radius:99px;padding:6px 12px;font-size:11px;color:var(--muted)}main{max-width:1600px;margin:auto;padding:36px 32px}h1{font-size:34px;line-height:1.2;letter-spacing:-1px;font-weight:550;margin:8px 0 24px}h2{font-size:21px;line-height:1.3;letter-spacing:-.5px;margin:0 0 12px}.eyebrow{font-size:10px;letter-spacing:2px;color:var(--muted);font-weight:650}.unlock{max-width:600px;margin:7vh auto;padding:36px;background:var(--panel);border:1px solid var(--line);border-radius:12px}.unlock p{color:var(--muted)}.file-label{display:grid;gap:8px;margin:25px 0}.page-heading{display:flex;align-items:center;justify-content:space-between}.page-heading button{margin-bottom:20px}.filters{display:flex;gap:10px;align-items:end;margin-bottom:20px;flex-wrap:wrap}.filters label{display:grid;gap:5px;font-size:11px;color:var(--muted)}.filters input,.filters select{font-size:13px;color:var(--text);min-height:42px}.filters .search{flex:1;min-width:220px}.workspace-grid{display:grid;grid-template-columns:minmax(420px,1.4fr) minmax(320px,1fr);gap:20px;align-items:start}.records,.detail{border:1px solid var(--line);background:var(--panel);border-radius:10px;overflow:hidden}.table-toolbar{display:flex;justify-content:space-between;align-items:center;gap:12px;padding:13px 16px;border-bottom:1px solid var(--line);color:var(--muted);font-size:12px;flex-wrap:wrap}.table-toolbar>div{display:flex;align-items:center;gap:6px}.table-toolbar select,.table-toolbar button{padding:5px 8px;font-size:12px}.table-scroll{overflow:auto;max-height:65vh}table{width:100%;border-collapse:collapse;text-align:left}th{position:sticky;top:0;background:var(--soft);font-size:10px;text-transform:uppercase;letter-spacing:1px;color:var(--muted);z-index:1}th,td{padding:11px 16px;border-bottom:1px solid var(--line);vertical-align:top}td{font-size:12px}td small{display:block;color:var(--muted);margin-top:2px}td button{padding:0;border:0;background:none;text-align:left;font-size:13px;color:var(--text)}tr.selected{background:var(--soft)}tr:hover{background:var(--soft)}.pagination{display:flex;justify-content:space-between;align-items:center;padding:14px 16px;font-size:12px}.pagination button{font-size:12px;padding:6px 10px}.live-note{font-size:10px;color:var(--muted);padding:0 16px 12px;margin:0}.detail{padding:24px;position:sticky;top:20px;max-height:83vh;overflow:auto}.detail h2{font-size:25px}.detail dl{display:grid;grid-template-columns:90px 1fr;gap:8px;margin:22px 0}.detail dt{font-size:11px;color:var(--muted)}.detail dd{margin:0;font-size:12px;overflow-wrap:anywhere}.detail dd span{display:block}.pill{display:inline-block;border:1px solid var(--line);border-radius:99px;padding:2px 8px;margin:0 4px 5px 0;color:var(--muted);font-size:10px}.notes-heading{border-top:1px solid var(--line);padding-top:22px;margin-top:24px;display:flex;justify-content:space-between;align-items:center}.notes-heading h3{margin:0;font-weight:550}.note-card{border-bottom:1px solid var(--line);padding:16px 0}.note-card>button{font-size:12px;padding:5px 9px;margin:8px 6px 0 0}.note-meta{font-size:10px;color:var(--muted);margin:4px 0 10px}.note-title{font-size:14px;font-weight:600;margin:0}.markdown{font-size:13px;overflow-wrap:anywhere}.markdown h1,.markdown h2,.markdown h3{font-size:17px;margin:12px 0}.markdown pre{overflow:auto;background:var(--soft);padding:12px;border-radius:6px}.markdown img{display:none}.markdown blockquote{margin-left:0;padding-left:12px;border-left:3px solid var(--line);color:var(--muted)}.markdown p{margin:8px 0}.markdown td,.markdown th{padding:5px;position:static}.editor{display:grid;gap:10px}.editor label{display:grid;gap:4px;font-size:11px;color:var(--muted)}.editor textarea{min-height:230px;resize:vertical;font-family:ui-monospace,SFMono-Regular,monospace;font-size:12px;tab-size:2}.editor-actions{display:flex;gap:6px;flex-wrap:wrap}.editor-actions button{font-size:12px}.primary{background:var(--accent);color:var(--panel)}.primary:hover{background:var(--accent);color:var(--panel)}.empty{padding:44px 22px;color:var(--muted);text-align:center}.empty h2{font-size:21px}.muted{color:var(--muted);font-size:12px}.danger{color:var(--danger)}#status{background:var(--panel);border:1px solid var(--line);padding:12px 16px;border-radius:8px}#status:empty{display:none}footer{color:var(--muted);font-size:11px;text-align:center;padding:20px}.skip{position:absolute;left:12px;top:-100px;padding:8px;background:var(--panel);z-index:5}.skip:focus{top:8px}.sr-only{position:absolute;width:1px;height:1px;padding:0;margin:-1px;overflow:hidden;clip:rect(0,0,0,0);white-space:nowrap;border:0}[hidden]{display:none!important}
+@media(prefers-color-scheme:dark){:root{--bg:#151a17;--panel:#1c231e;--text:#e1e7dc;--muted:#a3b19e;--line:#354136;--accent:#a9c4a3;--soft:#28342b;--danger:#ffb4a9}.primary{color:#182019}}
+@media(max-width:1000px){.workspace-grid{grid-template-columns:1fr}.detail{position:static;max-height:none}.privacy{display:none}}@media(max-width:600px){header{padding:18px;gap:18px}header p{font-size:11px}main{padding:26px 14px}.unlock{padding:22px;margin:25px 0}h1{font-size:28px}.filters{gap:8px}.filters label{flex:1;min-width:125px}.filters .search{flex-basis:100%}th,td{padding:10px}.detail{padding:18px}.table-toolbar{padding:10px}.page-heading{align-items:start}.page-heading button{font-size:11px}.table-scroll{max-height:50vh}}
+`;
+function workspaceClient() {
+  const el = (id) => document.getElementById(id);
+  let capability = "";
+  let offset = 0;
+  let direction = "desc";
+  let selectedPerson = null;
+  let dirty = false;
+  let activeSave = false;
+  let activeEditor = null;
+  let editorGeneration = 0;
+  let detailLoading = false;
+  let generation = 0;
+  let detailGeneration = 0;
+  let page = null;
+  const status = (message) => {
+    el("status").textContent = message;
+  };
+  const node = (tag, text = "", className = "") => {
+    const element = document.createElement(tag);
+    element.textContent = text;
+    element.className = className;
+    return element;
+  };
+  async function api(payload) {
+    const response = await fetch("/api", { method: "POST", cache: "no-store", signal: AbortSignal.timeout(15000), headers: { "content-type": "application/json", authorization: `Bearer ${capability}` }, body: JSON.stringify(payload) });
+    const envelope = await response.json();
+    if (!response.ok || envelope.ok !== true) {
+      const error = new Error(typeof envelope.message === "string" ? envelope.message : response.status === 401 ? "Access expired. Load the current access file again." : "The request failed.");
+      Object.assign(error, { status: response.status });
+      throw error;
+    }
+    return envelope.result;
+  }
+  function mayDiscard() {
+    if (activeSave) {
+      status("Wait for the current save outcome before switching notes or locking.");
+      return false;
+    }
+    if (detailLoading) {
+      status("Wait for the contact to finish loading before switching notes or locking.");
+      return false;
+    }
+    return !dirty || window.confirm("Discard your unsaved note draft?");
+  }
+  function query() {
+    const email = el("email").value;
+    return { search: el("search").value, ...el("source").value ? { source: el("source").value } : {}, ...email ? { hasEmail: email === "yes" } : {}, doNotContact: el("dnc").value, sort: el("sort").value, direction, limit: 50, offset };
+  }
+  async function load() {
+    const current = ++generation;
+    status("Loading contacts\u2026");
+    try {
+      const result = await api({ action: "query", query: query() });
+      if (current !== generation || !capability)
+        return;
+      page = result;
+      const sourceSelect = el("source");
+      const selectedSource = sourceSelect.value;
+      sourceSelect.replaceChildren(new Option("All sources", ""));
+      for (const facet of result.facets.sources)
+        sourceSelect.add(new Option(`${facet.source} (${facet.count})`, facet.source));
+      if (selectedSource && !result.facets.sources.some((facet) => facet.source === selectedSource))
+        sourceSelect.add(new Option(selectedSource, selectedSource));
+      sourceSelect.value = selectedSource;
+      el("rows").replaceChildren();
+      for (const person of result.items) {
+        const row = node("tr", "", selectedPerson === person.id ? "selected" : "");
+        const name = node("td");
+        const open = node("button", person.displayName);
+        open.type = "button";
+        open.addEventListener("click", () => {
+          if (mayDiscard()) {
+            dirty = false;
+            showPerson(person.id);
+          }
+        });
+        name.append(open, 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());
+        interactions.append(node("small", person.doNotContact ? "Do not contact" : person.reciprocal ? "Reciprocal" : "One-way / unknown"));
+        row.append(name, company, interactions);
+        el("rows").append(row);
+      }
+      el("range").textContent = result.items.length === 0 ? `0 shown \xB7 ${result.total.toLocaleString()} matching contacts` : `${offset + 1}\u2013${offset + result.items.length} of ${result.total.toLocaleString()} contacts`;
+      el("empty").hidden = result.items.length !== 0;
+      el("page").textContent = `Page ${Math.floor(offset / 50) + 1}`;
+      el("previous").disabled = offset === 0;
+      el("next").disabled = result.nextOffset === null;
+      status("");
+    } catch (error) {
+      if (current === generation)
+        status(error instanceof Error ? error.message : "Contact query failed.");
+    }
+  }
+  function renderNote(note, target) {
+    const card = node("article", "", "note-card");
+    card.dataset.noteId = String(note.id);
+    card.append(node("h4", note.title ?? "Untitled note", "note-title"), node("p", `${note.occurredAt.slice(0, 10)} \xB7 ${note.source} original \xB7 revision ${note.revision}`, "note-meta"));
+    const preview = node("div", "", "markdown");
+    preview.innerHTML = note.previewHtml ?? "";
+    card.append(preview);
+    const edit = node("button", "Edit markdown");
+    edit.type = "button";
+    edit.dataset.noteAction = "edit";
+    edit.addEventListener("click", () => {
+      if (mayDiscard())
+        editNote(note, card);
+    });
+    const history = node("button", "History");
+    history.type = "button";
+    history.dataset.noteAction = "history";
+    history.addEventListener("click", () => {
+      showHistory(note, card);
+    });
+    card.append(edit, history);
+    target.append(card);
+  }
+  async function showHistory(note, card, beforeRevision, existing) {
+    try {
+      const history = await api({ action: "note-history", noteId: note.id, ...beforeRevision === undefined ? {} : { beforeRevision } });
+      const container = existing ?? node("details");
+      if (!existing) {
+        container.setAttribute("open", "");
+        container.append(node("summary", "Revision history"));
+      }
+      for (const item of history.items) {
+        const entry = node("details");
+        entry.append(node("summary", `${item.revision === 0 ? "Original imported content" : `User revision ${item.revision}`} \xB7 ${item.createdAt}`), node("pre", item.body));
+        const restore = node("button", "Use this as a new draft");
+        restore.type = "button";
+        restore.addEventListener("click", () => {
+          if (mayDiscard())
+            editNote(note, card, item);
+        });
+        entry.append(restore);
+        container.append(entry);
+      }
+      if (history.nextBeforeRevision !== null) {
+        const older = node("button", "Older revisions");
+        older.type = "button";
+        older.dataset.noteAction = "older";
+        older.addEventListener("click", () => {
+          older.remove();
+          showHistory(note, card, history.nextBeforeRevision ?? undefined, container);
+        });
+        container.append(older);
+      }
+      if (!existing)
+        card.append(container);
+    } catch (error) {
+      status(error instanceof Error ? error.message : "History could not be loaded.");
+    }
+  }
+  function editNote(note, card, restore) {
+    if (activeSave || detailLoading)
+      return;
+    editorGeneration++;
+    if (activeEditor && activeEditor.card !== card) {
+      if (activeEditor.note.id === 0)
+        activeEditor.card.remove();
+      else {
+        const replacement = node("div");
+        renderNote(activeEditor.note, replacement);
+        activeEditor.card.replaceWith(...replacement.childNodes);
+      }
+    }
+    activeEditor = { note, card };
+    card.dataset.noteId = String(note.id);
+    const original = { title: note.title ?? "", body: note.body };
+    card.replaceChildren();
+    const editor = node("form", "", "editor");
+    const titleLabel = node("label", "Title");
+    const title = document.createElement("input");
+    title.value = restore ? restore.title ?? "" : original.title;
+    title.maxLength = 1024;
+    title.spellcheck = false;
+    title.autocomplete = "off";
+    titleLabel.append(title);
+    const bodyLabel = node("label", "Markdown note \xB7 private to this machine");
+    const body = document.createElement("textarea");
+    body.value = restore?.body ?? original.body;
+    body.spellcheck = false;
+    body.autocomplete = "off";
+    body.setAttribute("autocorrect", "off");
+    body.setAttribute("autocapitalize", "off");
+    bodyLabel.append(body);
+    const preview = node("div", "", "markdown");
+    preview.hidden = true;
+    const actions = node("div", "", "editor-actions");
+    const save = node("button", "Save revision", "primary");
+    save.type = "submit";
+    const toggle = node("button", "Preview");
+    toggle.type = "button";
+    toggle.dataset.noteAction = "preview";
+    toggle.addEventListener("click", async () => {
+      try {
+        preview.hidden = !preview.hidden;
+        if (!preview.hidden) {
+          const result = await api({ action: "preview", body: body.value });
+          preview.innerHTML = result.html;
+        }
+        toggle.textContent = preview.hidden ? "Preview" : "Hide preview";
+      } catch {
+        status("Preview is unavailable. Your draft is unchanged.");
+      }
+    });
+    const cancel = node("button", "Cancel");
+    cancel.type = "button";
+    cancel.dataset.noteAction = "cancel";
+    cancel.addEventListener("click", () => {
+      if (mayDiscard()) {
+        dirty = false;
+        if (selectedPerson !== null)
+          showPerson(selectedPerson);
+      }
+    });
+    const download = node("button", "Download draft");
+    download.type = "button";
+    download.addEventListener("click", () => {
+      const url = URL.createObjectURL(new Blob([body.value], { type: "text/markdown;charset=utf-8" }));
+      const link = document.createElement("a");
+      link.href = url;
+      link.download = `peopleblade-note-${note.id}.md`;
+      link.click();
+      setTimeout(() => URL.revokeObjectURL(url), 1000);
+    });
+    actions.append(save, toggle, cancel, download);
+    editor.append(titleLabel, bodyLabel, preview, actions);
+    card.append(editor);
+    let pending = null;
+    let saving = false;
+    let acknowledged = false;
+    const changed = () => {
+      editorGeneration++;
+      dirty = title.value !== original.title || body.value !== original.body;
+    };
+    title.addEventListener("input", changed);
+    body.addEventListener("input", changed);
+    changed();
+    editor.addEventListener("submit", async (event) => {
+      event.preventDefault();
+      if (saving || acknowledged || detailLoading)
+        return;
+      pending ??= {
+        ...note.id === 0 ? { action: "note-create", personId: note.personId, expectedPersonContextSha256: note.contextSha256, occurredAt: note.occurredAt } : { action: "note-update", noteId: note.id, expectedRevision: note.revision, expectedContextSha256: note.contextSha256 },
+        requestId: crypto.randomUUID(),
+        title: title.value.trim() === "" ? null : title.value,
+        body: body.value
+      };
+      saving = true;
+      activeSave = true;
+      save.disabled = true;
+      body.readOnly = true;
+      title.readOnly = true;
+      status("Saving an immutable revision\u2026");
+      try {
+        await api(pending);
+        acknowledged = true;
+        pending = null;
+        dirty = false;
+        save.textContent = "Saved";
+        status("Note saved. Original content and history are preserved.");
+        const refreshed = selectedPerson !== null && await showPerson(selectedPerson);
+        if (!refreshed) {
+          cancel.textContent = "Reload saved note";
+          status("Note saved. Details could not be refreshed. Reload the saved note; it will not be submitted again.");
+        }
+      } catch (error) {
+        const responseStatus = error.status;
+        const conflict = responseStatus === 409;
+        const rejected = responseStatus !== undefined && responseStatus >= 400 && responseStatus < 500;
+        status(conflict ? "This note or its contact identity changed. Download your draft, then Cancel to reload before applying it." : rejected ? error instanceof Error ? error.message : "The note was rejected; correct the draft and try again." : "Save outcome is uncertain. Retry sends the same request safely; keep this tab open or download your draft.");
+        if (rejected) {
+          pending = null;
+          body.readOnly = false;
+          title.readOnly = false;
+        }
+        save.textContent = rejected ? "Save revision" : "Retry same save";
+      } finally {
+        saving = false;
+        activeSave = false;
+        save.disabled = acknowledged;
+      }
+    });
+    body.addEventListener("keydown", (event) => {
+      if ((event.metaKey || event.ctrlKey) && event.key === "Enter") {
+        event.preventDefault();
+        editor.dispatchEvent(new Event("submit", { cancelable: true }));
+      }
+    });
+    body.focus();
+  }
+  async function showPerson(id, noteSearch = "") {
+    const current = ++detailGeneration;
+    const editorAtRequest = editorGeneration;
+    const target = el("detail");
+    detailLoading = true;
+    target.inert = true;
+    status("Loading person and notes\u2026");
+    try {
+      const result = await api({ action: "detail", personId: id, ...noteSearch ? { noteSearch } : {} });
+      const notes = result.notes;
+      if (current !== detailGeneration || !capability)
+        return false;
+      if (editorAtRequest !== editorGeneration) {
+        status("Contact loading was canceled because the note draft changed.");
+        return false;
+      }
+      activeEditor = null;
+      selectedPerson = id;
+      target.replaceChildren();
+      target.append(node("span", `PERSON ${id} \xB7 ${result.memberCount} SOURCE RECORD${result.memberCount === 1 ? "" : "S"}`, "eyebrow"), node("h2", result.contact.displayName));
+      const pills = node("div");
+      result.contact.sources.forEach((source) => pills.append(node("span", source, "pill")));
+      target.append(pills);
+      const fields = node("dl");
+      for (const [label, value] of [["Company", result.contact.organization], ["Title", result.contact.title], ["Preference", result.contact.doNotContact ? "Do not contact" : "No do-not-contact flag"], ["Interactions", result.contact.interactionCount.toLocaleString()]]) {
+        fields.append(node("dt", label ?? ""), node("dd", value ?? "\u2014"));
+      }
+      fields.append(node("dt", "Methods"));
+      const methods = node("dd");
+      result.methods.items.forEach((method) => methods.append(node("span", `${method.kind}: ${method.value}`)));
+      if (result.methods.truncated)
+        methods.append(node("span", `Showing ${result.methods.items.length} of ${result.methods.total}. Use the CLI for a narrower query.`));
+      fields.append(methods);
+      target.append(fields);
+      const heading = node("div", "", "notes-heading");
+      heading.append(node("h3", "Private notes"), node("span", "LOCAL ONLY", "eyebrow"));
+      target.append(heading);
+      target.append(node("p", "Latest 20 matching notes. Search older notes below. Edits preserve source content; identity review and joins remain explicit CLI actions.", "muted"));
+      const noteTools = node("form", "", "editor-actions");
+      const searchLabel = node("label", "Search notes ");
+      const noteQuery = document.createElement("input");
+      noteQuery.type = "search";
+      noteQuery.maxLength = 200;
+      noteQuery.value = noteSearch;
+      searchLabel.append(noteQuery);
+      const searchNotes = node("button", "Find");
+      searchNotes.type = "submit";
+      const add = node("button", "New note");
+      add.type = "button";
+      add.dataset.noteAction = "create";
+      noteTools.append(searchLabel, searchNotes, add);
+      target.append(noteTools);
+      noteTools.addEventListener("submit", (event) => {
+        event.preventDefault();
+        if (mayDiscard()) {
+          dirty = false;
+          showPerson(id, noteQuery.value);
+        }
+      });
+      const noteContainer = node("div");
+      target.append(noteContainer);
+      add.addEventListener("click", () => {
+        if (!mayDiscard())
+          return;
+        dirty = false;
+        const draft = node("article", "", "note-card");
+        noteContainer.prepend(draft);
+        editNote({ id: 0, personId: id, title: null, body: "", occurredAt: new Date().toISOString(), source: "manual", revision: 0, contextSha256: result.noteContext.contextSha256 }, draft);
+      });
+      if (notes.length === 0)
+        noteContainer.append(node("p", "No notes yet.", "muted"));
+      for (const note of notes)
+        renderNote(note, noteContainer);
+      status("");
+      return true;
+    } catch (error) {
+      if (current === detailGeneration)
+        status(error instanceof Error ? error.message : "Contact details could not be loaded.");
+      return false;
+    } finally {
+      if (current === detailGeneration) {
+        detailLoading = false;
+        target.inert = false;
+      }
+    }
+  }
+  el("access-file").addEventListener("change", async (event) => {
+    try {
+      const input = event.target;
+      const file = input.files?.[0];
+      input.value = "";
+      if (!file || file.size > 2048)
+        throw new Error("Choose the small access file printed by the running CLI.");
+      const access = JSON.parse(await file.text());
+      if (access.schemaVersion !== "peopleblade.workspace-access.v1" || access.origin !== location.origin || typeof access.capability !== "string" || !/^[A-Za-z0-9_-]{43}$/.test(access.capability))
+        throw new Error("This access file belongs to another workspace. Use the current CLI file and URL.");
+      capability = access.capability;
+      await api({ action: "ping" });
+      el("unlock").hidden = true;
+      el("book").hidden = false;
+      await load();
+      el("search").focus();
+    } catch (error) {
+      capability = "";
+      status(error instanceof Error ? error.message : "Workspace could not be unlocked.");
+    }
+  });
+  el("lock").addEventListener("click", () => {
+    if (!mayDiscard())
+      return;
+    capability = "";
+    dirty = false;
+    generation++;
+    detailGeneration++;
+    activeEditor = null;
+    selectedPerson = null;
+    el("rows").replaceChildren();
+    el("detail").replaceChildren();
+    el("book").hidden = true;
+    el("unlock").hidden = false;
+    status("Workspace locked.");
+  });
+  el("filters").addEventListener("submit", (event) => {
+    event.preventDefault();
+    offset = 0;
+    load();
+  });
+  el("reset").addEventListener("click", () => {
+    HTMLFormElement.prototype.reset.call(el("filters"));
+    offset = 0;
+    load();
+  });
+  el("sort").addEventListener("change", () => {
+    offset = 0;
+    load();
+  });
+  el("direction").addEventListener("click", () => {
+    direction = direction === "asc" ? "desc" : "asc";
+    el("direction").textContent = direction === "asc" ? "Ascending \u2191" : "Descending \u2193";
+    offset = 0;
+    load();
+  });
+  el("previous").addEventListener("click", () => {
+    offset = Math.max(0, offset - 50);
+    load();
+  });
+  el("next").addEventListener("click", () => {
+    if (page?.nextOffset !== null && page?.nextOffset !== undefined) {
+      offset = page.nextOffset;
+      load();
+    }
+  });
+  window.addEventListener("beforeunload", (event) => {
+    if (dirty || activeSave) {
+      event.preventDefault();
+      event.returnValue = "";
+    }
+  });
+}
+var workspaceScript = `(${workspaceClient.toString()})();`;
+
+// src/local/workspace-security.ts
+import { timingSafeEqual } from "crypto";
+var securityHeaders = {
+  "cache-control": "no-store",
+  "content-security-policy": "default-src 'none'; script-src 'self'; style-src 'self'; connect-src 'self'; img-src 'none'; font-src 'none'; frame-ancestors 'none'; base-uri 'none'; form-action 'none'; object-src 'none'",
+  "referrer-policy": "no-referrer",
+  "x-content-type-options": "nosniff",
+  "x-frame-options": "DENY",
+  "cross-origin-resource-policy": "same-origin",
+  "permissions-policy": "camera=(), microphone=(), geolocation=()"
+};
+
+class WorkspaceRequestError extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+  }
+}
+function json(value, status = 200) {
+  return Response.json(value, { status, headers: securityHeaders });
+}
+async function readPayload(request) {
+  const maximum = 256 * 1024;
+  const length = request.headers.get("content-length");
+  if (length !== null && (!/^(0|[1-9][0-9]*)$/u.test(length) || Number(length) > maximum)) {
+    request.body?.cancel().catch(() => {
+      return;
+    });
+    throw new WorkspaceRequestError("invalid_request", "Request exceeds 256 KiB.");
+  }
+  if (request.body === null)
+    throw new WorkspaceRequestError("invalid_request", "A JSON body is required.");
+  const reader = request.body.getReader();
+  const decoder = new TextDecoder("utf-8", { fatal: true });
+  let size = 0;
+  let text = "";
+  try {
+    for (;; ) {
+      const chunk = await reader.read();
+      if (chunk.done)
+        break;
+      size += chunk.value.byteLength;
+      if (size > maximum)
+        throw new Error("oversized");
+      text += decoder.decode(chunk.value, { stream: true });
+    }
+    text += decoder.decode();
+    return JSON.parse(text);
+  } catch {
+    reader.cancel().catch(() => {
+      return;
+    });
+    throw new WorkspaceRequestError("invalid_request", "Request must be valid UTF-8 JSON within 256 KiB.");
+  } finally {
+    reader.releaseLock();
+  }
+}
+function createWorkspaceHandler(input) {
+  const expected = new URL(input.origin);
+  if (expected.protocol !== "http:" || expected.hostname !== "127.0.0.1" || !expected.port || expected.origin !== input.origin || !/^[A-Za-z0-9_-]{43}$/u.test(input.capability)) {
+    throw new Error("Invalid local workspace authority.");
+  }
+  const secret = Buffer.from(input.capability);
+  return async (request) => {
+    const url = new URL(request.url);
+    if (url.origin !== input.origin || request.headers.get("host") !== expected.host || url.search !== "" || request.headers.get("sec-fetch-site") === "cross-site" || request.headers.has("origin") && request.headers.get("origin") !== input.origin) {
+      request.body?.cancel().catch(() => {
+        return;
+      });
+      return json({ 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] } });
+    }
+    if (request.method !== "POST" || url.pathname !== "/api")
+      return json({ 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);
+    }
+    if (request.headers.get("content-type")?.split(";")[0]?.trim().toLowerCase() !== "application/json") {
+      return json({ error: "unsupported_media_type" }, 415);
+    }
+    try {
+      return json({ 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 json({ ok: false, error: "operation_failed", message: "The operation failed. Your existing data is preserved." }, 500);
+    }
+  };
+}
+
+// src/local/workspace.ts
+var id = z5.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var requestSchema = z5.discriminatedUnion("action", [
+  z5.object({ action: z5.literal("ping") }).strict(),
+  z5.object({ action: z5.literal("query"), query: contactQueryInputSchema }).strict(),
+  z5.object({ action: z5.literal("detail"), personId: id, noteSearch: z5.string().max(200).optional() }).strict(),
+  z5.object({ action: z5.literal("notes"), personId: id, search: z5.string().max(200).optional() }).strict(),
+  z5.object({ action: z5.literal("note"), noteId: id }).strict(),
+  z5.object({ action: z5.literal("note-history"), noteId: id, beforeRevision: z5.number().int().min(1).optional() }).strict(),
+  z5.object({ action: z5.literal("preview"), body: z5.string().max(65536) }).strict(),
+  z5.object({
+    action: z5.literal("note-update"),
+    noteId: id,
+    expectedRevision: z5.number().int().min(0).max(Number.MAX_SAFE_INTEGER - 1),
+    expectedContextSha256: z5.string().regex(/^[0-9a-f]{64}$/u),
+    requestId: z5.uuid(),
+    title: z5.string().max(4096).nullable(),
+    body: z5.string().max(65536)
+  }).strict(),
+  z5.object({
+    action: z5.literal("note-create"),
+    personId: id,
+    expectedPersonContextSha256: z5.string().regex(/^[0-9a-f]{64}$/u),
+    requestId: z5.uuid(),
+    occurredAt: z5.string().max(64),
+    title: z5.string().max(4096).nullable(),
+    body: z5.string().max(65536)
+  }).strict()
+]);
+function dispatchWorkspaceRequest(database, payload) {
+  const parsed = requestSchema.safeParse(payload);
+  if (!parsed.success)
+    throw new WorkspaceRequestError("invalid_request", "Invalid workspace request. Check the action and its fields.");
+  const input = parsed.data;
+  try {
+    switch (input.action) {
+      case "ping":
+        return { schemaVersion: "peopleblade.workspace.v1", localOnly: true };
+      case "query":
+        return queryLocalContacts(database, input.query);
+      case "detail":
+        return database.transaction(() => ({
+          ...getLocalContactDetail(database, input.personId),
+          noteContext: personNoteContext(database, input.personId),
+          notes: ((input.noteSearch?.trim()) ? searchPersonNotes(database, { personId: input.personId, query: input.noteSearch, limit: 20 }) : listPersonNotes(database, { personId: input.personId, limit: 20 })).map((note) => ({ ...note, previewHtml: previewNoteMarkdown(note.body) }))
+        })).deferred();
+      case "notes": {
+        const notes = input.search?.trim() ? searchPersonNotes(database, { personId: input.personId, query: input.search, limit: 20 }) : listPersonNotes(database, { personId: input.personId, limit: 20 });
+        return notes.map((note) => ({ ...note, previewHtml: previewNoteMarkdown(note.body) }));
+      }
+      case "note":
+        return getPersonNote(database, input.noteId);
+      case "note-history":
+        return listPersonNoteRevisions(database, { noteId: input.noteId, beforeRevision: input.beforeRevision, limit: 50 });
+      case "note-update":
+        return revisePersonNote(database, input);
+      case "note-create":
+        return createWorkspaceNote(database, input);
+      case "preview":
+        return { html: previewNoteMarkdown(input.body) };
+    }
+  } catch (error) {
+    if (error instanceof NoteRevisionError) {
+      throw new WorkspaceRequestError(error.code === "not_found" ? "not_found" : error.code === "invalid_input" ? "invalid_request" : "conflict", error.message);
+    }
+    if (input.action === "preview")
+      throw new WorkspaceRequestError("invalid_request", "Markdown preview requires at most 64 KiB of UTF-8 text.");
+    throw error;
+  }
+}
+function startLocalWorkspace(database, port = 0) {
+  if (!Number.isSafeInteger(port) || port < 0 || port > 65535)
+    throw new Error("Workspace port must be 0\u201365535.");
+  const capability = randomBytes(32).toString("base64url");
+  let handler = null;
+  const server = Bun.serve({
+    hostname: "127.0.0.1",
+    port,
+    maxRequestBodySize: 256 * 1024,
+    idleTimeout: 20,
+    fetch(request) {
+      return handler === null ? new Response(null, { status: 503 }) : handler(request);
+    },
+    error() {
+      return new Response("Workspace request failed.", { status: 500, headers: { "cache-control": "no-store" } });
+    }
+  });
+  const origin = `http://127.0.0.1:${server.port}`;
+  let directory;
+  let accessFile;
+  try {
+    directory = mkdtempSync(join(tmpdir(), "peopleblade-workspace-"));
+    chmodSync(directory, 448);
+    accessFile = join(directory, "access.json");
+    writeFileSync(accessFile, JSON.stringify({ schemaVersion: "peopleblade.workspace-access.v1", origin, capability }), { flag: "wx", mode: 384 });
+  } catch (error) {
+    server.stop(true);
+    throw error;
   }
+  const fileIdentity = lstatSync(accessFile);
+  handler = createWorkspaceHandler({
+    origin,
+    capability,
+    assets: { html: workspaceHtml, css: workspaceCss, script: workspaceScript },
+    dispatch: (payload) => dispatchWorkspaceRequest(database, payload)
+  });
+  let stopped = false;
+  const stop = async () => {
+    if (stopped)
+      return;
+    stopped = true;
+    handler = null;
+    await server.stop(true);
+    try {
+      const current = lstatSync(accessFile);
+      if (current.isFile() && !current.isSymbolicLink() && current.ino === fileIdentity.ino && current.dev === fileIdentity.dev && current.nlink === 1)
+        unlinkSync(accessFile);
+      rmdirSync(directory);
+    } catch {}
+  };
+  return { schemaVersion: "peopleblade.workspace.v1", origin, accessFile, localOnly: true, stop };
+}
+async function runLocalWorkspace(database, options = {}) {
+  const workspace = startLocalWorkspace(database, options.port);
+  const { stop: _stop, ...receipt } = workspace;
+  if (options.json)
+    console.log(JSON.stringify(receipt));
+  else
+    console.log(`PeopleBlade local workspace
+${workspace.origin}
+Select this access file in the page: ${workspace.accessFile}
+Keep this terminal open. Press Ctrl+C to lock and stop.`);
+  let terminate = () => {
+    return;
+  };
   try {
-    return JSON.parse(raw);
-  } catch {
-    fail("Granola import is not valid JSON.");
+    await new Promise((resolve) => {
+      terminate = () => resolve();
+      process.once("SIGINT", terminate);
+      process.once("SIGTERM", terminate);
+      process.once("SIGHUP", terminate);
+    });
+  } finally {
+    process.removeListener("SIGINT", terminate);
+    process.removeListener("SIGTERM", terminate);
+    process.removeListener("SIGHUP", terminate);
+    await workspace.stop();
   }
 }
 
 // src/local/cloud-client.ts
-import { createHash as createHash2, randomBytes } from "crypto";
-import { z as z6 } from "zod";
+import { createHash as createHash2, randomBytes as randomBytes2 } from "crypto";
+import { z as z8 } from "zod";
 
 // src/local/cloud-configuration.ts
-import { z as z5 } 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 } from "fs";
+import { closeSync as closeSync3, constants as constants3, existsSync, mkdirSync, openSync as openSync3, readFileSync as readFileSync3, renameSync, writeFileSync as writeFileSync2 } from "fs";
 import { dirname } from "path";
-import { z as z4 } from "zod";
+import { z as z6 } from "zod";
 
 // src/local/paths.ts
 import { homedir, hostname, platform } from "os";
-import { join } from "path";
+import { join as join2 } from "path";
 function peoplebladeDirectory() {
   if (platform() === "darwin")
-    return join(homedir(), "Library", "Application Support", "PeopleBlade");
+    return join2(homedir(), "Library", "Application Support", "PeopleBlade");
   if (platform() === "win32")
-    return join(process.env.LOCALAPPDATA ?? join(homedir(), "AppData", "Local"), "PeopleBlade");
-  return join(process.env.XDG_DATA_HOME ?? join(homedir(), ".local", "share"), "peopleblade");
+    return join2(process.env.LOCALAPPDATA ?? join2(homedir(), "AppData", "Local"), "PeopleBlade");
+  return join2(process.env.XDG_DATA_HOME ?? join2(homedir(), ".local", "share"), "peopleblade");
 }
 function peoplebladeDatabasePath() {
-  return process.env.PEOPLEBLADE_DATABASE ?? join(peoplebladeDirectory(), "peopleblade.sqlite3");
+  return process.env.PEOPLEBLADE_DATABASE ?? join2(peoplebladeDirectory(), "peopleblade.sqlite3");
 }
 function peoplebladeConfigPath() {
-  return join(peoplebladeDirectory(), "config.json");
+  return join2(peoplebladeDirectory(), "config.json");
 }
 function defaultDeviceName() {
   return `${hostname() || "Mac"} \xB7 PeopleBlade CLI`.slice(0, 128);
 }
 
 // src/local/config.ts
-var configSchema = z4.object({
-  cloud: z4.object({
-    baseUrl: z4.url().max(2048),
-    deviceId: z4.uuid(),
-    token: z4.string().min(20).max(512)
+var configSchema = z6.object({
+  cloud: z6.object({
+    baseUrl: z6.url().max(2048),
+    deviceId: z6.uuid(),
+    token: z6.string().min(20).max(512)
   }).strict().nullable()
 }).strict();
 function readLocalConfig() {
@@ -5852,7 +7191,7 @@ function writeLocalConfig(config) {
   const temporary = `${path}.stage-${process.pid}`;
   const descriptor = openSync3(temporary, constants3.O_WRONLY | constants3.O_CREAT | constants3.O_EXCL, 384);
   try {
-    writeFileSync(descriptor, `${JSON.stringify(configSchema.parse(config), null, 2)}
+    writeFileSync2(descriptor, `${JSON.stringify(configSchema.parse(config), null, 2)}
 `);
   } finally {
     closeSync3(descriptor);
@@ -5861,10 +7200,10 @@ function writeLocalConfig(config) {
 }
 
 // src/local/cloud-configuration.ts
-var cloudConfigurationSchema = z5.object({
-  baseUrl: z5.url().max(2048),
-  deviceId: z5.uuid(),
-  token: z5.string().min(20).max(512)
+var cloudConfigurationSchema = z7.object({
+  baseUrl: z7.url().max(2048),
+  deviceId: z7.uuid(),
+  token: z7.string().min(20).max(512)
 }).strict();
 function cloudConfiguration(override) {
   const config = override ?? readLocalConfig().cloud;
@@ -5970,7 +7309,14 @@ function iso(value) {
 function localDatabaseFingerprint(database) {
   return localDatabaseInstanceId(database);
 }
-function projectCloudContacts(database) {
+function projectCloudContacts(database, options = {}) {
+  const selected = options.personIds === undefined ? undefined : [...new Set(options.personIds)];
+  if (selected !== undefined && (selected.length > 100 || selected.some((id2) => !Number.isSafeInteger(id2) || id2 < 1))) {
+    throw new Error("Projection selection requires at most 100 positive canonical person IDs.");
+  }
+  if (selected?.length === 0)
+    return [];
+  const selectionSql = selected === undefined ? "" : `AND p.id IN (${selected.map(() => "?").join(",")})`;
   const rows = database.query(`
     WITH
     ${canonicalInteractionRollupCtesSql},
@@ -6137,11 +7483,12 @@ function projectCloudContacts(database) {
     LEFT JOIN source_rollup ON source_rollup.person_id = p.id
     LEFT JOIN handle_rollup ON handle_rollup.person_id = p.id
     LEFT JOIN resource_eligibility ON resource_eligibility.person_id = p.id
-    WHERE resource_eligibility.person_id IS NULL
+    WHERE (resource_eligibility.person_id IS NULL
       OR resource_eligibility.has_active_resource = 1
-      OR canonical_interaction_rollup.person_id IS NOT NULL
+      OR canonical_interaction_rollup.person_id IS NOT NULL)
+      ${selectionSql}
     ORDER BY p.id
-  `).all();
+  `).all(...selected ?? []);
   const instance = localDatabaseFingerprint(database);
   return rows.map((row) => {
     const sources = sourceLabelSchema.array().parse(parseStringArray(row.sources_json).filter((source) => sourceLabelSchema.safeParse(source).success));
@@ -6182,49 +7529,49 @@ function projectCloudContacts(database) {
 }
 
 // src/local/cloud-client.ts
-var deviceStartResponse = z6.object({
+var deviceStartResponse = z8.object({
   deviceCode: deviceCodeSchema,
-  userCode: z6.string().regex(/^[23456789A-HJ-NP-Z]{8}$/u),
-  verificationUri: z6.url().max(2048),
-  expiresIn: z6.number().int().min(60).max(3600),
-  interval: z6.number().int().min(1).max(30)
+  userCode: z8.string().regex(/^[23456789A-HJ-NP-Z]{8}$/u),
+  verificationUri: z8.url().max(2048),
+  expiresIn: z8.number().int().min(60).max(3600),
+  interval: z8.number().int().min(1).max(30)
 }).strict();
-var deviceStatusResponse = z6.discriminatedUnion("status", [
-  z6.object({ status: z6.literal("pending") }).strict(),
-  z6.object({ status: z6.literal("expired") }).strict(),
-  z6.object({ status: z6.literal("authorized"), deviceId: z6.uuid() }).strict()
+var deviceStatusResponse = z8.discriminatedUnion("status", [
+  z8.object({ status: z8.literal("pending") }).strict(),
+  z8.object({ status: z8.literal("expired") }).strict(),
+  z8.object({ status: z8.literal("authorized"), deviceId: z8.uuid() }).strict()
 ]);
-var boundedModelCoordinateSchema = z6.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u);
-var usageOperationSchema = z6.string().regex(/^[a-z][a-z0-9_]{0,63}$/u);
-var usageProviderSchema = z6.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u);
-var usageUnitSchema = z6.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u);
-var cliEnrichmentUsageLimitResponse = z6.object({
+var boundedModelCoordinateSchema = z8.string().min(1).max(256).regex(/^[A-Za-z0-9][A-Za-z0-9._:/-]*$/u);
+var usageOperationSchema = z8.string().regex(/^[a-z][a-z0-9_]{0,63}$/u);
+var usageProviderSchema = z8.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u);
+var usageUnitSchema = z8.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u);
+var cliEnrichmentUsageLimitResponse = z8.object({
   operation: usageOperationSchema,
   provider: usageProviderSchema,
   unit: usageUnitSchema,
-  maximum: z6.number().int().min(0).max(100)
+  maximum: z8.number().int().min(0).max(100)
 }).strict();
-var cliEnrichmentPreviewResponse = z6.object({
-  previewId: z6.uuid(),
+var cliEnrichmentPreviewResponse = z8.object({
+  previewId: z8.uuid(),
   confirmationToken: cliEnrichmentConfirmationTokenSchema,
-  selectedCount: z6.number().int().min(1).max(100),
-  availableCredits: z6.number().int().min(0),
-  usageLimits: z6.array(cliEnrichmentUsageLimitResponse).min(1).max(16),
-  policyVersion: z6.literal(enrichmentPolicyVersion),
+  selectedCount: z8.number().int().min(1).max(100),
+  availableCredits: z8.number().int().min(0),
+  usageLimits: z8.array(cliEnrichmentUsageLimitResponse).min(1).max(16),
+  policyVersion: z8.literal(enrichmentPolicyVersion),
   model: boundedModelCoordinateSchema,
-  expiresAt: z6.iso.datetime({ offset: true })
+  expiresAt: z8.iso.datetime({ offset: true })
 }).strict();
-var cliPrioritizedEnrichmentContactResponse = z6.object({
-  localPersonId: z6.string().regex(/^[1-9][0-9]{0,18}$/u),
-  enrichmentInputVersion: z6.literal(2),
-  enrichmentInputSha256: z6.string().regex(/^[a-f0-9]{64}$/u),
-  rank: z6.number().int().min(1).max(100),
-  score: z6.number().int().min(0).max(1e4),
-  components: z6.object({
-    engagement: z6.number().int().min(0).max(5500),
-    reciprocity: z6.number().int().min(0).max(1000),
-    dataGaps: z6.number().int().min(0).max(2000),
-    identityReadiness: z6.number().int().min(0).max(1500)
+var cliPrioritizedEnrichmentContactResponse = z8.object({
+  localPersonId: z8.string().regex(/^[1-9][0-9]{0,18}$/u),
+  enrichmentInputVersion: z8.literal(2),
+  enrichmentInputSha256: z8.string().regex(/^[a-f0-9]{64}$/u),
+  rank: z8.number().int().min(1).max(100),
+  score: z8.number().int().min(0).max(1e4),
+  components: z8.object({
+    engagement: z8.number().int().min(0).max(5500),
+    reciprocity: z8.number().int().min(0).max(1000),
+    dataGaps: z8.number().int().min(0).max(2000),
+    identityReadiness: z8.number().int().min(0).max(1500)
   }).strict()
 }).strict().superRefine((value, context) => {
   const total = value.components.engagement + value.components.reciprocity + value.components.dataGaps + value.components.identityReadiness;
@@ -6232,39 +7579,39 @@ var cliPrioritizedEnrichmentContactResponse = z6.object({
     context.addIssue({ code: "custom", path: ["score"], message: "Priority score components drifted" });
 });
 var cliPrioritizedEnrichmentPreviewResponse = cliEnrichmentPreviewResponse.extend({
-  contacts: z6.array(cliPrioritizedEnrichmentContactResponse).min(1).max(100),
-  priority: z6.object({
-    policyVersion: z6.literal(enrichmentPriorityPolicyVersion),
-    asOf: z6.iso.datetime({ offset: true }),
-    receiptSha256: z6.string().regex(/^[a-f0-9]{64}$/u),
-    eligibleCount: z6.number().int().min(1).max(1e6),
-    executionCapacity: z6.tuple([z6.object({
-      operation: z6.literal("enrich_email"),
-      maximum: z6.number().int().min(0).max(100)
+  contacts: z8.array(cliPrioritizedEnrichmentContactResponse).min(1).max(100),
+  priority: z8.object({
+    policyVersion: z8.literal(enrichmentPriorityPolicyVersion),
+    asOf: z8.iso.datetime({ offset: true }),
+    receiptSha256: z8.string().regex(/^[a-f0-9]{64}$/u),
+    eligibleCount: z8.number().int().min(1).max(1e6),
+    executionCapacity: z8.tuple([z8.object({
+      operation: z8.literal("enrich_email"),
+      maximum: z8.number().int().min(0).max(100)
     }).strict()])
   }).strict()
 }).strict();
-var cliEnrichmentDispatchResponse = z6.object({
-  jobId: z6.uuid(),
-  dispatchStatus: z6.enum(["dispatching", "launched", "indeterminate"]),
-  replayed: z6.boolean()
+var cliEnrichmentDispatchResponse = z8.object({
+  jobId: z8.uuid(),
+  dispatchStatus: z8.enum(["dispatching", "launched", "indeterminate"]),
+  replayed: z8.boolean()
 }).strict();
-var enrichmentFieldSchema = z6.enum(["headline", "organization", "role", "location", "website", "publicEmail"]);
-var usageBillingSurfaceSchema = z6.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u);
+var enrichmentFieldSchema = z8.enum(["headline", "organization", "role", "location", "website", "publicEmail"]);
+var usageBillingSurfaceSchema = z8.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u);
 var usageModelSchema = boundedModelCoordinateSchema.nullable();
-var usageBillingUnitSchema = z6.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u).nullable();
-var usageBillingCertaintySchema = z6.enum(["unknown", "reported", "contractual", "conservative"]);
-var usageOutcomeSchema = z6.string().regex(/^[a-z][a-z0-9_]{0,63}$/u);
-var usageErrorCodeSchema = z6.string().regex(/^[A-Z0-9][A-Z0-9_:.-]{2,159}$/u).nullable();
-var usageCostCertaintySchema = z6.enum(["reported", "contractual", "estimated", "unknown", "reconciled"]);
-var usageExecutionRouteSchema = z6.string().regex(/^[a-z][a-z0-9_]{0,63}$/u);
-var usageExecutionProfileSha256Schema = z6.string().regex(/^[0-9a-f]{64}$/u).nullable();
-var boundedUsageCount = z6.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
-var cliEnrichmentUsageCoverageResponse = z6.object({
-  ledgerRuns: z6.number().int().min(0).max(100),
-  legacyRuns: z6.number().int().min(0).max(100)
+var usageBillingUnitSchema = z8.string().regex(/^[a-z][a-z0-9_-]{0,63}$/u).nullable();
+var usageBillingCertaintySchema = z8.enum(["unknown", "reported", "contractual", "conservative"]);
+var usageOutcomeSchema = z8.string().regex(/^[a-z][a-z0-9_]{0,63}$/u);
+var usageErrorCodeSchema = z8.string().regex(/^[A-Z0-9][A-Z0-9_:.-]{2,159}$/u).nullable();
+var usageCostCertaintySchema = z8.enum(["reported", "contractual", "estimated", "unknown", "reconciled"]);
+var usageExecutionRouteSchema = z8.string().regex(/^[a-z][a-z0-9_]{0,63}$/u);
+var usageExecutionProfileSha256Schema = z8.string().regex(/^[0-9a-f]{64}$/u).nullable();
+var boundedUsageCount = z8.number().int().min(0).max(Number.MAX_SAFE_INTEGER);
+var cliEnrichmentUsageCoverageResponse = z8.object({
+  ledgerRuns: z8.number().int().min(0).max(100),
+  legacyRuns: z8.number().int().min(0).max(100)
 }).strict();
-var cliEnrichmentProviderUsageResponse = z6.object({
+var cliEnrichmentProviderUsageResponse = z8.object({
   operation: usageOperationSchema,
   executionRoute: usageExecutionRouteSchema,
   executionProfileSha256: usageExecutionProfileSha256Schema,
@@ -6282,57 +7629,57 @@ var cliEnrichmentProviderUsageResponse = z6.object({
   inputTokens: boundedUsageCount,
   outputTokens: boundedUsageCount,
   billingUnit: usageBillingUnitSchema,
-  billedUnits: z6.number().min(0).max(Number.MAX_SAFE_INTEGER),
+  billedUnits: z8.number().min(0).max(Number.MAX_SAFE_INTEGER),
   billingCertainty: usageBillingCertaintySchema,
-  billingUnknown: z6.boolean(),
-  knownCostUsd: z6.number().min(0).max(Number.MAX_SAFE_INTEGER),
+  billingUnknown: z8.boolean(),
+  knownCostUsd: z8.number().min(0).max(Number.MAX_SAFE_INTEGER),
   costCertainty: usageCostCertaintySchema,
   unknownCostAttempts: boundedUsageCount
 }).strict();
-var cliEnrichmentAggregateFieldSourceResponse = z6.object({
+var cliEnrichmentAggregateFieldSourceResponse = z8.object({
   field: enrichmentFieldSchema,
   operation: usageOperationSchema,
   provider: usageProviderSchema,
-  contacts: z6.number().int().min(0).max(100)
+  contacts: z8.number().int().min(0).max(100)
 }).strict();
-var cliEnrichmentFailureResponse = z6.object({
+var cliEnrichmentFailureResponse = z8.object({
   operation: usageOperationSchema,
-  count: z6.number().int().min(1).max(100)
+  count: z8.number().int().min(1).max(100)
 }).strict();
-var cliEnrichmentJobStatusV4Response = z6.object({
-  id: z6.uuid(),
-  status: z6.enum(["queued", "running", "complete", "partial", "failed"]),
-  dispatchStatus: z6.enum(["dispatching", "launched", "indeterminate"]),
-  selectedCount: z6.number().int().min(1).max(100),
-  completedCount: z6.number().int().min(0).max(100),
-  failedCount: z6.number().int().min(0).max(100),
-  productCreditsSpent: z6.number().int().min(0).max(100),
+var cliEnrichmentJobStatusV4Response = z8.object({
+  id: z8.uuid(),
+  status: z8.enum(["queued", "running", "complete", "partial", "failed"]),
+  dispatchStatus: z8.enum(["dispatching", "launched", "indeterminate"]),
+  selectedCount: z8.number().int().min(1).max(100),
+  completedCount: z8.number().int().min(0).max(100),
+  failedCount: z8.number().int().min(0).max(100),
+  productCreditsSpent: z8.number().int().min(0).max(100),
   usageCoverage: cliEnrichmentUsageCoverageResponse,
-  providerUsage: z6.array(cliEnrichmentProviderUsageResponse).max(256),
-  fieldSources: z6.array(cliEnrichmentAggregateFieldSourceResponse).max(600),
-  failures: z6.array(cliEnrichmentFailureResponse).max(9),
-  createdAt: z6.iso.datetime({ offset: true }),
-  completedAt: z6.iso.datetime({ offset: true }).nullable()
+  providerUsage: z8.array(cliEnrichmentProviderUsageResponse).max(256),
+  fieldSources: z8.array(cliEnrichmentAggregateFieldSourceResponse).max(600),
+  failures: z8.array(cliEnrichmentFailureResponse).max(9),
+  createdAt: z8.iso.datetime({ offset: true }),
+  completedAt: z8.iso.datetime({ offset: true }).nullable()
 }).strict();
-var cliEnrichmentRunDetailResponse = z6.object({
-  localPersonId: z6.string().regex(/^[1-9][0-9]{0,18}$/u),
-  status: z6.enum(["pending", "running", "complete", "failed"]),
-  errorCode: z6.string().min(1).max(200).nullable(),
+var cliEnrichmentRunDetailResponse = z8.object({
+  localPersonId: z8.string().regex(/^[1-9][0-9]{0,18}$/u),
+  status: z8.enum(["pending", "running", "complete", "failed"]),
+  errorCode: z8.string().min(1).max(200).nullable(),
   failureOperation: usageOperationSchema.nullable(),
-  identityMatch: z6.enum(["confirmed", "possible", "insufficient"]).nullable(),
-  confidence: z6.number().int().min(0).max(100).nullable(),
-  fieldsPresent: z6.array(enrichmentFieldSchema).max(6),
-  claimFields: z6.array(enrichmentFieldSchema).max(6)
+  identityMatch: z8.enum(["confirmed", "possible", "insufficient"]).nullable(),
+  confidence: z8.number().int().min(0).max(100).nullable(),
+  fieldsPresent: z8.array(enrichmentFieldSchema).max(6),
+  claimFields: z8.array(enrichmentFieldSchema).max(6)
 }).strict();
-var cliEnrichmentRunUsageResponse = z6.object({
+var cliEnrichmentRunUsageResponse = z8.object({
   operation: usageOperationSchema,
   executionRoute: usageExecutionRouteSchema,
   executionProfileSha256: usageExecutionProfileSha256Schema,
-  attempt: z6.number().int().min(1).max(16),
+  attempt: z8.number().int().min(1).max(16),
   billingSurface: usageBillingSurfaceSchema,
   provider: usageProviderSchema,
   model: usageModelSchema,
-  status: z6.enum(["open", "succeeded", "failed", "indeterminate"]),
+  status: z8.enum(["open", "succeeded", "failed", "indeterminate"]),
   outcome: usageOutcomeSchema,
   errorCode: usageErrorCodeSchema,
   results: boundedUsageCount,
@@ -6340,10 +7687,10 @@ var cliEnrichmentRunUsageResponse = z6.object({
   inputTokens: boundedUsageCount,
   outputTokens: boundedUsageCount,
   billingUnit: usageBillingUnitSchema,
-  billedUnits: z6.number().min(0).max(Number.MAX_SAFE_INTEGER),
+  billedUnits: z8.number().min(0).max(Number.MAX_SAFE_INTEGER),
   billingCertainty: usageBillingCertaintySchema,
-  billingUnknown: z6.boolean(),
-  costUsd: z6.number().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
+  billingUnknown: z8.boolean(),
+  costUsd: z8.number().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
   costCertainty: usageCostCertaintySchema
 }).strict().superRefine((value, context) => {
   if ((value.status === "open" || value.status === "succeeded") && value.errorCode !== null) {
@@ -6354,22 +7701,31 @@ var cliEnrichmentRunUsageResponse = z6.object({
     });
   }
 });
-var cliEnrichmentRunFieldSourceResponse = z6.object({
+var cliEnrichmentRunFieldSourceResponse = z8.object({
   field: enrichmentFieldSchema,
-  sources: z6.array(z6.object({
+  sources: z8.array(z8.object({
     operation: usageOperationSchema,
     provider: usageProviderSchema,
-    evidenceRows: z6.number().int().min(1).max(5)
+    evidenceRows: z8.number().int().min(1).max(5)
   }).strict()).max(5)
 }).strict();
-var cliEnrichmentJobDetailsV4Response = z6.object({
-  jobId: z6.uuid(),
-  runs: z6.array(cliEnrichmentRunDetailResponse.extend({
-    usageCoverage: z6.enum(["ledger", "legacy"]),
-    usage: z6.array(cliEnrichmentRunUsageResponse).max(512),
-    fieldSources: z6.array(cliEnrichmentRunFieldSourceResponse).max(6)
+var cliEnrichmentJobDetailsV4Response = z8.object({
+  jobId: z8.uuid(),
+  runs: z8.array(cliEnrichmentRunDetailResponse.extend({
+    usageCoverage: z8.enum(["ledger", "legacy"]),
+    usage: z8.array(cliEnrichmentRunUsageResponse).max(512),
+    fieldSources: z8.array(cliEnrichmentRunFieldSourceResponse).max(6)
   }).strict()).max(100)
 }).strict();
+var cliEnrichmentPublicEmailLeftoverResponse = z8.object({
+  localPersonId: z8.string().regex(/^[1-9][0-9]{0,18}$/u),
+  runId: z8.uuid(),
+  publicEmail: z8.email().max(1024),
+  completedAt: z8.iso.datetime({ offset: true })
+}).strict();
+var cliEnrichmentPublicEmailsResponse = z8.object({
+  publicEmails: z8.array(cliEnrichmentPublicEmailLeftoverResponse).max(1e4)
+}).strict();
 function baseUrl(value) {
   const parsed = new URL(value);
   if (parsed.protocol !== "https:" && !(parsed.protocol === "http:" && ["localhost", "127.0.0.1"].includes(parsed.hostname))) {
@@ -6393,7 +7749,7 @@ async function openBrowser(url) {
 async function signInCloud(origin = "https://peopleblade.com", options = {}) {
   const fetcher = options.fetcher ?? fetch;
   const root = baseUrl(origin);
-  const rawToken = randomBytes(32).toString("base64url");
+  const rawToken = randomBytes2(32).toString("base64url");
   const tokenSha256 = createHash2("sha256").update(rawToken).digest("hex");
   const started = deviceStartResponse.parse(await postJson(fetcher, `${root}/api/cli/device/start`, { deviceName: defaultDeviceName(), tokenSha256 }));
   options.onCode?.(started.userCode, started.verificationUri);
@@ -6464,7 +7820,7 @@ function selectedLocalContacts(database, personIds, config) {
     WHERE member.canonical_person_id IN (${placeholders}) AND person.do_not_contact = 1`).get(...unique);
   if (doNotContact.count > 0)
     throw new Error("Selection contains a do-not-contact identity.");
-  const contacts = projectCloudContacts(database);
+  const contacts = projectCloudContacts(database, { personIds: unique });
   const byId = new Map(contacts.map((contact) => [Number(contact.localPersonId), contact]));
   const selected = unique.map((personId) => byId.get(personId));
   if (selected.some((contact) => contact === undefined)) {
@@ -6553,6 +7909,11 @@ async function cloudEnrichmentDetails(jobId, options = {}) {
   const raw = await postJson(options.fetcher ?? fetch, `${config.baseUrl}/api/cli/enrich/details?v=${cliEnrichmentReadContractVersion}`, input, config.token);
   return cliEnrichmentJobDetailsV4Response.parse(raw);
 }
+async function cloudEnrichmentPublicEmails(options = {}) {
+  const config = cloudConfiguration(options.configuration);
+  const raw = await postJson(options.fetcher ?? fetch, `${config.baseUrl}/api/cli/enrich/public-emails?v=${cliEnrichmentReadContractVersion}`, {}, config.token);
+  return cliEnrichmentPublicEmailsResponse.parse(raw);
+}
 var cloudEnrichmentRevalidationBatchLimit = 10;
 var maximumCloudEnrichmentRevalidationBatches = 1000;
 function addBoundedRevalidationCount(left, right) {
@@ -6601,6 +7962,20 @@ async function revalidateHistoricalCloudEnrichment(options = {}) {
   }
   throw new Error("PeopleBlade historical enrichment revalidation exceeded its batch limit.");
 }
+
+class CloudEnrichmentReadError extends Error {
+  jobId;
+  dispatchStatus;
+  nextCommand;
+  constructor(jobId, dispatchStatus, cause) {
+    const nextCommand = `peopleblade cloud enrich --status ${jobId} --json`;
+    super(`Enrichment dispatch was accepted as ${jobId}, but status could not be read. Do not repeat dispatch; run ${nextCommand}.`, { cause });
+    this.jobId = jobId;
+    this.dispatchStatus = dispatchStatus;
+    this.name = "CloudEnrichmentReadError";
+    this.nextCommand = nextCommand;
+  }
+}
 async function startCloudEnrichment(database, confirmation, personIds, options = {}) {
   const match = /^([0-9a-f-]{36})\.([A-Za-z0-9_-]{43})$/u.exec(confirmation);
   if (match === null)
@@ -6617,7 +7992,14 @@ async function startCloudEnrichment(database, confirmation, personIds, options =
       enrichmentInputSha256: contact.enrichmentInputSha256
     }))
   }, config.token));
-  let status = await cloudEnrichmentStatus(dispatch.jobId, { fetcher, configuration: config });
+  const readStatus = async () => {
+    try {
+      return await cloudEnrichmentStatus(dispatch.jobId, { fetcher, configuration: config });
+    } catch (cause) {
+      throw new CloudEnrichmentReadError(dispatch.jobId, dispatch.dispatchStatus, cause);
+    }
+  };
+  let status = await readStatus();
   if (options.wait === false || dispatch.dispatchStatus !== "launched")
     return { dispatch, status };
   const pollIntervalMs = Math.max(250, Math.min(30000, options.pollIntervalMs ?? 2000));
@@ -6626,16 +8008,16 @@ async function startCloudEnrichment(database, confirmation, personIds, options =
     if (["complete", "partial", "failed"].includes(status.status))
       return { dispatch, status };
     await new Promise((resolve) => setTimeout(resolve, pollIntervalMs));
-    status = await cloudEnrichmentStatus(dispatch.jobId, { fetcher, configuration: config });
+    status = await readStatus();
   }
   throw new Error(`Enrichment job ${dispatch.jobId} is still running; inspect it with cloud enrich --status.`);
 }
 
 // src/local/database.ts
 import { Database } from "bun:sqlite";
-import crypto from "crypto";
+import crypto2 from "crypto";
 import {
-  chmodSync,
+  chmodSync as chmodSync2,
   closeSync as closeSync4,
   constants as constants4,
   existsSync as existsSync2,
@@ -6643,17 +8025,17 @@ import {
   fstatSync as fstatSync3,
   fsyncSync,
   linkSync,
-  lstatSync,
+  lstatSync as lstatSync2,
   mkdirSync as mkdirSync2,
   openSync as openSync4,
   readFileSync as readFileSync4,
   realpathSync,
   readdirSync,
   statSync,
-  unlinkSync,
-  writeFileSync as writeFileSync2
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync3
 } from "fs";
-import { basename, dirname as dirname2, join as join2, resolve } from "path";
+import { basename, dirname as dirname2, join as join3, resolve } from "path";
 import { fileURLToPath } from "url";
 
 // src/local/phone-identity-migration.ts
@@ -7150,7 +8532,7 @@ function convergeLegacyProviderAccounts(database) {
 }
 
 // src/local/database.ts
-var migrationsDirectory = join2(dirname2(fileURLToPath(import.meta.url)), "migrations");
+var migrationsDirectory = join3(dirname2(fileURLToPath(import.meta.url)), "migrations");
 function migrationNames() {
   return readdirSync(migrationsDirectory).filter((name) => name.endsWith(".sql")).sort();
 }
@@ -7160,18 +8542,18 @@ function secureDirectory(path) {
   const standardRoot = resolve(peoplebladeDirectory());
   const physical = resolve(path);
   if (!existed || physical === standardRoot || physical.startsWith(`${standardRoot}/`))
-    chmodSync(path, 448);
+    chmodSync2(path, 448);
 }
 function assertSecureBackupDirectory(path) {
   const existed = existsSync2(path);
   if (existed)
-    assertSecureBackupDirectoryIdentity(lstatSync(path), true);
+    assertSecureBackupDirectoryIdentity(lstatSync2(path), true);
   secureDirectory(path);
   const physical = realpathSync(path);
-  assertSecureBackupDirectoryIdentity(lstatSync(physical), true);
+  assertSecureBackupDirectoryIdentity(lstatSync2(physical), true);
   let ancestor = dirname2(physical);
   while (true) {
-    const identity = lstatSync(ancestor);
+    const identity = lstatSync2(ancestor);
     assertSecureBackupDirectoryIdentity(identity, false);
     const parent = dirname2(ancestor);
     if (parent === ancestor)
@@ -7209,12 +8591,12 @@ function assertSecureFileIdentity(identity) {
   }
 }
 function secureFile(path) {
-  const identity = lstatSync(path);
+  const identity = lstatSync2(path);
   assertSecureFileIdentity(identity);
-  chmodSync(path, 384);
+  chmodSync2(path, 384);
 }
 function assertSameTemporaryFile(path, expected) {
-  const current = lstatSync(path);
+  const current = lstatSync2(path);
   assertSecureFileIdentity(current);
   if (current.dev !== expected.dev || current.ino !== expected.ino) {
     throw new Error("PeopleBlade backup temporary file was replaced.");
@@ -7225,7 +8607,7 @@ function temporarySnapshotSidecars(path) {
 }
 function pathEntryExists(path) {
   try {
-    lstatSync(path);
+    lstatSync2(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT")
@@ -7235,7 +8617,7 @@ function pathEntryExists(path) {
 }
 function unlinkIfPresent(path) {
   try {
-    unlinkSync(path);
+    unlinkSync2(path);
   } catch (error) {
     if (error.code !== "ENOENT")
       throw error;
@@ -7244,7 +8626,7 @@ function unlinkIfPresent(path) {
 function unlinkTemporarySidecarIfPresent(path) {
   let identity;
   try {
-    identity = lstatSync(path);
+    identity = lstatSync2(path);
   } catch (error) {
     if (error.code === "ENOENT")
       return;
@@ -7255,7 +8637,7 @@ function unlinkTemporarySidecarIfPresent(path) {
   } catch {
     throw new Error("PeopleBlade backup temporary SQLite sidecar was not a safe owned file.");
   }
-  unlinkSync(path);
+  unlinkSync2(path);
 }
 function assertNoTemporarySidecars(path) {
   for (const sidecar of temporarySnapshotSidecars(path)) {
@@ -7321,7 +8703,7 @@ function migrateLocalDatabase(database) {
       continue;
     database.exec("BEGIN IMMEDIATE");
     try {
-      database.exec(readFileSync4(join2(migrationsDirectory, filename), "utf8"));
+      database.exec(readFileSync4(join3(migrationsDirectory, filename), "utf8"));
       database.query("INSERT INTO schema_migrations(version) VALUES (?)").run(filename);
       database.exec("COMMIT");
     } catch (error) {
@@ -7378,7 +8760,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 = join2(destinationDirectory, basename(requestedDestination));
+  const destination = join3(destinationDirectory, basename(requestedDestination));
   if (existsSync2(destination))
     throw new Error(`Backup already exists: ${destination}`);
   if (source === destination)
@@ -7397,14 +8779,14 @@ function backupLocalDatabase(sourcePath, destinationPath) {
   } finally {
     database.close();
   }
-  const temporary = join2(destinationDirectory, `.peopleblade-backup-${process.pid}-${crypto.randomBytes(8).toString("hex")}`);
+  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);
   try {
     try {
       fchmodSync(descriptor, 384);
       const identity = fstatSync3(descriptor);
       assertNoTemporarySidecars(temporary);
-      writeFileSync2(descriptor, bytes);
+      writeFileSync3(descriptor, bytes);
       fsyncSync(descriptor);
       normalizeAndValidateSnapshot(temporary, identity);
       fsyncSync(descriptor);
@@ -7412,7 +8794,7 @@ function backupLocalDatabase(sourcePath, destinationPath) {
       closeSync4(descriptor);
     }
     linkSync(temporary, destination);
-    unlinkSync(temporary);
+    unlinkSync2(temporary);
   } catch (error) {
     unlinkIfPresent(temporary);
     for (const sidecar of temporarySnapshotSidecars(temporary))
@@ -7431,11 +8813,11 @@ 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 join2(dirname2(databasePath), "backups", `${label}-${timestamp2}.sqlite3`);
+  return join3(dirname2(databasePath), "backups", `${label}-${timestamp2}.sqlite3`);
 }
 
 // src/local/ensoul.ts
-import { randomBytes as randomBytes2 } from "crypto";
+import { randomBytes as randomBytes3 } from "crypto";
 import {
   closeSync as closeSync5,
   constants as constants5,
@@ -7443,25 +8825,25 @@ import {
   fstatSync as fstatSync4,
   fsyncSync as fsyncSync2,
   linkSync as linkSync2,
-  lstatSync as lstatSync2,
+  lstatSync as lstatSync3,
   openSync as openSync5,
   realpathSync as realpathSync2,
-  unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync3
+  unlinkSync as unlinkSync3,
+  writeFileSync as writeFileSync4
 } from "fs";
-import { basename as basename2, dirname as dirname3, join as join3, resolve as resolve2 } from "path";
+import { basename as basename2, dirname as dirname3, join as join4, resolve as resolve2 } from "path";
 
 // src/lib/ensoul-contracts.ts
-import { z as z7 } from "zod";
+import { z as z9 } from "zod";
 var ensoulSourcePacketVersion = "ensoul.source-packet.v1";
 var peoplebladeEnsoulAdapter = "peopleblade";
 var peoplebladeEnsoulPayloadSchema = "ensoul.public-enrichment-source.v1";
 var ensoulDigestCanonicalization = "JCS-RFC8785";
-var digestSchema = z7.string().regex(/^[a-f0-9]{64}$/u);
-var prefixedDigestSchema = z7.string().regex(/^sha256:[a-f0-9]{64}$/u);
-var timestampSchema = z7.iso.datetime({ offset: true });
-var boundedText2 = (maximum) => z7.string().trim().min(1).max(maximum);
-var positiveSafeInteger = z7.number().int().positive().max(Number.MAX_SAFE_INTEGER);
+var digestSchema = z9.string().regex(/^[a-f0-9]{64}$/u);
+var prefixedDigestSchema = z9.string().regex(/^sha256:[a-f0-9]{64}$/u);
+var timestampSchema = z9.iso.datetime({ offset: true });
+var boundedText2 = (maximum) => z9.string().trim().min(1).max(maximum);
+var positiveSafeInteger = z9.number().int().positive().max(Number.MAX_SAFE_INTEGER);
 function assertWellFormedUnicode(value) {
   for (let index = 0;index < value.length; index += 1) {
     const code = value.charCodeAt(index);
@@ -7503,7 +8885,7 @@ function ensoulJcsCanonicalJson(value) {
   }
   throw new Error("JCS input is not valid JSON.");
 }
-var ensoulSourceClassSchema = z7.enum([
+var ensoulSourceClassSchema = z9.enum([
   "private_capture",
   "polished_self_presentation",
   "observed_behavior",
@@ -7512,24 +8894,24 @@ var ensoulSourceClassSchema = z7.enum([
   "metadata",
   "public_web_evidence"
 ]);
-var ensoulSourceRecordSemanticSchema = z7.object({
+var ensoulSourceRecordSemanticSchema = z9.object({
   id: boundedText2(200),
   kind: boundedText2(100),
   occurredAt: timestampSchema.optional(),
   observedAt: timestampSchema.optional(),
-  authorRole: z7.enum(["subject", "counterpart", "third_party", "mixed", "unknown"]),
-  contentRole: z7.enum(["original", "quoted", "forwarded", "summary", "ai_assisted", "mixed", "unknown"]),
-  authorshipConfidence: z7.enum(["verified", "strong", "weak", "unknown"]),
-  sentStatus: z7.enum(["sent", "draft", "received", "published", "unknown"]),
-  visibility: z7.enum(["public", "private"]),
+  authorRole: z9.enum(["subject", "counterpart", "third_party", "mixed", "unknown"]),
+  contentRole: z9.enum(["original", "quoted", "forwarded", "summary", "ai_assisted", "mixed", "unknown"]),
+  authorshipConfidence: z9.enum(["verified", "strong", "weak", "unknown"]),
+  sentStatus: z9.enum(["sent", "draft", "received", "published", "unknown"]),
+  visibility: z9.enum(["public", "private"]),
   sourceClass: ensoulSourceClassSchema,
-  content: z7.object({
-    text: z7.string().max(50000).optional(),
-    title: z7.string().max(1000).optional(),
+  content: z9.object({
+    text: z9.string().max(50000).optional(),
+    title: z9.string().max(1000).optional(),
     url: httpUrlSchema.optional(),
-    truncated: z7.boolean().optional()
+    truncated: z9.boolean().optional()
   }).strict().refine((content) => content.text !== undefined || content.title !== undefined || content.url !== undefined, "Record content requires text, title, or URL"),
-  provenance: z7.object({
+  provenance: z9.object({
     provider: boundedText2(100),
     operation: boundedText2(160).optional(),
     sourceId: boundedText2(300).optional(),
@@ -7542,17 +8924,17 @@ var ensoulSourceRecordSemanticSchema = z7.object({
 var ensoulSourceRecordSchema = ensoulSourceRecordSemanticSchema.extend({
   digest: prefixedDigestSchema
 }).strict();
-var ensoulClaimSchema = z7.object({
+var ensoulClaimSchema = z9.object({
   id: boundedText2(200),
   text: boundedText2(4000),
-  recordIds: z7.array(boundedText2(200)).min(1).max(50).refine((values) => new Set(values).size === values.length, "Claim record IDs must be unique"),
-  status: z7.enum(["source_reported", "adapter_structured", "contested"]),
-  claimantRole: z7.enum(["subject", "counterpart", "third_party", "institutional", "adapter", "unknown"]),
-  claimKind: z7.enum(["fact", "stated_belief", "reported_observation", "derived_index"]),
+  recordIds: z9.array(boundedText2(200)).min(1).max(50).refine((values) => new Set(values).size === values.length, "Claim record IDs must be unique"),
+  status: z9.enum(["source_reported", "adapter_structured", "contested"]),
+  claimantRole: z9.enum(["subject", "counterpart", "third_party", "institutional", "adapter", "unknown"]),
+  claimKind: z9.enum(["fact", "stated_belief", "reported_observation", "derived_index"]),
   subjectLocalId: boundedText2(200),
-  sensitivity: z7.enum(["ordinary", "sensitive_explicit"])
+  sensitivity: z9.enum(["ordinary", "sensitive_explicit"])
 }).strict();
-var ensoulLimitationSchema = z7.enum([
+var ensoulLimitationSchema = z9.enum([
   "Public-web evidence plus bounded local subject background only; this packet is not a complete account of the person.",
   "Web authorship is unknown; no record is a direct subject voice sample.",
   "Private messages and CRM notes are excluded.",
@@ -7560,41 +8942,41 @@ var ensoulLimitationSchema = z7.enum([
   "Raw provider payloads, credentials, and unrelated contacts are excluded.",
   "Do not infer sensitive traits, diagnoses, consent, or permission to act from this packet."
 ]);
-var peoplebladeEnsoulPacketBodySchema = z7.object({
-  schemaVersion: z7.literal(ensoulSourcePacketVersion),
-  digestCanonicalization: z7.literal(ensoulDigestCanonicalization),
+var peoplebladeEnsoulPacketBodySchema = z9.object({
+  schemaVersion: z9.literal(ensoulSourcePacketVersion),
+  digestCanonicalization: z9.literal(ensoulDigestCanonicalization),
   generatedAt: timestampSchema,
-  subject: z7.object({
+  subject: z9.object({
     localId: boundedText2(200),
-    kind: z7.literal("person"),
+    kind: z9.literal("person"),
     displayName: boundedText2(300).optional(),
     identityBasis: boundedText2(1000)
   }).strict(),
-  scope: z7.object({
-    adapter: z7.literal(peoplebladeEnsoulAdapter),
-    payloadSchema: z7.literal(peoplebladeEnsoulPayloadSchema),
+  scope: z9.object({
+    adapter: z9.literal(peoplebladeEnsoulAdapter),
+    payloadSchema: z9.literal(peoplebladeEnsoulPayloadSchema),
     asOf: timestampSchema,
     sourceCutoff: timestampSchema.optional(),
-    completeness: z7.enum(["complete", "sampled", "bounded", "unknown"]),
+    completeness: z9.enum(["complete", "sampled", "bounded", "unknown"]),
     sourceRevision: boundedText2(300),
-    limits: z7.object({
+    limits: z9.object({
       maxCurrentEnrichments: positiveSafeInteger,
       maxRecords: positiveSafeInteger,
       maxClaims: positiveSafeInteger,
       maxPacketBytes: positiveSafeInteger,
       oldestObservedAt: timestampSchema.nullable(),
-      exactContactCoordinates: z7.literal("excluded-or-redacted"),
-      notes: z7.literal("excluded"),
-      messages: z7.literal("excluded"),
-      rawProviderPayloads: z7.literal("excluded")
+      exactContactCoordinates: z9.literal("excluded-or-redacted"),
+      notes: z9.literal("excluded"),
+      messages: z9.literal("excluded"),
+      rawProviderPayloads: z9.literal("excluded")
     }).strict()
   }).strict(),
-  records: z7.array(ensoulSourceRecordSchema).max(2000),
-  claims: z7.array(ensoulClaimSchema).max(500),
-  limitations: z7.array(ensoulLimitationSchema).min(1).max(32)
+  records: z9.array(ensoulSourceRecordSchema).max(2000),
+  claims: z9.array(ensoulClaimSchema).max(500),
+  limitations: z9.array(ensoulLimitationSchema).min(1).max(32)
 }).strict();
 var peoplebladeEnsoulPacketSemanticSchema = peoplebladeEnsoulPacketBodySchema.extend({
-  packetId: z7.string().trim().min(8).max(160)
+  packetId: z9.string().trim().min(8).max(160)
 }).strict();
 var ensoulSourcePacketSchema = peoplebladeEnsoulPacketSemanticSchema.extend({
   packetDigest: prefixedDigestSchema
@@ -8042,7 +9424,7 @@ function buildPeoplebladeEnsoulSourcePacket(database, requestedPersonId, options
 }
 function pathEntryExists2(path) {
   try {
-    lstatSync2(path);
+    lstatSync3(path);
     return true;
   } catch (error) {
     if (error.code === "ENOENT")
@@ -8051,7 +9433,7 @@ function pathEntryExists2(path) {
   }
 }
 function assertPrivateOutputDirectory(path) {
-  const identity = lstatSync2(path);
+  const identity = lstatSync3(path);
   const uid = typeof process.getuid === "function" ? process.getuid() : null;
   if (!identity.isDirectory() || identity.isSymbolicLink() || uid === null || identity.uid !== uid || (identity.mode & 18) !== 0)
     throw new Error("Ensoul output directory must be a private, owned directory and not a symlink.");
@@ -8061,9 +9443,9 @@ function unlinkExpectedInode(path, expected) {
   if (expected === null)
     return;
   try {
-    const current = lstatSync2(path);
+    const current = lstatSync3(path);
     if (current.dev === expected.dev && current.ino === expected.ino)
-      unlinkSync2(path);
+      unlinkSync3(path);
   } catch (error) {
     if (error.code !== "ENOENT")
       throw error;
@@ -8077,10 +9459,10 @@ function writePrivatePacket(path, contents) {
   if (filename === "." || filename === "..")
     throw new Error("Ensoul output requires a file path.");
   const directory = assertPrivateOutputDirectory(dirname3(requested));
-  const destination = join3(directory, filename);
+  const destination = join4(directory, filename);
   if (pathEntryExists2(destination))
     throw new Error("Ensoul output already exists; refusing to overwrite it.");
-  const temporary = join3(directory, `.peopleblade-ensoul-${process.pid}-${randomBytes2(12).toString("hex")}`);
+  const temporary = join4(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);
   try {
@@ -8090,7 +9472,7 @@ function writePrivatePacket(path, contents) {
     if (!identity.isFile() || identity.nlink !== 1 || uid === null || identity.uid !== uid) {
       throw new Error("Ensoul output staging file is not a private, owned regular file.");
     }
-    writeFileSync3(descriptor, contents, "utf8");
+    writeFileSync4(descriptor, contents, "utf8");
     fsyncSync2(descriptor);
   } catch (error) {
     unlinkExpectedInode(temporary, identity);
@@ -8103,8 +9485,8 @@ function writePrivatePacket(path, contents) {
   try {
     linkSync2(temporary, destination);
     destinationLinked = true;
-    unlinkSync2(temporary);
-    const published = lstatSync2(destination);
+    unlinkSync3(temporary);
+    const published = lstatSync3(destination);
     const uid = typeof process.getuid === "function" ? process.getuid() : null;
     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.");
@@ -8145,7 +9527,7 @@ function preparePeoplebladeEnsoulSource(database, requestedPersonId, outputPath,
 
 // src/local/legacy-rolodex.ts
 import { Database as Database2 } from "bun:sqlite";
-import { lstatSync as lstatSync3, realpathSync as realpathSync3 } from "fs";
+import { lstatSync as lstatSync4, realpathSync as realpathSync3 } from "fs";
 function tableExists2(database, name) {
   return database.query("SELECT 1 FROM sqlite_master WHERE type IN ('table','view') AND name=?").get(name) !== null;
 }
@@ -8167,7 +9549,7 @@ function binding(value) {
     return value;
   throw new Error("Legacy database value is not a supported SQLite binding.");
 }
-function json(value) {
+function json2(value) {
   return canonicalJson(value);
 }
 function providerForKind(kind) {
@@ -8193,7 +9575,7 @@ function maxDate(left, right) {
 }
 function migrateLegacyRolodex(sourcePath, destinationPath) {
   const sourcePhysical = realpathSync3(sourcePath);
-  const identity = lstatSync3(sourcePhysical);
+  const identity = lstatSync4(sourcePhysical);
   if (!identity.isFile() || identity.isSymbolicLink() || identity.nlink !== 1) {
     throw new Error("Legacy Rolodex must be one regular database file.");
   }
@@ -8243,7 +9625,7 @@ function migrateLegacyRolodex(sourcePath, destinationPath) {
         notes, metadata_json, created_at, updated_at
       ) VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`);
       for (const [canonicalId, memberIds] of [...members].sort(([a], [b]) => a - b)) {
-        const candidates = memberIds.map((id) => legacyPeople.get(id)).filter((item) => item !== undefined);
+        const candidates = memberIds.map((id2) => legacyPeople.get(id2)).filter((item) => item !== undefined);
         const root = candidates.find((person) => person.id === canonicalId) ?? candidates[0];
         if (root === undefined)
           throw new Error("Legacy identity component has no person.");
@@ -8253,7 +9635,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"), json({ 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"), json2({ 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) => {
@@ -8278,7 +9660,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), json({ 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), 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);
         sourceMap.set(legacyId, number(result2.lastInsertRowid, "source run id"));
         sourceRuns += 1;
       }
@@ -8289,7 +9671,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, json({ 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, json2({ legacy_email_id: row.id, source_row: row.source_row }), row.created_at].map(binding));
         if (result2.changes > 0)
           contactMethods += 1;
       }
@@ -8297,7 +9679,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, json({ 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, json2({ legacy_phone_id: row.id, source_row: row.source_row }), row.created_at].map(binding));
           if (result2.changes > 0)
             contactMethods += 1;
         }
@@ -8307,12 +9689,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")), json({ 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")), json({ 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")), json({ 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")), json({ 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, json({ 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")), json({ 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")), 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] }
       ];
       for (const spec of resourceSpecs)
         if (tableExists2(source, spec.table))
@@ -8357,7 +9739,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, json(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, json2(metric.metadata));
         interactionMetrics += 1;
       }
       if (tableExists2(source, "tags") && tableExists2(source, "person_tags")) {
@@ -8373,16 +9755,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"), json({ 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"), json2({ 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"), json(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"), json2(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), json(result));
+      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.exec("COMMIT");
       return { ...result, cached: false };
     } catch (error) {
@@ -8423,8 +9805,9 @@ function selfStatus(metadataJson) {
     throw new Error("Provider resource identity metadata is malformed.");
   }
 }
-function profiles(database) {
-  const rows = database.query(`SELECT p.id, component.canonical_person_id, p.display_name, p.organization,
+function profiles(database, index, personIds) {
+  const scoped = personIds !== undefined;
+  const rows = database.query(`SELECT p.id, p.display_name, p.organization,
     coalesce((SELECT json_group_array(normalized_value) FROM (
       SELECT DISTINCT method.normalized_value
       FROM contact_methods method
@@ -8458,19 +9841,37 @@ function profiles(database) {
         AND (realm.id IS NULL OR realm.active=1)
       ORDER BY value
     )),'[]') AS resources
-    FROM people p JOIN person_identity_components component ON component.person_id=p.id ORDER BY p.id`).all();
-  return new Map(rows.map((row) => {
-    const profile = {
-      id: Number(row.id),
-      canonicalId: Number(row.canonical_person_id),
+    FROM people p
+    ${scoped ? "WHERE p.id IN (SELECT value FROM json_each(?))" : ""} ORDER BY p.id`).all(...scoped ? [JSON.stringify(personIds)] : []);
+  const result = new Map;
+  for (const row of rows) {
+    const id2 = Number(row.id);
+    const canonicalId = index.canonicalOf.get(id2);
+    if (canonicalId === undefined)
+      continue;
+    result.set(id2, {
+      id: id2,
+      canonicalId,
       displayName: nullableString(row.display_name),
       organization: nullableString(row.organization),
       emails: stringArray(String(row.emails)),
       phones: stringArray(String(row.phones)),
       resources: stringArray(String(row.resources))
-    };
-    return [profile.id, profile];
-  }));
+    });
+  }
+  return result;
+}
+function personNamesLookup(database) {
+  const statement = database.query("SELECT display_name,organization FROM people WHERE id=?");
+  const cache = new Map;
+  return (personId) => {
+    if (cache.has(personId))
+      return cache.get(personId);
+    const row = statement.get(personId);
+    const names = row === null ? undefined : { displayName: nullableString(row.display_name), organization: nullableString(row.organization) };
+    cache.set(personId, names);
+    return names;
+  };
 }
 function legacyEvidence(left, right, kind, signals, warnings) {
   return {
@@ -8533,7 +9934,7 @@ function reviewedEvidenceDigest(decision) {
   }
 }
 function suggestLegacyIdentities(database, kind, limit) {
-  const values = [...profiles(database).values()];
+  const values = [...profiles(database, componentIndex(database)).values()];
   const suggestions = [];
   const candidates = new Map;
   const priority = { "exact-email": 3, "exact-phone": 2, "name-organization": 1 };
@@ -8703,10 +10104,29 @@ function eligibleOwners(database) {
   }
   return buckets;
 }
-function componentSnapshot(database, canonicalId) {
+function componentIndex(database) {
+  const rows = database.query(`SELECT person_id,canonical_person_id FROM person_identity_components
+    ORDER BY canonical_person_id,person_id`).all();
+  const canonicalOf = new Map;
+  const membersOf = new Map;
+  for (const row of rows) {
+    const personId = Number(row.person_id);
+    const canonicalId = Number(row.canonical_person_id);
+    canonicalOf.set(personId, canonicalId);
+    const members = membersOf.get(canonicalId) ?? [];
+    members.push(personId);
+    membersOf.set(canonicalId, members);
+  }
+  return { canonicalOf, membersOf };
+}
+function memberList(index, canonicalId) {
+  return JSON.stringify(index.membersOf.get(canonicalId) ?? []);
+}
+function componentSnapshot(database, canonicalId, index) {
+  const memberIds = memberList(index, canonicalId);
   const members = database.query(`SELECT person.id,person.display_name,person.organization
-    FROM person_identity_components component JOIN people person ON person.id=component.person_id
-    WHERE component.canonical_person_id=? ORDER BY person.id`).all(canonicalId).map((row) => ({
+    FROM people person
+    WHERE person.id IN (SELECT value FROM json_each(?)) ORDER BY person.id`).all(memberIds).map((row) => ({
     id: Number(row.id),
     displayName: nullableString(row.display_name),
     organization: nullableString(row.organization),
@@ -8719,11 +10139,10 @@ function componentSnapshot(database, canonicalId) {
       realm.identity_namespace AS realm_identity_namespace,
       realm.external_id_sha256 AS realm_external_id_sha256
     FROM provider_resources resource
-    JOIN person_identity_components component ON component.person_id=resource.person_id
     LEFT JOIN source_realms realm ON realm.id=resource.source_realm_id
-    WHERE component.canonical_person_id=? AND resource.active=1
+    WHERE resource.person_id IN (SELECT value FROM json_each(?)) AND resource.active=1
       AND (realm.id IS NULL OR realm.active=1)
-    ORDER BY resource.id`).all(canonicalId).map((row) => ({
+    ORDER BY resource.id`).all(memberIds).map((row) => ({
     id: Number(row.id),
     personId: Number(row.person_id),
     provider: String(row.provider),
@@ -8740,14 +10159,13 @@ function componentSnapshot(database, canonicalId) {
       method.value,method.normalized_value,method.label,method.metadata_json,
       method.provider_resource_id
     FROM contact_methods method
-    JOIN person_identity_components component ON component.person_id=method.person_id
     LEFT JOIN provider_resources resource ON resource.id=method.provider_resource_id
     LEFT JOIN source_realms realm ON realm.id=resource.source_realm_id
-    WHERE component.canonical_person_id=? AND method.active=1
+    WHERE method.person_id IN (SELECT value FROM json_each(?)) AND method.active=1
       AND method.identity_eligible=1 AND method.confidence='exact'
       AND (resource.id IS NULL OR resource.active=1)
       AND (realm.id IS NULL OR realm.active=1)
-    ORDER BY method.kind,method.normalized_value,method.person_id,method.id`).all(canonicalId).map((row) => ({
+    ORDER BY method.kind,method.normalized_value,method.person_id,method.id`).all(memberIds).map((row) => ({
     id: Number(row.id),
     personId: Number(row.person_id),
     kind: String(row.kind),
@@ -8800,13 +10218,12 @@ function componentRealmContradictions(left, right) {
   }
   return [...realms.values()].filter((group) => group.values.size > 1).map((group) => `distinct exact resources in ${group.label}`).sort();
 }
-function componentInteractionLanes(database, canonicalId) {
+function componentInteractionLanes(database, canonicalId, index) {
   const rows = database.query(`SELECT metric.provider,realm.service
     FROM interaction_metrics metric
-    JOIN person_identity_components component ON component.person_id=metric.person_id
     LEFT JOIN source_realms realm ON realm.authority=metric.provider AND realm.account_key=metric.account_key
-    WHERE component.canonical_person_id=? AND (realm.id IS NULL OR realm.active=1)
-    ORDER BY metric.provider,realm.service`).all(canonicalId);
+    WHERE metric.person_id IN (SELECT value FROM json_each(?)) AND (realm.id IS NULL OR realm.active=1)
+    ORDER BY metric.provider,realm.service`).all(memberList(index, canonicalId));
   const result = new Map;
   for (const row of rows) {
     const provider = String(row.provider);
@@ -8887,14 +10304,15 @@ function eligibleOwnerSemantic(owner) {
 function observedCandidates(database, options) {
   const allObservations = observedMethods(database);
   const ownersBySignal = eligibleOwners(database);
-  const profileMap = profiles(database);
+  const index = options.index ?? componentIndex(database);
+  const names = personNamesLookup(database);
   const snapshots = new Map;
   const laneCache = new Map;
   const snapshot = (canonicalId) => {
     const cached = snapshots.get(canonicalId);
     if (cached !== undefined)
       return cached;
-    const created = componentSnapshot(database, canonicalId);
+    const created = componentSnapshot(database, canonicalId, index);
     snapshots.set(canonicalId, created);
     return created;
   };
@@ -8902,7 +10320,7 @@ function observedCandidates(database, options) {
     const cached = laneCache.get(canonicalId);
     if (cached !== undefined)
       return cached;
-    const created = componentInteractionLanes(database, canonicalId);
+    const created = componentInteractionLanes(database, canonicalId, index);
     laneCache.set(canonicalId, created);
     return created;
   };
@@ -8923,7 +10341,7 @@ function observedCandidates(database, options) {
     }
     targetComponentsByPerson.set(observation.personId, targets);
   }
-  const selected = allObservations.filter((observation) => observation.kind === (options.kind === "observed-email" ? "email" : "phone") && (options.source === undefined || observation.provider === options.source) && (options.realmId === undefined || observation.realmId === options.realmId));
+  const selected = allObservations.filter((observation) => observation.kind === (options.kind === "observed-email" ? "email" : "phone") && (options.source === undefined || observation.provider === options.source) && (options.realmId === undefined || observation.realmId === options.realmId) && (options.observationPersonIds === undefined || options.observationPersonIds.includes(observation.personId)));
   const deduplicated = new Map;
   for (const observation of selected) {
     if (selfStatus(observation.resourceMetadataJson) === "true")
@@ -8955,10 +10373,10 @@ function observedCandidates(database, options) {
       continue;
     const leftId = Math.min(observation.personId, anchor.personId);
     const rightId = Math.max(observation.personId, anchor.personId);
-    const leftProfile = profileMap.get(leftId);
-    const rightProfile = profileMap.get(rightId);
-    const observationProfile = profileMap.get(observation.personId);
-    const targetProfile = profileMap.get(anchor.personId);
+    const leftProfile = names(leftId);
+    const rightProfile = names(rightId);
+    const observationProfile = names(observation.personId);
+    const targetProfile = names(anchor.personId);
     if (leftProfile === undefined || rightProfile === undefined || observationProfile === undefined || targetProfile === undefined)
       continue;
     const candidateComponentIds = [...new Set(item.owners.map((owner) => owner.canonicalId))].sort((a, b) => a - b);
@@ -9108,9 +10526,9 @@ function assertReviewTransitionAllowed(current, digest) {
     return;
   throw new Error("This identity evidence has already been reviewed; request a fresh suggestion after evidence changes.");
 }
-function assertMergeAllowed(database, leftCanonicalId, rightCanonicalId, supersededDecisionId = null) {
-  const leftMembers = database.query("SELECT person_id FROM person_identity_components WHERE canonical_person_id=? ORDER BY person_id").all(leftCanonicalId).map((row) => row.person_id);
-  const rightMembers = database.query("SELECT person_id FROM person_identity_components WHERE canonical_person_id=? ORDER BY person_id").all(rightCanonicalId).map((row) => row.person_id);
+function assertMergeAllowed(database, index, leftCanonicalId, rightCanonicalId, supersededDecisionId = null) {
+  const leftMembers = index.membersOf.get(leftCanonicalId) ?? [];
+  const rightMembers = index.membersOf.get(rightCanonicalId) ?? [];
   const leftMarks = leftMembers.map(() => "?").join(",");
   const rightMarks = rightMembers.map(() => "?").join(",");
   const blockers = database.query(`SELECT count(*) AS count FROM identity_current_decisions
@@ -9130,7 +10548,8 @@ function insertDecision(database, left, right, action, digest, evidence, priorDe
 function decideLegacyIdentity(database, parsed, action, note) {
   if (action === "separate")
     throw new Error("Use identity separate with the accepted decision ID.");
-  const map = profiles(database);
+  const index = componentIndex(database);
+  const map = profiles(database, index, [parsed.left, parsed.right]);
   const left = map.get(parsed.left);
   const right = map.get(parsed.right);
   if (left === undefined || right === undefined)
@@ -9149,17 +10568,20 @@ function decideLegacyIdentity(database, parsed, action, note) {
   assertReviewTransitionAllowed(current, parsed.digest);
   if (action === "accept") {
     const superseded = current !== null && ["reject", "separate"].includes(current.action) && reviewedEvidenceDigest(current) !== parsed.digest ? current.id : null;
-    assertMergeAllowed(database, left.canonicalId, right.canonicalId, superseded);
+    assertMergeAllowed(database, index, left.canonicalId, right.canonicalId, superseded);
   }
   return insertDecision(database, parsed.left, parsed.right, action, parsed.digest, evidence, current?.id ?? null, note);
 }
 function decideObservedIdentity(database, parsed, action, note) {
   if (action === "separate")
     throw new Error("Use identity separate with the accepted decision ID.");
+  const index = componentIndex(database);
   const candidates = observedCandidates(database, {
     kind: parsed.kind,
     ambiguity: "all",
-    suppressDecisions: false
+    suppressDecisions: false,
+    observationPersonIds: [parsed.left, parsed.right],
+    index
   });
   const candidate = candidates.find((item) => item.suggestion.token === `id2.${parsed.left}.${parsed.right}.${parsed.kind}.${parsed.observationMethodId}.${item.digest}`);
   if (candidate === undefined || candidate.digest !== parsed.digest) {
@@ -9168,16 +10590,16 @@ function decideObservedIdentity(database, parsed, action, note) {
   if (action === "accept" && candidate.realmContradictions.length > 0) {
     throw new Error("Distinct exact resources in one source realm block this identity merge.");
   }
-  const left = database.query("SELECT canonical_person_id FROM person_identity_components WHERE person_id=?").get(parsed.left);
-  const right = database.query("SELECT canonical_person_id FROM person_identity_components WHERE person_id=?").get(parsed.right);
-  if (left === null || right === null || left.canonical_person_id === right.canonical_person_id) {
+  const left = index.canonicalOf.get(parsed.left);
+  const right = index.canonicalOf.get(parsed.right);
+  if (left === undefined || right === undefined || left === right) {
     throw new Error("Identity evidence changed; request a fresh suggestion.");
   }
   const current = currentDecision(database, parsed.left, parsed.right);
   assertReviewTransitionAllowed(current, parsed.digest);
   if (action === "accept") {
     const superseded = current !== null && ["reject", "separate"].includes(current.action) && reviewedEvidenceDigest(current) !== parsed.digest ? current.id : null;
-    assertMergeAllowed(database, left.canonical_person_id, right.canonical_person_id, superseded);
+    assertMergeAllowed(database, index, left, right, superseded);
   }
   return insertDecision(database, parsed.left, parsed.right, action, parsed.digest, candidate.evidence, current?.id ?? null, note);
 }
@@ -9226,6 +10648,275 @@ function separateIdentityDecision(database, acceptedDecisionId, note) {
     throw error;
   }
 }
+var IDENTITY_AUTO_ACCEPT_NOTE = "auto:high-precision";
+var IDENTITY_AUTO_ACCEPT_KINDS = [
+  "exact-email",
+  "exact-phone",
+  "observed-email",
+  "observed-phone"
+];
+var DEFAULT_IDENTITY_AUTO_ACCEPT_KINDS = [
+  "exact-email",
+  "exact-phone",
+  "observed-phone"
+];
+var DEFAULT_IDENTITY_AUTO_ACCEPT_LIMIT = 100;
+var MAX_IDENTITY_AUTO_ACCEPT_LIMIT = 500;
+var AUTO_ACCEPT_SUGGESTION_PAGE = 500;
+var REALM_CONTRADICTION_PREFIX = "distinct exact resources in";
+var CONFLICTING_TARGETS_WARNING = "this provider identity has observed methods pointing to different identity components";
+var OBSERVED_BASELINE_WARNING = /^unverified (?:email|phone) observation; review is required$/u;
+var OBSERVED_TOLERATED_WARNINGS = [
+  OBSERVED_BASELINE_WARNING,
+  /^normalized display names differ$/u,
+  /^interaction history overlaps direct and Beeper /u
+];
+var PHONE_NAME_MISMATCH_DETAIL = "both records carry different display names; a shared phone joins only matching names or a nameless stub";
+var PHONE_COMPONENT_NAME_MISMATCH_DETAIL = "identity components carry different display names; a shared phone requires compatible names across both components";
+function isAutoAcceptKind(kind) {
+  return IDENTITY_AUTO_ACCEPT_KINDS.includes(kind);
+}
+function displayNameTokens(displayName) {
+  const raw = (displayName ?? "").trim();
+  if (raw.length === 0 || raw.includes("@") && !/\s/u.test(raw))
+    return [];
+  const normalized = raw.normalize("NFKC").toLocaleLowerCase("en-US").replaceAll(/[^\p{L}\p{M}\p{N}]+/gu, " ").trim();
+  if (normalized.length === 0 || /^[\p{N} ]+$/u.test(normalized))
+    return [];
+  return [...new Set(normalized.split(" "))];
+}
+function compatibleDisplayNames(left, right) {
+  const leftTokens = displayNameTokens(left);
+  const rightTokens = displayNameTokens(right);
+  if (leftTokens.length === 0 || rightTokens.length === 0)
+    return true;
+  const [shorter, longer] = leftTokens.length <= rightTokens.length ? [leftTokens, rightTokens] : [rightTokens, leftTokens];
+  const longerSet = new Set(longer);
+  return shorter.every((token) => longerSet.has(token));
+}
+function phoneNameBlocker(suggestion) {
+  if (suggestion.kind !== "exact-phone" && suggestion.kind !== "observed-phone")
+    return null;
+  if (compatibleDisplayNames(suggestion.left.displayName, suggestion.right.displayName))
+    return null;
+  return { reason: "name-mismatch", detail: PHONE_NAME_MISMATCH_DETAIL };
+}
+function identityAutoAcceptBlocker(suggestion) {
+  if (!isAutoAcceptKind(suggestion.kind)) {
+    return { reason: "ineligible-kind", detail: `${suggestion.kind} evidence always requires manual review` };
+  }
+  const realm = suggestion.warnings.find((warning) => warning.startsWith(REALM_CONTRADICTION_PREFIX));
+  if (realm !== undefined)
+    return { reason: "realm-contradiction", detail: realm };
+  const observation = suggestion.observation;
+  if (observation === undefined) {
+    if (suggestion.warnings.length > 0 || suggestion.confidence !== "strong") {
+      return { reason: "unreviewed-warning", detail: suggestion.warnings[0] ?? "suggestion is not strong" };
+    }
+    return phoneNameBlocker(suggestion);
+  }
+  if (observation.ambiguity !== "unique" || observation.candidateComponentCount !== 1) {
+    return {
+      reason: "ambiguous-candidates",
+      detail: `observed value has ${observation.candidateComponentCount} eligible identity candidates`
+    };
+  }
+  if (observation.observationComponentCount > 1) {
+    return {
+      reason: "multi-observation-cluster",
+      detail: `observed value appears in ${observation.observationComponentCount} provider identity components`
+    };
+  }
+  if (suggestion.warnings.includes(CONFLICTING_TARGETS_WARNING)) {
+    return { reason: "conflicting-targets", detail: CONFLICTING_TARGETS_WARNING };
+  }
+  if (observation.selfStatus !== "false") {
+    return { reason: "self-status-unknown", detail: `source self status is ${observation.selfStatus}` };
+  }
+  const unexpected = suggestion.warnings.find((warning) => !OBSERVED_TOLERATED_WARNINGS.some((pattern) => pattern.test(warning)));
+  if (unexpected !== undefined)
+    return { reason: "unreviewed-warning", detail: unexpected };
+  return phoneNameBlocker(suggestion);
+}
+function componentLevelRealmBlocker(database, index, suggestion) {
+  if (suggestion.observation !== undefined)
+    return null;
+  const left = index.canonicalOf.get(suggestion.leftPersonId);
+  const right = index.canonicalOf.get(suggestion.rightPersonId);
+  if (left === undefined || right === undefined || left === right) {
+    return { reason: "stale-evidence", detail: "identity components changed during this run" };
+  }
+  const contradictions = componentRealmContradictions(componentSnapshot(database, left, index), componentSnapshot(database, right, index));
+  const first = contradictions[0];
+  return first === undefined ? null : { reason: "realm-contradiction", detail: first };
+}
+function componentLevelPhoneNameBlocker(database, index, suggestion) {
+  if (suggestion.kind !== "exact-phone" && suggestion.kind !== "observed-phone")
+    return null;
+  const left = index.canonicalOf.get(suggestion.leftPersonId);
+  const right = index.canonicalOf.get(suggestion.rightPersonId);
+  const stale = {
+    reason: "stale-evidence",
+    detail: "identity components changed during this run"
+  };
+  if (left === undefined || right === undefined || left === right)
+    return stale;
+  const names = personNamesLookup(database);
+  const componentNames = (canonicalId) => {
+    const members = index.membersOf.get(canonicalId);
+    if (members === undefined || members.length === 0)
+      return null;
+    const result = [];
+    for (const personId of members) {
+      const person = names(personId);
+      if (person === undefined)
+        return null;
+      result.push(person.displayName);
+    }
+    return result;
+  };
+  const leftNames = componentNames(left);
+  const rightNames = componentNames(right);
+  if (leftNames === null || rightNames === null)
+    return stale;
+  if (leftNames.some((leftName) => rightNames.some((rightName) => !compatibleDisplayNames(leftName, rightName)))) {
+    return { reason: "name-mismatch", detail: PHONE_COMPONENT_NAME_MISMATCH_DETAIL };
+  }
+  return null;
+}
+function normalizeAutoAcceptKinds(kinds) {
+  const requested = kinds === undefined || kinds.length === 0 ? DEFAULT_IDENTITY_AUTO_ACCEPT_KINDS : kinds;
+  const result = [];
+  for (const kind of requested) {
+    if (kind === "name-organization") {
+      throw new Error("name-organization evidence is never eligible for automatic acceptance.");
+    }
+    if (!isAutoAcceptKind(kind))
+      throw new Error("Identity auto-accept kinds must be exact-email, exact-phone, observed-email, or observed-phone.");
+    if (!result.includes(kind))
+      result.push(kind);
+  }
+  return result;
+}
+function autoAcceptIdentities(database, options = {}) {
+  const kinds = normalizeAutoAcceptKinds(options.kinds);
+  if (options.ambiguity !== undefined && options.ambiguity !== "unique") {
+    throw new Error("Identity auto-accept reviews unique candidates only.");
+  }
+  const limit = options.limit ?? DEFAULT_IDENTITY_AUTO_ACCEPT_LIMIT;
+  if (!Number.isSafeInteger(limit) || limit < 1 || limit > MAX_IDENTITY_AUTO_ACCEPT_LIMIT) {
+    throw new Error(`Identity auto-accept limit must be between 1 and ${MAX_IDENTITY_AUTO_ACCEPT_LIMIT}.`);
+  }
+  if (options.source !== undefined && !/^[a-z][a-z0-9-]{0,63}$/u.test(options.source)) {
+    throw new Error("Identity observation source is invalid.");
+  }
+  const dryRun = options.dryRun === true;
+  const operatorNote = options.note?.trim() ?? "";
+  const noteFor = (kind) => `${IDENTITY_AUTO_ACCEPT_NOTE} ${kind} unique${operatorNote.length > 0 ? `; ${operatorNote}` : ""}`;
+  const accepted = [];
+  const skipped = [];
+  const resolved = new Set;
+  const stale = new Map;
+  const pairKey = (suggestion) => `${suggestion.leftPersonId}.${suggestion.rightPersonId}`;
+  const skip = (suggestion, blocker) => {
+    resolved.add(pairKey(suggestion));
+    stale.delete(pairKey(suggestion));
+    skipped.push({
+      token: suggestion.token,
+      kind: suggestion.kind,
+      leftPersonId: suggestion.leftPersonId,
+      rightPersonId: suggestion.rightPersonId,
+      reason: blocker.reason,
+      detail: blocker.detail,
+      warnings: suggestion.warnings
+    });
+  };
+  let index = null;
+  const components = () => {
+    index ??= componentIndex(database);
+    return index;
+  };
+  let rounds = 0;
+  let progress = true;
+  while (progress && accepted.length < limit && rounds <= limit) {
+    rounds += 1;
+    progress = false;
+    for (const kind of kinds) {
+      if (accepted.length >= limit)
+        break;
+      const observed = kind === "observed-email" || kind === "observed-phone";
+      const suggestions = suggestIdentities(database, {
+        kind,
+        limit: AUTO_ACCEPT_SUGGESTION_PAGE,
+        ...observed ? { ambiguity: "unique" } : {},
+        ...observed && options.source !== undefined ? { source: options.source } : {}
+      });
+      for (const suggestion of suggestions) {
+        if (accepted.length >= limit)
+          break;
+        const key = pairKey(suggestion);
+        if (resolved.has(key))
+          continue;
+        const blocker = identityAutoAcceptBlocker(suggestion) ?? (currentDecision(database, suggestion.leftPersonId, suggestion.rightPersonId) === null ? null : { reason: "prior-decision", detail: "a current decision already exists for this pair" }) ?? componentLevelRealmBlocker(database, components(), suggestion) ?? componentLevelPhoneNameBlocker(database, components(), suggestion);
+        if (blocker !== null) {
+          skip(suggestion, blocker);
+          continue;
+        }
+        const entry = {
+          token: suggestion.token,
+          kind,
+          leftPersonId: suggestion.leftPersonId,
+          rightPersonId: suggestion.rightPersonId,
+          score: suggestion.score
+        };
+        if (dryRun) {
+          resolved.add(key);
+          accepted.push({ decisionId: null, ...entry });
+          continue;
+        }
+        try {
+          const decision = decideIdentity(database, suggestion.token, "accept", noteFor(kind));
+          index = null;
+          resolved.add(key);
+          stale.delete(key);
+          accepted.push({ decisionId: decision.decisionId, ...entry });
+          progress = true;
+        } catch (error) {
+          const message = error instanceof Error ? error.message : "unexpected failure";
+          if (message === "Identity evidence changed; request a fresh suggestion.") {
+            stale.set(key, suggestion);
+            continue;
+          }
+          skip(suggestion, { reason: "decision-refused", detail: message });
+        }
+      }
+    }
+    if (dryRun)
+      break;
+  }
+  for (const suggestion of stale.values()) {
+    skip(suggestion, { reason: "stale-evidence", detail: "evidence changed during this run; rerun to re-evaluate" });
+  }
+  const byReason = {};
+  for (const item of skipped)
+    byReason[item.reason] = (byReason[item.reason] ?? 0) + 1;
+  return {
+    dryRun,
+    policy: {
+      kinds,
+      ambiguity: "unique",
+      limit,
+      source: options.source ?? null,
+      note: IDENTITY_AUTO_ACCEPT_NOTE
+    },
+    rounds,
+    reviewed: resolved.size,
+    limitReached: accepted.length >= limit,
+    accepted,
+    skipped,
+    counts: { accepted: accepted.length, skipped: skipped.length, byReason }
+  };
+}
 function currentAcceptedObservedDecisions(database, observationsByMethod, source) {
   const decisions = database.query(`SELECT id,evidence_json,created_at FROM identity_current_decisions
     WHERE action='accept' AND json_extract(evidence_json,'$.version')=2
@@ -9348,7 +11039,7 @@ function auditObservedIdentityLinks(database, options = {}) {
 }
 
 // src/local/people-create.ts
-import { randomBytes as randomBytes3 } from "crypto";
+import { randomBytes as randomBytes4 } from "crypto";
 var MODE2 = "confirmed-person-v1";
 var PROVIDER3 = "manual";
 var ACCOUNT_KEY2 = "local";
@@ -9400,7 +11091,7 @@ function nameStableKey(displayName) {
     schemaVersion: 1,
     kind: "confirmed-name",
     displayName,
-    entropy: randomBytes3(32).toString("hex")
+    entropy: randomBytes4(32).toString("hex")
   }))}`;
 }
 function explicitAttestationMetadata(note) {
@@ -9598,12 +11289,12 @@ function addConfirmedPerson(database, args) {
 import { Database as Database3 } from "bun:sqlite";
 import { createHash as createHash3 } from "crypto";
 import {
-  lstatSync as lstatSync4,
+  lstatSync as lstatSync5,
   readdirSync as readdirSync2,
   realpathSync as realpathSync4
 } from "fs";
 import { homedir as homedir2 } from "os";
-import { join as join4, resolve as resolve3 } from "path";
+import { join as join5, resolve as resolve3 } from "path";
 var EMAIL_PATTERN2 = /^(?=[\x21-\x7E]+$)[^@\s]+@[^@\s]+\.[^@\s]+$/u;
 function clean(value) {
   if (typeof value !== "string")
@@ -9614,7 +11305,7 @@ function clean(value) {
 function normalizeEmail(value) {
   return value.trim().toLocaleLowerCase("en-US");
 }
-var DEFAULT_APPLE_CONTACTS_DIRECTORY = join4(homedir2(), "Library", "Application Support", "AddressBook");
+var DEFAULT_APPLE_CONTACTS_DIRECTORY = join5(homedir2(), "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;
@@ -9807,8 +11498,8 @@ function rowsByOwner(database, table, names) {
 }
 function sourceDatabasePaths(directory) {
   const base = realpathSync4(resolve3(directory));
-  const sourceDirectory = join4(base, "Sources");
-  const sourceIdentity = lstatSync4(sourceDirectory);
+  const sourceDirectory = join5(base, "Sources");
+  const sourceIdentity = lstatSync5(sourceDirectory);
   if (!sourceIdentity.isDirectory() || sourceIdentity.isSymbolicLink()) {
     throw new Error("Apple Contacts Sources must be a real directory");
   }
@@ -9819,7 +11510,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 = join4(sourceDirectory, entry.name);
+    const candidateDirectory = join5(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;
@@ -9828,8 +11519,8 @@ function sourceDatabasePaths(directory) {
     const databaseName = databases[0]?.name;
     if (databaseName === undefined)
       throw new Error("Apple Contacts database name is missing");
-    const candidate = join4(candidateDirectory, databaseName);
-    const identity = lstatSync4(candidate);
+    const candidate = join5(candidateDirectory, databaseName);
+    const identity = lstatSync5(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`);
@@ -9933,9 +11624,9 @@ function readStore(storeKey, path) {
         values[child.name] = rows.map((row) => stableObject(row, metrics));
       }
       const serviceRows = childMaps.get("ZABCDMESSAGINGADDRESS")?.get(primaryKey) ?? [];
-      values.ZABCDSERVICE = [...new Set(serviceRows.map((row) => row.ZSERVICE))].filter((id) => typeof id === "number" && Number.isSafeInteger(id)).map((id) => serviceById.get(id)).filter((row) => row !== undefined).map((row) => stableObject(row, metrics));
+      values.ZABCDSERVICE = [...new Set(serviceRows.map((row) => row.ZSERVICE))].filter((id2) => typeof id2 === "number" && Number.isSafeInteger(id2)).map((id2) => serviceById.get(id2)).filter((row) => row !== undefined).map((row) => stableObject(row, metrics));
       const customRows = childMaps.get("ZABCDCUSTOMPROPERTYVALUE")?.get(primaryKey) ?? [];
-      values.ZABCDCUSTOMPROPERTY = [...new Set(customRows.map((row) => row.ZCUSTOMPROPERTY))].filter((id) => typeof id === "number" && Number.isSafeInteger(id)).map((id) => customPropertyById.get(id)).filter((row) => row !== undefined).map((row) => stableObject(row, metrics));
+      values.ZABCDCUSTOMPROPERTY = [...new Set(customRows.map((row) => row.ZCUSTOMPROPERTY))].filter((id2) => typeof id2 === "number" && Number.isSafeInteger(id2)).map((id2) => customPropertyById.get(id2)).filter((row) => row !== undefined).map((row) => stableObject(row, metrics));
       values.ZABCDGROUPS = (groups.get(primaryKey) ?? []).map((row) => stableObject(row, metrics));
       const rawJson = stableJson({
         schemaVersion: 1,
@@ -10170,15 +11861,15 @@ function syncAppleContacts(database, options = {}) {
 }
 
 // src/local/source-ingestion.ts
-import { z as z8 } from "zod";
-var providerSchema = z8.string().regex(/^[a-z][a-z0-9-]{0,63}$/u);
-var boundedText3 = (maximum) => z8.string().min(1).max(maximum).refine((value) => !/[\u0000\r]/u.test(value), "Text contains an unsupported control character");
+import { z as z10 } from "zod";
+var providerSchema = z10.string().regex(/^[a-z][a-z0-9-]{0,63}$/u);
+var boundedText3 = (maximum) => z10.string().min(1).max(maximum).refine((value) => !/[\u0000\r]/u.test(value), "Text contains an unsupported control character");
 var nullableText3 = (maximum) => boundedText3(maximum).nullable();
-var digestSchema2 = z8.string().regex(/^[a-f0-9]{64}$/u);
-var timestampSchema2 = z8.iso.datetime({ offset: true });
+var digestSchema2 = z10.string().regex(/^[a-f0-9]{64}$/u);
+var timestampSchema2 = z10.iso.datetime({ offset: true });
 var sqliteNoCase = (value) => value.replace(/[A-Z]/gu, (character) => character.toLowerCase());
-var jsonObjectSchema = z8.record(z8.string(), z8.json()).refine((value) => Buffer.byteLength(canonicalJson(value), "utf8") <= 64 * 1024, "Metadata exceeds 64 KiB");
-var personSchema = z8.object({
+var jsonObjectSchema = z10.record(z10.string(), z10.json()).refine((value) => Buffer.byteLength(canonicalJson(value), "utf8") <= 64 * 1024, "Metadata exceeds 64 KiB");
+var personSchema = z10.object({
   displayName: nullableText3(1024),
   givenName: nullableText3(1024),
   middleName: nullableText3(1024),
@@ -10191,16 +11882,16 @@ var personSchema = z8.object({
   title: nullableText3(1024),
   birthday: birthdaySchema,
   observationBasis: boundedText3(128),
-  observationPriority: z8.number().int().min(0).max(1000),
+  observationPriority: z10.number().int().min(0).max(1000),
   metadata: jsonObjectSchema
 }).strict();
-var resourceSchema = z8.object({
+var resourceSchema = z10.object({
   type: boundedText3(64),
   id: boundedText3(4096),
   username: nullableText3(2048),
   profileUrl: nullableText3(4096),
-  profileUrlIdentityEligible: z8.boolean(),
-  nameIdentityEligible: z8.boolean(),
+  profileUrlIdentityEligible: z10.boolean(),
+  nameIdentityEligible: z10.boolean(),
   displayName: nullableText3(2048),
   metadata: jsonObjectSchema
 }).strict().superRefine((resource, context) => {
@@ -10211,20 +11902,20 @@ var resourceSchema = z8.object({
       message: "An identity-eligible profile URL must be a stored HTTP(S) profile URL"
     });
 });
-var methodSchema = z8.object({
-  kind: z8.enum(["email", "phone", "url", "address", "date", "social", "other"]),
+var methodSchema = z10.object({
+  kind: z10.enum(["email", "phone", "url", "address", "date", "social", "other"]),
   value: boundedText3(8192),
   normalizedValue: boundedText3(8192),
-  label: z8.string().max(256),
-  primary: z8.boolean(),
-  confidence: z8.enum(["exact", "likely", "possible", "unknown"]),
-  identityEligible: z8.boolean(),
+  label: z10.string().max(256),
+  primary: z10.boolean(),
+  confidence: z10.enum(["exact", "likely", "possible", "unknown"]),
+  identityEligible: z10.boolean(),
   metadata: jsonObjectSchema
 }).strict();
-var contactSchema = z8.object({
+var contactSchema = z10.object({
   person: personSchema,
   resource: resourceSchema,
-  methods: z8.array(methodSchema).max(1000)
+  methods: z10.array(methodSchema).max(1000)
 }).strict().superRefine((contact, context) => {
   const coordinates = new Set;
   contact.methods.forEach((method, index) => {
@@ -10235,24 +11926,24 @@ var contactSchema = z8.object({
     coordinates.add(coordinate);
   });
 });
-var completenessSchema = z8.enum(["complete", "partial", "lower-bound", "unknown"]);
-var coverageSchema = z8.object({
-  localEnumerationComplete: z8.boolean(),
-  remoteSetComplete: z8.boolean(),
-  truncated: z8.boolean(),
-  absencePolicy: z8.enum(["reconcile-observed", "preserve"]),
-  warnings: z8.array(boundedText3(128)).max(32)
+var completenessSchema = z10.enum(["complete", "partial", "lower-bound", "unknown"]);
+var coverageSchema = z10.object({
+  localEnumerationComplete: z10.boolean(),
+  remoteSetComplete: z10.boolean(),
+  truncated: z10.boolean(),
+  absencePolicy: z10.enum(["reconcile-observed", "preserve"]),
+  warnings: z10.array(boundedText3(128)).max(32)
 }).strict();
-var interactionSchema = z8.object({
+var interactionSchema = z10.object({
   resourceType: boundedText3(64),
   resourceId: boundedText3(4096),
-  sentCount: z8.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  receivedCount: z8.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  interactionCount: z8.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
-  conversationCount: z8.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
+  sentCount: z10.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  receivedCount: z10.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  interactionCount: z10.number().int().min(0).max(Number.MAX_SAFE_INTEGER),
+  conversationCount: z10.number().int().min(0).max(Number.MAX_SAFE_INTEGER).nullable(),
   firstInteractionAt: timestampSchema2.nullable(),
   lastInteractionAt: timestampSchema2.nullable(),
-  reciprocal: z8.boolean(),
+  reciprocal: z10.boolean(),
   completeness: completenessSchema,
   metadata: jsonObjectSchema
 }).strict().superRefine((interaction, context) => {
@@ -10265,32 +11956,32 @@ var interactionSchema = z8.object({
   if (interaction.interactionCount === 0 && (interaction.firstInteractionAt !== null || interaction.lastInteractionAt !== null) || interaction.interactionCount > 0 && (interaction.firstInteractionAt === null || interaction.lastInteractionAt === null) || interaction.firstInteractionAt !== null && interaction.lastInteractionAt !== null && Date.parse(interaction.firstInteractionAt) > Date.parse(interaction.lastInteractionAt))
     context.addIssue({ code: "custom", path: ["firstInteractionAt"], message: "Interaction timestamps do not match the observed count" });
 });
-var sourceBindingSchema = z8.object({
+var sourceBindingSchema = z10.object({
   authId: boundedText3(128),
   authSha256: digestSchema2,
   subjectSha256: digestSchema2,
   metadata: jsonObjectSchema
 }).strict();
-var sourceRealmSchema = z8.object({
+var sourceRealmSchema = z10.object({
   service: boundedText3(64),
   identityNamespace: boundedText3(128),
   externalIdSha256: digestSchema2,
   metadata: jsonObjectSchema
 }).strict();
-var sourceRealmInventoryEntrySchema = z8.object({
+var sourceRealmInventoryEntrySchema = z10.object({
   accountKey: boundedText3(256),
   sourceRealm: sourceRealmSchema
 }).strict();
-var sourceRealmInventorySchema = z8.object({
-  schemaVersion: z8.literal(1),
+var sourceRealmInventorySchema = z10.object({
+  schemaVersion: z10.literal(1),
   provider: providerSchema,
   observedAt: timestampSchema2,
   sourceBinding: sourceBindingSchema,
-  localEnumerationComplete: z8.boolean(),
-  truncated: z8.boolean(),
-  absencePolicy: z8.enum(["reconcile-observed", "preserve"]),
-  realms: z8.array(sourceRealmInventoryEntrySchema).max(128),
-  warnings: z8.array(boundedText3(128)).max(32)
+  localEnumerationComplete: z10.boolean(),
+  truncated: z10.boolean(),
+  absencePolicy: z10.enum(["reconcile-observed", "preserve"]),
+  realms: z10.array(sourceRealmInventoryEntrySchema).max(128),
+  warnings: z10.array(boundedText3(128)).max(32)
 }).strict().superRefine((inventory, context) => {
   if (inventory.absencePolicy === "reconcile-observed" && (!inventory.localEnumerationComplete || inventory.truncated)) {
     context.addIssue({
@@ -10313,8 +12004,8 @@ var sourceRealmInventorySchema = z8.object({
     externalIds.add(entry.sourceRealm.externalIdSha256);
   });
 });
-var contactSourceSnapshotSchema = z8.object({
-  schemaVersion: z8.literal(1),
+var contactSourceSnapshotSchema = z10.object({
+  schemaVersion: z10.literal(1),
   provider: providerSchema,
   accountKey: boundedText3(256),
   mode: boundedText3(64),
@@ -10325,8 +12016,8 @@ var contactSourceSnapshotSchema = z8.object({
   observedAt: timestampSchema2,
   sourceBinding: sourceBindingSchema,
   sourceRealm: sourceRealmSchema,
-  contacts: z8.array(contactSchema).max(250000),
-  interactions: z8.array(interactionSchema).max(250000),
+  contacts: z10.array(contactSchema).max(250000),
+  interactions: z10.array(interactionSchema).max(250000),
   metadata: jsonObjectSchema
 }).strict().superRefine((snapshot, context) => {
   if (snapshot.coverage.absencePolicy === "reconcile-observed" && (!snapshot.coverage.localEnumerationComplete || snapshot.coverage.truncated)) {
@@ -10366,19 +12057,19 @@ function resourceStableKey(snapshot, resource) {
   return `source:${sha256(canonicalJson([snapshot.provider, snapshot.accountKey, resource.type, resource.id]))}`;
 }
 function parseCachedResult(value) {
-  return z8.object({
-    account_key: z8.string(),
-    source_rows: z8.number().int(),
-    people_created: z8.number().int(),
-    people_matched: z8.number().int(),
-    methods_touched: z8.number().int(),
-    interactions_touched: z8.number().int(),
-    resources_removed: z8.number().int(),
-    reconciled: z8.boolean(),
+  return z10.object({
+    account_key: z10.string(),
+    source_rows: z10.number().int(),
+    people_created: z10.number().int(),
+    people_matched: z10.number().int(),
+    methods_touched: z10.number().int(),
+    interactions_touched: z10.number().int(),
+    resources_removed: z10.number().int(),
+    reconciled: z10.boolean(),
     completeness: completenessSchema,
-    local_enumeration_complete: z8.boolean(),
-    remote_set_complete: z8.boolean(),
-    truncated: z8.boolean()
+    local_enumeration_complete: z10.boolean(),
+    remote_set_complete: z10.boolean(),
+    truncated: z10.boolean()
   }).strict().transform((result) => ({ ...result, cached: true })).parse(JSON.parse(value));
 }
 function bindSourceRealm(database, snapshot) {
@@ -16485,7 +18176,7 @@ function plainDataObject(value, label) {
   }
   return descriptors;
 }
-function positiveInteger(value, label, maximum) {
+function positiveInteger2(value, label, maximum) {
   if (value === undefined)
     return;
   if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 1 || value > maximum)
@@ -16507,9 +18198,9 @@ function prepareRequest2(value) {
   const authId = descriptors.authId?.value;
   if (typeof authId !== "string" || !/^[a-z][a-z0-9-]{0,127}$/u.test(authId))
     return fail22("authId must be lowercase kebab text");
-  const limitChats = positiveInteger(descriptors.limitChats?.value, "limitChats", 1e5);
-  const limitMessages = positiveInteger(descriptors.limitMessages?.value, "limitMessages", 1e6);
-  const maxParticipants = positiveInteger(descriptors.maxParticipants?.value, "maxParticipants", 2000);
+  const limitChats = positiveInteger2(descriptors.limitChats?.value, "limitChats", 1e5);
+  const limitMessages = positiveInteger2(descriptors.limitMessages?.value, "limitMessages", 1e6);
+  const maxParticipants = positiveInteger2(descriptors.maxParticipants?.value, "maxParticipants", 2000);
   return Object.freeze({
     authId,
     ...limitChats === undefined ? {} : { limitChats },
@@ -16631,7 +18322,7 @@ function timestamp4(value, label) {
     throw new Error(`${label} must be an ISO timestamp.`);
   return new Date(milliseconds).toISOString();
 }
-function json2(value, label) {
+function json3(value, label) {
   const encoded = canonicalJson(value);
   if (Buffer.byteLength(encoded, "utf8") > 64 * 1024)
     throw new Error(`${label} exceeds its byte limit.`);
@@ -16657,9 +18348,9 @@ function recordSourceExecutionReceipt(database, input) {
   const completedAt = timestamp4(input.completedAt, "Execution completion");
   if (completedAt !== null && completedAt < startedAt)
     throw new Error("Execution timing is invalid.");
-  const usageJson = json2(input.usage, "Execution usage");
-  const costJson = json2(input.cost, "Execution cost");
-  const metadataJson = json2(input.metadata, "Execution metadata");
+  const usageJson = json3(input.usage, "Execution usage");
+  const costJson = json3(input.cost, "Execution cost");
+  const metadataJson = json3(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,
@@ -16834,9 +18525,9 @@ var SUMMARY_CONTRACT_SHA256 = sha256(canonicalJson({
     sourceVersion: "1.1.0"
   }
 }));
-function validateBeeperContactInteractionAccounts(summary, connectedAccounts) {
+function validateBeeperContactInteractionAccounts(summary2, connectedAccounts) {
   const expected = [...connectedAccounts].map((account) => ({ accountId: account.accountId, service: account.service })).sort((left, right) => left.accountId.localeCompare(right.accountId));
-  const observed = summary.accounts.map((account) => ({ accountId: account.accountId, service: normalizeBeeperService(account.network) })).sort((left, right) => left.accountId.localeCompare(right.accountId));
+  const observed = summary2.accounts.map((account) => ({ accountId: account.accountId, service: normalizeBeeperService(account.network) })).sort((left, right) => left.accountId.localeCompare(right.accountId));
   if (canonicalJson(observed) !== canonicalJson(expected)) {
     throw new Error("Beeper interaction summary connected-account inventory drifted");
   }
@@ -16909,7 +18600,7 @@ function ledgerBeeperContactInteractionExport(database, accountKey2, result) {
     completedAt: receipt.finishedAt
   });
 }
-function projectBeeperContactInteractions(summary, coordinates) {
+function projectBeeperContactInteractions(summary2, coordinates) {
   const accounts = new Map;
   for (const coordinate2 of coordinates) {
     const prior = accounts.get(coordinate2.rawAccountId);
@@ -16918,7 +18609,7 @@ function projectBeeperContactInteractions(summary, coordinates) {
     }
     accounts.set(coordinate2.rawAccountId, { accountKey: coordinate2.accountKey, service: coordinate2.service });
   }
-  const summaryAccounts = new Map(summary.accounts.map((account) => [
+  const summaryAccounts = new Map(summary2.accounts.map((account) => [
     account.accountId,
     normalizeBeeperService(account.network)
   ]));
@@ -16933,7 +18624,7 @@ function projectBeeperContactInteractions(summary, coordinates) {
   ]));
   const grouped = new Map;
   let matched = 0;
-  for (const interaction of summary.interactions) {
+  for (const interaction of summary2.interactions) {
     const coordinate2 = contacts.get(`${interaction.accountId}\x00${interaction.contactId}`);
     if (coordinate2 === undefined)
       continue;
@@ -16954,11 +18645,11 @@ function projectBeeperContactInteractions(summary, coordinates) {
       completeness: interaction.completeness,
       metadata: {
         basis: "wrench-contact-interaction-summary-v1",
-        summarySha256: summary.integrity.summarySha256,
+        summarySha256: summary2.integrity.summarySha256,
         sourceVersion: interaction.provenance.sourceVersion,
         providerVersion: interaction.provenance.providerVersion,
-        conversationScope: summary.scope.conversations,
-        messageScope: summary.scope.messages
+        conversationScope: summary2.scope.conversations,
+        messageScope: summary2.scope.messages
       }
     });
     grouped.set(coordinate2.accountKey, items);
@@ -16969,7 +18660,7 @@ function projectBeeperContactInteractions(summary, coordinates) {
     return {
       accountKey: accountKey2,
       relationshipSourceSha256: sha256(canonicalJson({
-        summarySha256: summary.integrity.summarySha256,
+        summarySha256: summary2.integrity.summarySha256,
         accountKey: accountKey2,
         interactions
       })),
@@ -16979,10 +18670,10 @@ function projectBeeperContactInteractions(summary, coordinates) {
     };
   });
   return {
-    summarySha256: summary.integrity.summarySha256,
-    directRelationships: summary.interactions.length,
+    summarySha256: summary2.integrity.summarySha256,
+    directRelationships: summary2.interactions.length,
     matchedRelationships: matched,
-    unmatchedRelationships: summary.interactions.length - matched,
+    unmatchedRelationships: summary2.interactions.length - matched,
     contactReferences: coordinates.length,
     unmatchedContactReferences: coordinates.length - matched,
     groups
@@ -18022,7 +19713,7 @@ var MESSAGING_SEARCH_CONTRACT_SHA256 = BEEPER_WRENCH_COMPATIBILITY.operations["m
 var FINAL_ORIGIN2 = BEEPER_WRENCH_COMPATIBILITY.adapter.origin;
 var MAX_QUERIES = 50;
 var MAX_RESULTS = 20;
-var SHA256 = /^[a-f0-9]{64}$/u;
+var SHA2562 = /^[a-f0-9]{64}$/u;
 var AUTH_ID2 = /^[a-z][a-z0-9-]{0,127}$/u;
 function record4(value, label) {
   if (typeof value !== "object" || value === null || Array.isArray(value)) {
@@ -18076,7 +19767,7 @@ function integer3(value, label, maximum) {
 }
 function digest4(value, label) {
   const parsed = text3(value, label, 64);
-  if (!SHA256.test(parsed))
+  if (!SHA2562.test(parsed))
     throw new Error(`${label} must be a SHA-256 digest`);
   return parsed;
 }
@@ -18305,8 +19996,8 @@ function searchCandidates(account, contacts, conversations) {
     mergeCandidate(candidates, peers[0], "messaging.search");
   }
   return {
-    candidates: [...candidates.entries()].map(([id, candidate]) => ({
-      id,
+    candidates: [...candidates.entries()].map(([id2, candidate]) => ({
+      id: id2,
       displayName: candidate.displayName,
       username: candidate.username,
       origins: [...candidate.origins].sort()
@@ -19540,10 +21231,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 lstatSync5, realpathSync as realpathSync5 } from "fs";
+import { lstatSync as lstatSync6, realpathSync as realpathSync5 } from "fs";
 import { homedir as homedir3 } from "os";
-import { join as join5, resolve as resolve4 } from "path";
-var DEFAULT_IMESSAGE_DATABASE = join5(homedir3(), "Library", "Messages", "chat.db");
+import { join as join6, resolve as resolve4 } from "path";
+var DEFAULT_IMESSAGE_DATABASE = join6(homedir3(), "Library", "Messages", "chat.db");
 var DEFAULT_IMESSAGE_ACCOUNT = "imessage-main";
 var DEFAULT_IMESSAGE_PAGE_SIZE = 1000;
 var MAX_DATABASE_BYTES = 4 * 1024 * 1024 * 1024;
@@ -19657,11 +21348,11 @@ function loadHandles(database) {
   const result = new Map;
   for (const row of allRows3(database, "SELECT ROWID,id,service FROM handle ORDER BY ROWID")) {
     const rowid = safeInteger2(row.ROWID, "iMessage handle ROWID");
-    const id = boundedText4(row.id, "iMessage handle identity");
+    const id2 = boundedText4(row.id, "iMessage handle identity");
     const service = boundedText4(row.service, "iMessage handle service");
     if (result.has(rowid))
       throw new Error("iMessage handle ROWIDs are duplicated");
-    result.set(rowid, { hash: sha2566(id), service, identity: exactMessageHandleIdentity(id) });
+    result.set(rowid, { hash: sha2566(id2), service, identity: exactMessageHandleIdentity(id2) });
   }
   return result;
 }
@@ -19987,7 +21678,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 = resolve4(options.messagesDatabase ?? DEFAULT_IMESSAGE_DATABASE);
-  const identity = lstatSync5(requestedPath);
+  const identity = lstatSync6(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");
@@ -20154,12 +21845,12 @@ function validateExtra(bytes, label) {
   while (position < bytes.length) {
     if (bytes.length - position < 4)
       throw new Error(`ZIP ${label} contains a truncated extra field`);
-    const id = bytes.readUInt16LE(position);
+    const id2 = bytes.readUInt16LE(position);
     const length = bytes.readUInt16LE(position + 2);
     const next = end(position + 4, length, `${label} extra field`);
     if (next > bytes.length)
       throw new Error(`ZIP ${label} contains a truncated extra field`);
-    if (id === ZIP64_EXTRA)
+    if (id2 === ZIP64_EXTRA)
       throw new Error("ZIP64 archives are not supported");
     position = next;
   }
@@ -20603,11 +22294,11 @@ function providerId2(value, label) {
   return String(value);
 }
 function oneProviderId(value, label) {
-  const id = providerId2(value.id, `${label}.id`);
+  const id2 = providerId2(value.id, `${label}.id`);
   const userId = providerId2(value.user_id, `${label}.user_id`);
-  if (id !== null && userId !== null && id !== userId)
+  if (id2 !== null && userId !== null && id2 !== userId)
     throw new Error(`${label} contains conflicting exact provider IDs`);
-  return id ?? userId;
+  return id2 ?? userId;
 }
 function profileHref(value, handle, label) {
   const text5 = bounded(value, label, 2048, true);
@@ -20716,12 +22407,12 @@ function messageItems(member) {
     const handle = optionalUsername(name);
     if (handle !== null)
       names.add(handle);
-    const id = oneProviderId(participant, label);
-    if (id !== null && ids.has(id))
+    const id2 = oneProviderId(participant, label);
+    if (id2 !== null && ids.has(id2))
       throw new Error(`${label} repeats an ID`);
-    if (id !== null)
-      ids.add(id);
-    participants.push({ providerUserId: id, username: handle });
+    if (id2 !== null)
+      ids.add(id2);
+    participants.push({ providerUserId: id2, username: handle });
   }
   return dense(root.messages, `${member.memberName}.messages`, MAX_MESSAGES).map((value, index) => {
     const label = `${member.memberName}.messages[${index}]`;
@@ -20902,33 +22593,33 @@ function importInstagramArchive(database, path, options) {
       const values = aliases.get(handle);
       return values?.size === 1 ? [...values.values()][0] : null;
     };
-    const ensure = (id, href, handle, display) => {
+    const ensure = (id2, href, handle, display) => {
       if (handle === owner)
         return null;
       const canonicalHref = href ?? (handle === null ? null : `https://www.instagram.com/${handle}/`);
-      if (id === null && canonicalHref === null)
+      if (id2 === null && canonicalHref === null)
         return null;
-      const byId = id === null ? null : getRow6(database, "SELECT id,person_id,username,profile_url FROM provider_resources WHERE provider=? AND account_key=? AND resource_type='user' AND resource_id=?", PROVIDER8, account, id);
+      const byId = id2 === null ? null : getRow6(database, "SELECT id,person_id,username,profile_url FROM provider_resources WHERE provider=? AND account_key=? AND resource_type='user' AND resource_id=?", PROVIDER8, account, id2);
       const byHref = canonicalHref === null ? null : getRow6(database, "SELECT id,person_id,username,profile_url FROM provider_resources WHERE provider=? AND account_key=? AND profile_url=? ORDER BY id LIMIT 1", PROVIDER8, account, canonicalHref);
       if (byId !== null && byHref !== null && byId.person_id !== byHref.person_id)
         throw new Error("Instagram ID and profile URL identify different people");
       let personId = byId?.person_id ?? byHref?.person_id ?? null;
       if (personId === null) {
-        personId = insertedId6(run5(database, "INSERT INTO people(stable_key,display_name,metadata_json) VALUES (?,?,?)", `instagram:${sha2567(`${account}\x00${id ?? canonicalHref}`)}`, display ?? handle, stableJson4({ createdBy: "instagram-exact-resource" })));
+        personId = insertedId6(run5(database, "INSERT INTO people(stable_key,display_name,metadata_json) VALUES (?,?,?)", `instagram:${sha2567(`${account}\x00${id2 ?? canonicalHref}`)}`, display ?? handle, stableJson4({ createdBy: "instagram-exact-resource" })));
         peopleCreated += 1;
       } else if (display !== null || handle !== null)
         run5(database, "UPDATE people SET display_name=coalesce(display_name,?) WHERE id=?", display ?? handle, personId);
       peopleTouched.add(personId);
-      if (id !== null && byId === null) {
+      if (id2 !== null && byId === null) {
         const prior = allRows4(database, "SELECT resource_id FROM provider_resources WHERE provider=? AND account_key=? AND resource_type='user' AND person_id=?", PROVIDER8, account, personId);
         if (prior.length > 0)
           throw new Error("Instagram profile is bound to conflicting numeric IDs");
       }
       let primary = byId?.id ?? byHref?.id ?? null;
-      if (id !== null && byId === null) {
-        primary = insertedId6(run5(database, "INSERT INTO provider_resources(provider,account_key,resource_type,resource_id,person_id,username,profile_url,display_name,metadata_json) VALUES (?,?,'user',?,?,?,?,?,?)", PROVIDER8, account, id, personId, handle, canonicalHref, display ?? handle, "{}"));
+      if (id2 !== null && byId === null) {
+        primary = insertedId6(run5(database, "INSERT INTO provider_resources(provider,account_key,resource_type,resource_id,person_id,username,profile_url,display_name,metadata_json) VALUES (?,?,'user',?,?,?,?,?,?)", PROVIDER8, account, id2, personId, handle, canonicalHref, display ?? handle, "{}"));
         identitiesCreated += 1;
-      } else if (id === null && canonicalHref !== null && byHref === null) {
+      } else if (id2 === null && canonicalHref !== null && byHref === null) {
         primary = insertedId6(run5(database, "INSERT INTO provider_resources(provider,account_key,resource_type,resource_id,person_id,username,profile_url,display_name,metadata_json) VALUES (?,?,'profile',?,?,?,?,?,?)", PROVIDER8, account, canonicalHref, personId, handle, canonicalHref, display ?? handle, "{}"));
         identitiesCreated += 1;
       }
@@ -20936,7 +22627,7 @@ function importInstagramArchive(database, path, options) {
         throw new Error("Instagram identity was not materialized");
       run5(database, "UPDATE provider_resources SET username=coalesce(?,username),profile_url=coalesce(?,profile_url),profile_url_identity_eligible=CASE WHEN ? IS NULL THEN profile_url_identity_eligible ELSE 1 END,display_name=coalesce(?,display_name),active=1 WHERE id=?", handle, canonicalHref, canonicalHref, display ?? handle, primary);
       touchedResources.add(primary);
-      const identity = { personId, primaryResourceId: primary, username: handle, profileHref: canonicalHref, providerUserId: id };
+      const identity = { personId, primaryResourceId: primary, username: handle, profileHref: canonicalHref, providerUserId: id2 };
       observe(handle, identity);
       return identity;
     };
@@ -21233,14 +22924,14 @@ function extraFields(bytes, label) {
   while (position < bytes.length) {
     if (bytes.length - position < 4)
       throw new Error(`X ZIP ${label} contains a truncated extra field`);
-    const id = bytes.readUInt16LE(position);
+    const id2 = bytes.readUInt16LE(position);
     const length = bytes.readUInt16LE(position + 2);
     const next = checkedEnd(position + 4, length, `${label} extra field`);
     if (next > bytes.length)
       throw new Error(`X ZIP ${label} contains a truncated extra field`);
-    if (fields.has(id))
-      throw new Error(`X ZIP ${label} contains duplicate extra field ${id}`);
-    fields.set(id, bytes.subarray(position + 4, next));
+    if (fields.has(id2))
+      throw new Error(`X ZIP ${label} contains duplicate extra field ${id2}`);
+    fields.set(id2, bytes.subarray(position + 4, next));
     position = next;
   }
   return fields;
@@ -21663,7 +23354,7 @@ function timestamp5(value, label) {
     throw new Error(`${label} is not a timestamp`);
   return new Date(milliseconds2).toISOString();
 }
-function userLink(value, id, label) {
+function userLink(value, id2, label) {
   const raw = text5(value, label, 2048, true);
   let parsed;
   try {
@@ -21671,7 +23362,7 @@ function userLink(value, id, label) {
   } catch (error) {
     throw new Error(`${label} is not an X user link`, { cause: error });
   }
-  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.port !== "" || parsed.hash !== "" || !["twitter.com", "www.twitter.com", "x.com", "www.x.com"].includes(parsed.hostname) || parsed.pathname !== "/intent/user" || parsed.searchParams.size !== 1 || parsed.searchParams.get("user_id") !== id) {
+  if (parsed.protocol !== "https:" || parsed.username !== "" || parsed.password !== "" || parsed.port !== "" || parsed.hash !== "" || !["twitter.com", "www.twitter.com", "x.com", "www.x.com"].includes(parsed.hostname) || parsed.pathname !== "/intent/user" || parsed.searchParams.size !== 1 || parsed.searchParams.get("user_id") !== id2) {
     throw new Error(`${label} does not identify the exported X user ID`);
   }
 }
@@ -21844,11 +23535,11 @@ function parseTweetIdentities(member) {
       const mentionLabel = `${label}.tweet.entities.user_mentions[${mentionIndex}]`;
       const mention = plain2(value2, mentionLabel);
       exactKeys5(mention, REVIEWED_MENTION_KEYS, mentionLabel);
-      const id = optionalOpaqueProviderId(mention.id, `${mentionLabel}.id`);
+      const id2 = optionalOpaqueProviderId(mention.id, `${mentionLabel}.id`);
       const idString = optionalOpaqueProviderId(mention.id_str, `${mentionLabel}.id_str`);
-      if (id === null || idString === null)
+      if (id2 === null || idString === null)
         throw new Error(`${mentionLabel} must contain both X user ID coordinates`);
-      if (id !== idString)
+      if (id2 !== idString)
         throw new Error(`${mentionLabel} X user IDs disagree`);
       if (!PROVIDER_ID2.test(idString))
         continue;
@@ -21928,12 +23619,12 @@ function parseMessages(member, selfId, group, seenMessageIds, conversationMember
       state.participants.add(selfId);
     let directPeerId = null;
     if (!group) {
-      const ids = conversationId.split("-").map((id, part) => providerId3(id, `${label}.conversationId[${part}]`));
+      const ids = conversationId.split("-").map((id2, part) => providerId3(id2, `${label}.conversationId[${part}]`));
       if (ids.length !== 2 || !ids.includes(selfId))
         throw new Error(`${label}.conversationId is not bound to the archive account`);
-      for (const id of ids)
-        state.participants.add(id);
-      directPeerId = ids.find((id) => id !== selfId) ?? null;
+      for (const id2 of ids)
+        state.participants.add(id2);
+      directPeerId = ids.find((id2) => id2 !== selfId) ?? null;
       if (directPeerId === null)
         throw new Error(`${label}.conversationId does not identify a direct-message peer`);
     }
@@ -21956,7 +23647,7 @@ function parseMessages(member, selfId, group, seenMessageIds, conversationMember
         state.participants.add(message.senderId);
         if (message.recipientId !== null)
           state.participants.add(message.recipientId);
-        if (!group && [...state.participants].some((id) => !conversationId.split("-").includes(id)))
+        if (!group && [...state.participants].some((id2) => !conversationId.split("-").includes(id2)))
           throw new Error(`${eventLabel} names a user outside its direct conversation`);
         let providerUserId = null;
         let direction = null;
@@ -21987,8 +23678,8 @@ function parseMessages(member, selfId, group, seenMessageIds, conversationMember
         occurredAt = message.createdAt;
         state.messageCount += 1;
       } else if (["joinConversation", "participantsJoin", "participantsLeave", "conversationNameUpdate"].includes(eventKind)) {
-        for (const id of validateMembershipEvent(event[eventKind], `${eventLabel}.${eventKind}`, eventKind))
-          state.participants.add(id);
+        for (const id2 of validateMembershipEvent(event[eventKind], `${eventLabel}.${eventKind}`, eventKind))
+          state.participants.add(id2);
       } else
         throw new Error(`${eventLabel} contains unreviewed event ${eventKind}`);
       if (occurredAt !== null) {
@@ -22005,7 +23696,7 @@ function parseMessages(member, selfId, group, seenMessageIds, conversationMember
   const evidence = [];
   for (const [conversationId, state] of [...combined.entries()].sort(([left], [right]) => left.localeCompare(right))) {
     const conversationSha256 = sha2568(conversationId);
-    for (const providerUserId of [...state.participants].filter((id) => id !== selfId).sort()) {
+    for (const providerUserId of [...state.participants].filter((id2) => id2 !== selfId).sort()) {
       const safe = { kind: "dm-participant", memberName: member.memberName, memberRecord: state.memberRecord, providerUserId, conversationSha256, group, messageCount: state.messageCount, firstMessageAt: state.first, lastMessageAt: state.last };
       evidence.push({ ...safe, hash: sha2568(stableJson5(safe)) });
     }
@@ -23293,7 +24984,7 @@ var DEFAULT_WHATSAPP_INTERACTION_PAGE_SIZE = 1000;
 var MAX_PAGES2 = 1e5;
 var MAX_CONTACTS5 = 250000;
 var MAX_INTERACTIONS = 1e6;
-var SHA2562 = /^[a-f0-9]{64}$/u;
+var SHA2563 = /^[a-f0-9]{64}$/u;
 var DECIMAL = /^(?:0|[1-9][0-9]{0,18})$/u;
 var SUBJECT2 = /^whatsapp:(?:pn:[0-9]{5,20}|lid:[0-9]{5,32})$/u;
 var USER_JID = /^([0-9]{5,20})@s\.whatsapp\.net$/u;
@@ -23351,7 +25042,7 @@ function bool3(value, label) {
 }
 function digest5(value, label) {
   const parsed = text6(value, label, 64);
-  if (!SHA2562.test(parsed))
+  if (!SHA2563.test(parsed))
     throw new Error(`${label} is invalid`);
   return parsed;
 }
@@ -23988,7 +25679,7 @@ function syncWhatsAppRelationships(database, options = {}) {
 }
 
 // src/cli/version.ts
-var peoplebladeVersion = "0.1.2";
+var peoplebladeVersion = "0.2.1";
 
 // src/cli/main.ts
 var usage = `PeopleBlade \u2014 local-first contact intelligence
@@ -24000,6 +25691,13 @@ Core:
   backup [PATH]                     Create a consistent private SQLite backup
   migrate rolodex --from PATH       Back up and migrate a legacy Rolodex database once
   list [--search TEXT] [--limit N]  Search the local contact book
+  query [--search TEXT]             Page the live contact book (default 50, maximum 100)
+    [--source NAME] [--has-email yes|no] [--has-phone yes|no]
+    [--do-not-contact all|exclude|only] [--sort name|organization|interactions|last-contact]
+    [--direction asc|desc] [--limit N] [--offset N]
+  people show ID                    Read bounded canonical contact details
+  capabilities                     Discover supported sources and contracts without a database
+  ui [--port N]                    Open the local-only CRM workspace (default: random loopback port)
   people add --display-name NAME --confirm
                                     Create one user-confirmed local person
                                     [--email EMAIL] [--label NAME] [--note TEXT]
@@ -24009,6 +25707,9 @@ Core:
                                     List reversible accepted observed decisions
   identity suggest [--kind KIND]    Review one evidence-bound possible duplicate
   identity decide TOKEN ACTION      Accept, reject, or defer one fresh suggestion
+  identity auto-accept [--kinds LIST] [--source NAME] [--limit N] [--dry-run] [--note TEXT]
+                                    Accept only unique, warning-free exact evidence and report every skip
+                                    Default kinds: exact-email,exact-phone,observed-phone
   identity separate DECISION_ID     Reverse one current accepted identity decision
   identity attest-email PERSON_ID EMAIL
                                     Add one explicit, reversible exact email attestation
@@ -24016,7 +25717,7 @@ Core:
   identity retract-email METHOD_ID  Retract one explicit email attestation
   identity accept-candidate TOKEN   Materialize one reviewed staged provider candidate
 
-Sources:
+Sources (append --auto-accept to run identity auto-accept after a successful import):
   contacts sync [--directory PATH] Sync macOS Contacts from the local AddressBook database
   beeper sync [--auth ID]         Sync connected Beeper accounts sequentially through Wrench
     [--with-relationships]         Add body-free lower-bound direct interaction counts
@@ -24048,6 +25749,7 @@ Cloud (optional):
   cloud enrich --confirm TOKEN      Launch a preview with the same --person-id values
   cloud enrich --status JOB_ID      Read one CLI-owned aggregate enrichment receipt
   cloud enrich --details JOB_ID     Read privacy-safe per-run tuning diagnostics
+  cloud enrich --public-emails      Read deduplicated publicEmail leftovers from completed runs
   cloud enrich --revalidate-historical
                                     Revalidate stored results under the current policy
 
@@ -24055,6 +25757,11 @@ Notes (local JSON; not synced to cloud):
   notes add --person-id ID --occurred-at ISO --body TEXT
                                     Append one dated note [--title TEXT] [--source NAME] [--source-id ID]
   notes list --person-id ID         List notes [--since ISO] [--until ISO] [--source NAME]
+  notes show ID                     Read effective markdown and revision/context fences
+  notes update ID --body-file PATH|- --expected-revision N
+    --expected-context SHA256 --request-id UUID [--title TEXT | --clear-title]
+                                    Append an idempotent, compare-and-swap note edit
+  notes history ID                  Read immutable history [--before-revision N] [--limit N]
   notes search QUERY                Search note text [--person-id ID] [--since ISO] [--until ISO]
   notes import --from granola.json  Attach Granola summaries by exact email/phone, then unique name search; apply a new calendar email only to that unique match
 
@@ -24067,8 +25774,11 @@ Ensoul:
                                     Write a private, source-bounded person packet
 
 The default database is ${peoplebladeDatabasePath()}`;
+
+class CliUsageError extends Error {
+}
 function fail3(message) {
-  throw new Error(message);
+  throw new CliUsageError(message);
 }
 function valueAfter(args, name) {
   const index = args.indexOf(name);
@@ -24099,6 +25809,76 @@ function positive(value, label, fallback, maximum) {
     fail3(`${label} is too large.`);
   return parsed;
 }
+function nonnegative(value, label, fallback, maximum) {
+  if (value === undefined)
+    return fallback;
+  if (!/^(?:0|[1-9][0-9]*)$/u.test(value))
+    fail3(`${label} must be a nonnegative integer.`);
+  const number2 = Number(value);
+  if (!Number.isSafeInteger(number2) || number2 > maximum)
+    fail3(`${label} is too large.`);
+  return number2;
+}
+function yesNo(value, label) {
+  if (value === undefined)
+    return;
+  if (value !== "yes" && value !== "no")
+    fail3(`${label} must be yes or no.`);
+  return value === "yes";
+}
+async function readNoteMarkdown(path) {
+  const maximum = 65536;
+  if (path !== "-") {
+    const descriptor = openSync9(resolve6(path), constants9.O_RDONLY | constants9.O_NONBLOCK | (constants9.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()) {
+        fail3("Markdown input must be one owned regular file of at most 65536 bytes.");
+      }
+      const bytes2 = new Uint8Array(maximum + 1);
+      let length2 = 0;
+      for (;; ) {
+        const count = readSync3(descriptor, bytes2, length2, bytes2.length - length2, null);
+        length2 += count;
+        if (length2 > maximum)
+          fail3("Markdown input exceeds 65536 bytes.");
+        if (count === 0)
+          break;
+      }
+      const after = fstatSync8(descriptor);
+      if (after.size !== before.size || after.mtimeMs !== before.mtimeMs || after.ctimeMs !== before.ctimeMs || after.ino !== before.ino || after.dev !== before.dev || length2 !== before.size) {
+        fail3("Markdown input changed while it was being read.");
+      }
+      return new TextDecoder("utf-8", { fatal: true }).decode(bytes2.subarray(0, length2));
+    } finally {
+      closeSync9(descriptor);
+    }
+  }
+  const reader = Bun.stdin.stream().getReader();
+  const bytes = new Uint8Array(maximum);
+  let length = 0;
+  let done = false;
+  try {
+    for (;; ) {
+      const next = await reader.read();
+      if (next.done) {
+        done = true;
+        break;
+      }
+      if (next.value.byteLength > maximum - length)
+        fail3("Markdown input exceeds 65536 bytes.");
+      bytes.set(next.value, length);
+      length += next.value.byteLength;
+    }
+    return new TextDecoder("utf-8", { fatal: true }).decode(bytes.subarray(0, length));
+  } finally {
+    if (!done)
+      reader.cancel().catch(() => {
+        return;
+      });
+    reader.releaseLock();
+  }
+}
 function print(value, asJson) {
   if (asJson)
     console.log(JSON.stringify(value, null, 2));
@@ -24107,12 +25887,29 @@ function print(value, asJson) {
   else
     console.log(JSON.stringify(value, null, 2));
 }
+function flag(args, name) {
+  const index = args.indexOf(name);
+  if (index < 0)
+    return false;
+  args.splice(index, 1);
+  return true;
+}
+var AUTO_ACCEPT_SOURCE_COMMANDS = new Set([
+  "contacts sync",
+  "beeper sync",
+  "google sync",
+  "imessage sync",
+  "whatsapp sync",
+  "linkedin import",
+  "x import",
+  "instagram import",
+  "notes import"
+]);
 async function main(argv) {
   const args = [...argv];
   const databasePath = valueAfter(args, "--db") ?? peoplebladeDatabasePath();
-  const asJson = args.includes("--json");
-  if (asJson)
-    args.splice(args.indexOf("--json"), 1);
+  const asJson = flag(args, "--json");
+  const autoAccept = flag(args, "--auto-accept");
   if (args.length === 0 || args[0] === "--help" || args[0] === "-h") {
     console.log(usage);
     return;
@@ -24124,6 +25921,15 @@ async function main(argv) {
     return;
   }
   const [command, subcommand, ...rest] = args;
+  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);
+    return;
+  }
   if (command === "init") {
     if (args.length !== 1)
       fail3("init takes no arguments.");
@@ -24146,7 +25952,7 @@ async function main(argv) {
   if (command === "cloud" && subcommand === "signin") {
     if (rest.length)
       fail3(`Unknown argument: ${rest[0]}`);
-    const result = await signInCloud(undefined, { onCode: (code, verification) => console.log(`Authorize code ${code}
+    const result = await signInCloud(undefined, { onCode: (code, verification) => console.error(`Authorize code ${code}
 ${verification}`) });
     print(result, asJson);
     return;
@@ -24183,7 +25989,22 @@ ${verification}`) });
   }
   initializeLocalDatabase(databasePath);
   const database = connectLocalDatabase(databasePath);
+  const printImport = (result, json4) => {
+    if (!autoAccept) {
+      print(result, json4);
+      return;
+    }
+    print({ ...result, identityAutoAccept: autoAcceptIdentities(database) }, json4);
+  };
   try {
+    if (command === "ui") {
+      const options = [subcommand, ...rest].filter((item) => item !== undefined);
+      const port = nonnegative(valueAfter(options, "--port"), "--port", 0, 65535);
+      if (options.length)
+        fail3(`Unknown argument: ${options[0]}`);
+      await runLocalWorkspace(database, { port, json: asJson });
+      return;
+    }
     if (command === "list") {
       const options = [subcommand, ...rest].filter((item) => item !== undefined);
       const search = valueAfter(options, "--search") ?? "";
@@ -24193,9 +26014,32 @@ ${verification}`) });
       print(listLocalContacts(database, search, limit), asJson);
       return;
     }
+    if (command === "query") {
+      const options = [subcommand, ...rest].filter((item) => item !== undefined);
+      const search = valueAfter(options, "--search") ?? "";
+      const source = valueAfter(options, "--source");
+      const doNotContact = valueAfter(options, "--do-not-contact") ?? "all";
+      const sort = valueAfter(options, "--sort") ?? "interactions";
+      const direction = valueAfter(options, "--direction") ?? "desc";
+      const hasEmail = yesNo(valueAfter(options, "--has-email"), "--has-email");
+      const hasPhone = yesNo(valueAfter(options, "--has-phone"), "--has-phone");
+      const limit = positive(valueAfter(options, "--limit"), "--limit", 50, 100);
+      const offset = nonnegative(valueAfter(options, "--offset"), "--offset", 0, 1e6);
+      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);
+      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);
+        return;
+      }
       if (subcommand !== "add")
-        fail3("people supports add.");
+        fail3("people supports add or show.");
       const options = [...rest];
       const displayName2 = valueAfter(options, "--display-name") ?? fail3("people add requires --display-name.");
       const email2 = valueAfter(options, "--email");
@@ -24288,6 +26132,32 @@ ${verification}`) });
       print(decideIdentity(database, token3, action, note), asJson);
       return;
     }
+    if (command === "identity" && subcommand === "auto-accept") {
+      const options = [...rest];
+      const kindsValue = valueAfter(options, "--kinds");
+      const ambiguity = valueAfter(options, "--ambiguity");
+      const source = valueAfter(options, "--source");
+      const limit = positive(valueAfter(options, "--limit"), "--limit", 100, 500);
+      const note = valueAfter(options, "--note");
+      const dryRun = flag(options, "--dry-run");
+      if (ambiguity !== undefined && ambiguity !== "unique")
+        fail3("identity auto-accept reviews unique candidates only; --ambiguity must be unique.");
+      if (source !== undefined && !/^[a-z][a-z0-9-]{0,63}$/u.test(source))
+        fail3("--source must be a lowercase provider name.");
+      const kinds = kindsValue === undefined ? undefined : kindsValue.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+      if (kinds !== undefined && kinds.length === 0)
+        fail3("--kinds requires a comma-separated list of evidence kinds.");
+      if (options.length)
+        fail3(`Unknown argument: ${options[0]}`);
+      print(autoAcceptIdentities(database, {
+        ...kinds === undefined ? {} : { kinds },
+        limit,
+        dryRun,
+        ...source === undefined ? {} : { source },
+        ...note === undefined ? {} : { note }
+      }), asJson);
+      return;
+    }
     if (command === "identity" && subcommand === "separate") {
       const options = [...rest];
       const decisionIdValue = options.shift();
@@ -24362,6 +26232,9 @@ ${verification}`) });
       const statusJobId = valueAfter(options, "--status");
       const detailsJobId = valueAfter(options, "--details");
       const prioritizeValue = valueAfter(options, "--prioritize");
+      const publicEmails = options.includes("--public-emails");
+      if (publicEmails)
+        options.splice(options.indexOf("--public-emails"), 1);
       const revalidateHistorical = options.includes("--revalidate-historical");
       if (revalidateHistorical)
         options.splice(options.indexOf("--revalidate-historical"), 1);
@@ -24371,11 +26244,14 @@ ${verification}`) });
       const personIdValues = valuesAfter(options, "--person-id");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      if (statusJobId !== undefined && (detailsJobId !== undefined || revalidateHistorical || confirmation !== undefined || prioritizeValue !== undefined || personIdValues.length > 0 || noWait)) {
-        fail3("--status cannot be combined with --details, --revalidate-historical, --confirm, --prioritize, --person-id, or --no-wait.");
+      if (statusJobId !== undefined && (detailsJobId !== undefined || publicEmails || revalidateHistorical || confirmation !== undefined || prioritizeValue !== undefined || personIdValues.length > 0 || noWait)) {
+        fail3("--status cannot be combined with --details, --public-emails, --revalidate-historical, --confirm, --prioritize, --person-id, or --no-wait.");
       }
-      if (detailsJobId !== undefined && (revalidateHistorical || confirmation !== undefined || prioritizeValue !== undefined || personIdValues.length > 0 || noWait)) {
-        fail3("--details cannot be combined with --revalidate-historical, --confirm, --prioritize, --person-id, or --no-wait.");
+      if (detailsJobId !== undefined && (publicEmails || revalidateHistorical || confirmation !== undefined || prioritizeValue !== undefined || personIdValues.length > 0 || noWait)) {
+        fail3("--details cannot be combined with --public-emails, --revalidate-historical, --confirm, --prioritize, --person-id, or --no-wait.");
+      }
+      if (publicEmails && (revalidateHistorical || confirmation !== undefined || prioritizeValue !== undefined || personIdValues.length > 0 || noWait)) {
+        fail3("--public-emails cannot be combined with --revalidate-historical, --confirm, --prioritize, --person-id, or --no-wait.");
       }
       if (revalidateHistorical && (confirmation !== undefined || prioritizeValue !== undefined || personIdValues.length > 0 || noWait)) {
         fail3("--revalidate-historical cannot be combined with --confirm, --prioritize, --person-id, or --no-wait.");
@@ -24388,6 +26264,15 @@ ${verification}`) });
         print(await cloudEnrichmentDetails(detailsJobId), asJson);
         return;
       }
+      if (publicEmails) {
+        const leftovers = await cloudEnrichmentPublicEmails();
+        if (asJson) {
+          print(leftovers, true);
+          return;
+        }
+        print({ count: leftovers.publicEmails.length, sample: leftovers.publicEmails.slice(0, 5) }, false);
+        return;
+      }
       if (revalidateHistorical) {
         print(await revalidateHistoricalCloudEnrichment(), asJson);
         return;
@@ -24416,6 +26301,55 @@ ${verification}`) });
       print({ ...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);
+      return;
+    }
+    if (command === "notes" && subcommand === "update") {
+      const options = [...rest];
+      const noteId = positive(options.shift(), "ID", 0, Number.MAX_SAFE_INTEGER);
+      const path = valueAfter(options, "--body-file") ?? fail3("notes update requires --body-file PATH or -.");
+      const revisionValue = valueAfter(options, "--expected-revision") ?? fail3("notes update requires --expected-revision.");
+      const expectedRevision = nonnegative(revisionValue, "--expected-revision", 0, Number.MAX_SAFE_INTEGER);
+      const expectedContextSha256 = valueAfter(options, "--expected-context") ?? fail3("notes update requires --expected-context.");
+      const requestId = valueAfter(options, "--request-id") ?? fail3("notes update requires --request-id.");
+      const title = valueAfter(options, "--title");
+      const clearTitle = flag(options, "--clear-title");
+      if (title !== undefined && clearTitle)
+        fail3("--title and --clear-title are mutually exclusive.");
+      if (options.length)
+        fail3(`Unknown argument: ${options[0]}`);
+      let currentTitle;
+      if (title !== undefined)
+        currentTitle = title;
+      else if (clearTitle)
+        currentTitle = null;
+      else {
+        if (expectedRevision === Number.MAX_SAFE_INTEGER)
+          fail3("Expected note revision is unavailable.");
+        const expected = listPersonNoteRevisions(database, { noteId, beforeRevision: expectedRevision + 1, limit: 1 }).items[0];
+        if (expected?.revision !== expectedRevision)
+          throw new NoteRevisionError("revision_conflict", "Expected note revision is unavailable. Reload the note before saving.");
+        currentTitle = expected.title;
+      }
+      const body = await readNoteMarkdown(path);
+      print(revisePersonNote(database, { noteId, expectedRevision, expectedContextSha256, requestId, title: currentTitle, body }), true);
+      return;
+    }
+    if (command === "notes" && subcommand === "history") {
+      const options = [...rest];
+      const noteId = positive(options.shift(), "ID", 0, Number.MAX_SAFE_INTEGER);
+      const before = valueAfter(options, "--before-revision");
+      const limit = positive(valueAfter(options, "--limit"), "--limit", 50, 100);
+      if (options.length)
+        fail3(`Unknown argument: ${options[0]}`);
+      print(listPersonNoteRevisions(database, { noteId, limit, ...before === undefined ? {} : {
+        beforeRevision: positive(before, "--before-revision", 0, Number.MAX_SAFE_INTEGER)
+      } }), true);
+      return;
+    }
     if (command === "notes" && subcommand === "add") {
       const options = [...rest];
       const personIdValue = valueAfter(options, "--person-id") ?? fail3("notes add requires --person-id.");
@@ -24482,14 +26416,14 @@ ${verification}`) });
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
       const payload = from === "-" ? parseGranolaImportJson(await new Response(Bun.stdin).text()) : readGranolaImportFile(resolve6(from));
-      print(importGranolaMeetings(database, payload), true);
+      printImport(importGranolaMeetings(database, payload), true);
       return;
     }
     if (command === "research" && subcommand === "prepare") {
-      const id = positive(rest[0], "PERSON_ID", 0, Number.MAX_SAFE_INTEGER);
+      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, id), true);
+      print(researchTemplate(database, id2), true);
       return;
     }
     if (command === "research" && subcommand === "apply") {
@@ -24519,7 +26453,7 @@ ${verification}`) });
         options.splice(options.indexOf("--preserve"), 1);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(syncAppleContacts(database, {
+      printImport(syncAppleContacts(database, {
         ...contactsDirectory === undefined ? {} : { contactsDirectory },
         ...accountKey5 === undefined ? {} : { accountKey: accountKey5 },
         reconcile: !preserve
@@ -24539,7 +26473,7 @@ ${verification}`) });
       if (withRelationships)
         console.error("Beeper relationships \xB7 deriving a body-free interaction summary through Wrench");
       console.error("Beeper contacts \xB7 discovering connected accounts through Wrench");
-      print(syncBeeperContacts(database, {
+      printImport(syncBeeperContacts(database, {
         authId: effectiveAuthId,
         contactLimit,
         withRelationships,
@@ -24593,7 +26527,7 @@ ${verification}`) });
       const pageSize = positive(valueAfter(options, "--page-size"), "--page-size", 100, 100);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(syncGoogleContacts(database, { ...authId3 === undefined ? {} : { authId: authId3 }, pageSize }), asJson);
+      printImport(syncGoogleContacts(database, { ...authId3 === undefined ? {} : { authId: authId3 }, pageSize }), asJson);
       return;
     }
     if (command === "google" && subcommand === "stats") {
@@ -24609,7 +26543,7 @@ ${verification}`) });
       const pageSize = positive(valueAfter(options, "--page-size"), "--page-size", 1000, 5000);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(syncIMessageRelationships(database, {
+      printImport(syncIMessageRelationships(database, {
         ...messagesDatabase === undefined ? {} : { messagesDatabase },
         ...accountKey5 === undefined ? {} : { accountKey: accountKey5 },
         pageSize
@@ -24623,7 +26557,7 @@ ${verification}`) });
       const interactionPageSize = positive(valueAfter(options, "--interaction-page-size"), "--interaction-page-size", 1000, 1000);
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(syncWhatsAppRelationships(database, {
+      printImport(syncWhatsAppRelationships(database, {
         ...authId3 === undefined ? {} : { authId: authId3 },
         contactPageSize,
         interactionPageSize
@@ -24639,7 +26573,7 @@ ${verification}`) });
       const ownerProfileUrl = valueAfter(options, "--owner-profile-url");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(importLinkedInArchive(database, archive, {
+      printImport(importLinkedInArchive(database, archive, {
         ...accountKey5 === undefined ? {} : { accountKey: accountKey5 },
         ...ownerProfileUrl === undefined ? {} : { ownerProfileUrl }
       }), asJson);
@@ -24659,7 +26593,7 @@ ${verification}`) });
       const accountKey5 = valueAfter(options, "--account");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(await importXArchive(database, archive, { ...accountKey5 === undefined ? {} : { accountKey: accountKey5 } }), asJson);
+      printImport(await importXArchive(database, archive, { ...accountKey5 === undefined ? {} : { accountKey: accountKey5 } }), asJson);
       return;
     }
     if (command === "x" && subcommand === "stats") {
@@ -24677,7 +26611,7 @@ ${verification}`) });
       const accountKey5 = valueAfter(options, "--account");
       if (options.length)
         fail3(`Unknown argument: ${options[0]}`);
-      print(importInstagramArchive(database, archive, { ownerUsername, ...accountKey5 === undefined ? {} : { accountKey: accountKey5 } }), asJson);
+      printImport(importInstagramArchive(database, archive, { ownerUsername, ...accountKey5 === undefined ? {} : { accountKey: accountKey5 } }), asJson);
       return;
     }
     if (command === "instagram" && subcommand === "stats") {
@@ -24700,6 +26634,22 @@ ${usage}`);
   }
 }
 main(process.argv.slice(2)).catch((error) => {
-  console.error(`peopleblade: ${error instanceof Error ? error.message : "unexpected failure"}`);
+  const message = error instanceof Error ? error.message.slice(0, 2000) : "Unexpected failure.";
+  if (process.argv.slice(2).includes("--json")) {
+    console.error(JSON.stringify({
+      schemaVersion: "peopleblade.error.v1",
+      error: {
+        code: error instanceof CliUsageError ? "invalid_arguments" : error instanceof ZodError ? "invalid_input" : error instanceof NoteRevisionError ? error.code : error instanceof CloudEnrichmentReadError ? "enrichment_status_unavailable" : "operation_failed",
+        message,
+        ...error instanceof CloudEnrichmentReadError ? {
+          jobId: error.jobId,
+          dispatchStatus: error.dispatchStatus,
+          nextCommand: error.nextCommand,
+          dispatchRetrySafe: false
+        } : {}
+      }
+    }));
+  } else
+    console.error(`peopleblade: ${message}`);
   process.exitCode = 1;
 });