feat(person-db-resolver, person-resolver), fix(shell-auth): multi-signal matching, observation history, additive email/bio capture

person-db-resolver is the operator tool for resolving event/contact CSVs
into the canonical persons/organizations layer — the core of "Event Prep
and Followup" as an Augment-It use case: import an attendee or prospect
list, resolve each row to a canonical person, capture whatever context
that row carries (org, role, bio, an event tie), and leave a durable trail.
This batch hardens the resolver end-to-end so it holds up against messy
real-world data — CSV rows with only an email, no name; bios with facts
worth keeping; an operator needing to see what's already on file before
adding to it. Proven out against the Aspen Institute Summer Socrates
Seminars attendee list, but the improvements are general to the use case,
not specific to that event.

Person matching now collects from every signal (linkedin_url, email, fuzzy
name) instead of short-circuiting on the first exact hit, so near-matches
still surface as alternatives even after a decisive match. Email is now a
first-class person field: matched additively (never overwrites a
human-verified value already on file), written as a has_email observation,
and used to backfill stub records — including a race-safe path — created by
bulk CLI imports that only ever had an email. Bio text is captured the same
way as has_bio, tied to related_event when the row came from one. A new
person.observations capability (NATS subject + workspace capability wiring)
exposes the append-only observation history read-only, since "editing" a
fact means adding a newer observation, not mutating the old one.

person-db-resolver UI: candidates now show a stub-record affordance (email
or LinkedIn URL when there's no name), the observation column is editable
per-row before it's written, observation history renders under a matched/
created result so the operator sees what's on file before adding to it, and
the row index persists per record-set to localStorage (resume-on-remount +
a manual jump-to-row input) so a mapping session survives an HMR reload or
tab reopen. ColumnMapper and normalize.ts gained email/bio column mapping
to feed all of this.

Small but relevant: dev auto-login (shell/DidiBadge.svelte, shell/
SignInWall.svelte) — setting PUBLIC_DEV_AUTO_LOGIN_EMAIL skips the manual
magic-link click on every stack restart, guarded with sessionStorage rather
than a component-local flag, since sign-in's full-page reload re-mounts the
component and re-nulls any local guard, which was causing an infinite
magic-link loop. dev.sh now starts the sibling id-didi-sh identity service
idempotently before backend/frontend come up, and exports PUBLIC_* vars
from root .env so rsbuild's per-package cwd doesn't hide them from
import.meta.env.

Also included: a set of one-off scripts/surreal-*.mjs operator scripts that
re-match already-resolved Aspen CSV rows to their persons row by identifier
(email > LinkedIn > name) to backfill tags/bio/relevance/x-handle that
predate this commit's resolver changes — necessary because nothing in this
pipeline writes person_uuid back onto the source CSV. build-aspen-tags-
relevance-report.mjs is an early, non-productized sketch of what a
tag/relevance-filtered export view could look like (faceted filter bar,
reuses the FreedomFest report's stylesheet) — a direction, not a shipped
feature. Also filed context-v/issues/Person-DB-Resolver-Needs-Multiple-
Organizations-Per-Person.md as a stub: bios routinely name multiple current/
past affiliations but the UI still only resolves one org per row —
documented, not addressed here.

Files changed:
- apps/person-db-resolver/src/App.svelte
- apps/person-db-resolver/src/app.css
- apps/person-db-resolver/src/components/ColumnMapper.svelte
- apps/person-db-resolver/src/components/PersonCandidateList.svelte
- apps/person-db-resolver/src/lib/normalize.ts
- apps/person-db-resolver/src/lib/resolver-client.ts
- apps/person-db-resolver/src/lib/types.ts
- services/record-surrealdb-resolver/src/person-handlers.ts
- services/record-surrealdb-resolver/src/person-resolver.ts
- services/workspace/src/capabilities.ts
- shell/src/DidiBadge.svelte
- shell/src/SignInWall.svelte
- scripts/dev.sh
- scripts/build-aspen-tags-relevance-report.mjs
- scripts/surreal-add-person-tags.mjs
- scripts/surreal-backfill-bio-observations.mjs
- scripts/surreal-backfill-tags-relevance.mjs
- scripts/surreal-backfill-x-handle.mjs
- scripts/surreal-set-person-bio.mjs
- scripts/surreal-set-person-relevance.mjs
- scripts/surreal-write-event-aspen-summer-socrates.mjs
- context-v/issues/Person-DB-Resolver-Needs-Multiple-Organizations-Per-Person.md

Co-Authored-By: Claude Sonnet 5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_013XVHBYaKTwCYdweGu2bnTU

Author: mpstaton

apps/person-db-resolver/src/App.svelte

@@ -19,6 +19,7 @@
     applyPerson,
     affiliatePerson,
     addPersonObservation,
+    fetchPersonObservations,
     fetchOrgCandidates,
     searchOrgs,
   } from './lib/resolver-client';
@@ -27,6 +28,7 @@
     PersonNormRecord,
     PersonCandidate,
     PersonApplyResult,
+    PersonObservationRow,
     OrgCandidate,
     OrgSuggestion,
     PersonAffiliateResult,
@@ -36,6 +38,11 @@
   const WS_URL = 'ws://localhost:3001/ws';
   const ACTIVE_RECORD_SET_KEY = 'augment-it:active-record-set';
   const MAPPING_KEY_PREFIX = 'augment-it:person-db-resolver:mapping:';
+  // Per-record-set "where I left off" — restored on every selectRecordSet()
+  // (mount, HMR remount, workspace switch, tab reopen), not just typed
+  // navigation. Saved on every idx change so it's always current, not just
+  // on explicit jumps.
+  const IDX_KEY_PREFIX = 'augment-it:person-db-resolver:idx:';
 
   let status = $state<'connecting' | 'open' | 'closed' | 'error'>('connecting');
   let client = $state<string>('reach-edu');
@@ -53,13 +60,30 @@
   let personCandidates = $state<PersonCandidate[]>([]);
   let loadingPerson = $state(false);
   let personError = $state<string | null>(null);
+  // Which action set personError — candidates/match/create all share the
+  // one error slot, but a raw SurrealDB constraint message (e.g. a UNIQUE
+  // index collision on create) reads very differently from a failed
+  // candidate lookup. Labeled at the throw site instead of hardcoded in
+  // the template.
+  let personErrorLabel = $state<'candidates' | 'match' | 'create'>('candidates');
   let personResult = $state<PersonApplyResult | null>(null);
   let personBusy = $state(false);
   let personNameInput = $state('');
+  // Editable mirror of the mapped Observation column — before this, the
+  // event-tie text (e.g. "attendee at Aspen Institute: ...") was parsed and
+  // written silently with zero operator visibility or per-row override.
+  // Same "operator-edited value wins, falls back to the mapped column"
+  // pattern as personNameInput.
+  let personObservationInput = $state('');
   let personSearchQuery = $state('');
   let personSearchResults = $state<PersonCandidate[]>([]);
   let personSearching = $state(false);
   let personSkipped = $state(false);
+  // Read-only history for the matched/created person — observations are
+  // append-only, so this is what makes "editing" sane: see what's on file,
+  // add a correction on top, don't blindly append with no context.
+  let personObservations = $state<PersonObservationRow[]>([]);
+  let personObservationsLoading = $state(false);
 
   let orgCandidates = $state<OrgCandidate[]>([]);
   let loadingOrg = $state(false);
@@ -87,11 +111,17 @@
   );
   const source = $derived(selectedSet ? `record-set:${selectedSet.name}` : 'person-db-resolver');
   // The person actions (candidates/create/match) use the OPERATOR-EDITED
-  // name, not the raw mapped column — record.name stays visible in
-  // RecordCard as "here's what the CSV said," personNameInput is what
-  // actually gets written. Falls back to the mapped name if cleared.
+  // name and observation text, not the raw mapped columns — record stays
+  // visible in RecordCard as "here's what the CSV said," these inputs are
+  // what actually gets written. Falls back to the mapped values if cleared.
   const personRecord = $derived(
-    record ? { ...record, name: personNameInput.trim() || record.name } : null,
+    record
+      ? {
+          ...record,
+          name: personNameInput.trim() || record.name,
+          observation: personObservationInput.trim() || record.observation,
+        }
+      : null,
   );
 
   function onActiveRecordSetChange(e: Event) {
@@ -161,11 +191,34 @@
     try {
       const r = (await workspace.invoke('row.list', { record_set_id })) as { rows: Row[] };
       rows = r.rows.filter((row) => !(row.fields as Record<string, unknown>).archived);
+      // Resume where this record set was left off — mount, HMR remount,
+      // workspace switch, or tab reopen all land here via the same path.
+      const stored = typeof localStorage !== 'undefined' ? localStorage.getItem(`${IDX_KEY_PREFIX}${record_set_id}`) : null;
+      if (stored != null) {
+        const n = Number(stored);
+        if (Number.isFinite(n)) idx = Math.min(Math.max(0, n), Math.max(0, rows.length - 1));
+      }
     } catch (err) {
       console.error('row.list', err);
     }
   }
 
+  function saveIdx() {
+    if (selectedRecordSetId && typeof localStorage !== 'undefined') {
+      localStorage.setItem(`${IDX_KEY_PREFIX}${selectedRecordSetId}`, String(idx));
+    }
+  }
+
+  // Manual "jump to row N" — accepts 1-based row numbers (matches the
+  // "N / total" display), clamps to the valid range.
+  function jumpTo(raw: string | number) {
+    const n = typeof raw === 'number' ? raw : Number(raw);
+    if (!Number.isFinite(n) || rows.length === 0) return;
+    idx = Math.min(Math.max(0, Math.round(n) - 1), rows.length - 1);
+    resetRowState();
+    saveIdx();
+  }
+
   function loadMapping(record_set_id: string) {
     const key = `${MAPPING_KEY_PREFIX}${record_set_id}`;
     const stored = typeof localStorage !== 'undefined' ? localStorage.getItem(key) : null;
@@ -197,6 +250,7 @@
     personSkipped = false;
     personSearchQuery = '';
     personSearchResults = [];
+    personObservations = [];
     orgCandidates = [];
     orgError = null;
     orgResult = null;
@@ -226,6 +280,7 @@
       return;
     }
     personNameInput = rec.name;
+    personObservationInput = rec.observation ?? '';
     void loadPersonCandidatesFor(rec);
   });
 
@@ -236,6 +291,7 @@
     try {
       personCandidates = await fetchPersonCandidates(rec, client);
     } catch (err) {
+      personErrorLabel = 'candidates';
       personError = err instanceof Error ? err.message : String(err);
       personCandidates = [];
     } finally {
@@ -287,13 +343,27 @@
     await loadOrgCandidatesFor(orgNameInput);
   }
 
+  async function loadPersonObservations(person_uuid: string) {
+    personObservationsLoading = true;
+    try {
+      personObservations = await fetchPersonObservations(person_uuid, client);
+    } catch (err) {
+      console.error('person.observations', err);
+      personObservations = [];
+    } finally {
+      personObservationsLoading = false;
+    }
+  }
+
   async function doMatchPerson(c: PersonCandidate) {
     if (!personRecord) return;
     personBusy = true;
     personError = null;
     try {
       personResult = await applyPerson({ action: 'match', person_uuid: c.person_uuid, record: personRecord, client, source });
+      void loadPersonObservations(personResult.person_uuid);
     } catch (err) {
+      personErrorLabel = 'match';
       personError = err instanceof Error ? err.message : String(err);
     } finally {
       personBusy = false;
@@ -306,7 +376,9 @@
     personError = null;
     try {
       personResult = await applyPerson({ action: 'create', record: personRecord, client, source });
+      void loadPersonObservations(personResult.person_uuid);
     } catch (err) {
+      personErrorLabel = 'create';
       personError = err instanceof Error ? err.message : String(err);
     } finally {
       personBusy = false;
@@ -423,6 +495,7 @@
       obsSaved = true;
       obsPredicate = '';
       obsValue = '';
+      void loadPersonObservations(personResult.person_uuid);
     } catch (err) {
       obsError = err instanceof Error ? err.message : String(err);
     } finally {
@@ -433,10 +506,12 @@
   function advance() {
     idx = Math.min(idx + 1, rows.length);
     resetRowState();
+    saveIdx();
   }
   function back() {
     idx = Math.max(0, idx - 1);
     resetRowState();
+    saveIdx();
   }
   function skipRow() {
     advance();
@@ -463,7 +538,18 @@
         {/each}
       </select>
       {#if rows.length}
-        <span class="pdr-progress">{Math.min(idx + 1, rows.length)} / {rows.length}</span>
+        <span class="pdr-progress">
+          <input
+            type="number"
+            class="pdr-jump"
+            min="1"
+            max={rows.length}
+            value={Math.min(idx + 1, rows.length)}
+            title="jump to row"
+            onchange={(e) => jumpTo(e.currentTarget.value)}
+            onkeydown={(e) => { if (e.key === 'Enter') e.currentTarget.blur(); }}
+          /> / {rows.length}
+        </span>
         <button type="button" class="pdr-btn" onclick={() => (showMapper = true)}>edit column mapping</button>
       {/if}
     </div>
@@ -489,13 +575,22 @@
             <span class="pdr-eyebrow">person</span>
             {#if loadingPerson}<span class="pdr-muted">finding candidates…</span>{/if}
           </div>
-          {#if personError}<div class="pdr-error">candidates: {personError}</div>{/if}
+          {#if personError}<div class="pdr-error">{personErrorLabel}: {personError}</div>{/if}
 
           {#if !personResult && !personSkipped}
             <label class="pdr-org-name-row">
               <span>person name</span>
               <input type="text" bind:value={personNameInput} onchange={() => void loadPersonCandidates()} placeholder="Person name" />
             </label>
+            <label class="pdr-org-name-row">
+              <span>observation (event tie)</span>
+              <input
+                type="text"
+                bind:value={personObservationInput}
+                placeholder="e.g. attendee at Event Name"
+                title="Written as a parsed event-tie observation on create/match. Edit or clear before resolving this row."
+              />
+            </label>
             <PersonCandidateList candidates={personCandidates} busy={personBusy} onMatch={doMatchPerson} />
             <div class="pdr-create">
               <button type="button" class="pdr-btn pdr-btn-create" disabled={personBusy || !personRecord?.name} onclick={doCreatePerson}>
@@ -537,6 +632,25 @@
               <div class="pdr-result-head">
                 {personResult.created ? '✓ created' : '✓ matched'} <strong>{personResult.name}</strong>
               </div>
+              <details class="pdr-search" open>
+                <summary>
+                  observation history{personObservationsLoading ? ' — loading…' : ` (${personObservations.length})`}
+                </summary>
+                {#if !personObservationsLoading && personObservations.length === 0}
+                  <p class="pdr-muted">nothing on file yet.</p>
+                {:else}
+                  <ul class="pdr-search-results">
+                    {#each personObservations as o (o.predicate + String(o.observed_at) + String(o.object))}
+                      <li>
+                        <span>
+                          <strong>{o.predicate}</strong>: {String(o.object)}
+                          <span class="pdr-muted"> — {new Date(o.observed_at).toLocaleString()} · {o.source}</span>
+                        </span>
+                      </li>
+                    {/each}
+                  </ul>
+                {/if}
+              </details>
               <div class="pdr-add-obs">
                 <label><span>predicate (optional)</span><input type="text" bind:value={obsPredicate} placeholder="defaults to 'note'" /></label>
                 <label><span>value</span><input type="text" bind:value={obsValue} placeholder="e.g. confirmed 2026-07-07" /></label>

apps/person-db-resolver/src/app.css

@@ -21,7 +21,8 @@
 .pdr-setpick { display: flex; align-items: center; gap: 0.5rem; margin-top: 0.5rem; font-size: 0.85rem; }
 .pdr-setpick label { color: var(--color-text-muted, #9aa0aa); }
 .pdr-setpick select { background: var(--color-surface, #1c1e25); color: inherit; border: 1px solid var(--color-border, #2a2c33); border-radius: 4px; padding: 0.3rem 0.5rem; min-width: 18rem; }
-.pdr-progress { margin-left: auto; color: var(--color-text-muted, #9aa0aa); font-variant-numeric: tabular-nums; }
+.pdr-progress { margin-left: auto; color: var(--color-text-muted, #9aa0aa); font-variant-numeric: tabular-nums; display: flex; align-items: center; gap: 0.3rem; }
+.pdr-jump { width: 3.5rem; background: var(--color-surface, #1c1e25); color: inherit; border: 1px solid var(--color-border, #2a2c33); border-radius: 4px; padding: 0.25rem 0.4rem; font: inherit; font-variant-numeric: tabular-nums; text-align: right; }
 
 .pdr-body { margin-top: 1rem; }
 .pdr-grid { display: grid; grid-template-columns: 1fr 1fr; gap: 1rem; align-items: start; }

apps/person-db-resolver/src/components/ColumnMapper.svelte

@@ -31,6 +31,8 @@
     { key: 'role', label: 'Role / title', required: false },
     { key: 'linkedin_url', label: 'LinkedIn URL', required: false },
     { key: 'observation', label: 'Observation (event tie)', required: false },
+    { key: 'email', label: 'Email', required: false },
+    { key: 'bio', label: 'Bio', required: false },
   ];
 
   function save() {

apps/person-db-resolver/src/components/PersonCandidateList.svelte

@@ -22,8 +22,15 @@
       <li class="pdr-candidate">
         <div class="pdr-candidate-head">
           <div class="pdr-candidate-id">
-            <span class="pdr-candidate-name">{c.name || '(no name)'}</span>
+            <span class="pdr-candidate-name">
+              {c.name || c.email || c.linkedin_profile_url || '(no identifying info on this record)'}
+            </span>
             {#if c.headline}<span class="pdr-candidate-headline">{c.headline}</span>{/if}
+            {#if !c.name}
+              <span class="pdr-candidate-headline">
+                stub record — no name on file{c.email ? `, matched by email` : c.linkedin_profile_url ? `, matched by LinkedIn URL` : ''}
+              </span>
+            {/if}
           </div>
           <div class="pdr-candidate-score">
             <span class="pdr-score" data-tier={c.score >= 90 ? 'high' : c.score >= 60 ? 'mid' : 'low'}>{c.score}</span>

apps/person-db-resolver/src/lib/normalize.ts

@@ -24,6 +24,8 @@ export function normalizePersonRecord(
     role: get(mapping.role) || null,
     linkedin_url: get(mapping.linkedin_url) || null,
     observation: get(mapping.observation) || null,
+    email: get(mapping.email) || null,
+    bio: get(mapping.bio) || null,
   };
 }
 
@@ -37,6 +39,8 @@ const GUESSES: Record<keyof FieldMapping, string[]> = {
   role: ['title', 'role', 'Title', 'Role'],
   linkedin_url: ['linkedin_url', 'linkedin', 'profile_url', 'LinkedIn'],
   observation: ['observation', 'Observation'],
+  email: ['email', 'Email', 'email_address', 'Email Address'],
+  bio: ['bio', 'Bio', 'biography', 'Biography'],
 };
 
 export function guessMapping(columns: string[]): FieldMapping {
@@ -52,6 +56,8 @@ export function guessMapping(columns: string[]): FieldMapping {
     role: pick('role'),
     linkedin_url: pick('linkedin_url'),
     observation: pick('observation'),
+    email: pick('email'),
+    bio: pick('bio'),
   };
 }
 

apps/person-db-resolver/src/lib/resolver-client.ts

@@ -11,6 +11,7 @@ import type {
   PersonCandidate,
   PersonApplyResult,
   PersonAffiliateResult,
+  PersonObservationRow,
   OrgCandidate,
   OrgSuggestion,
 } from './types';
@@ -78,6 +79,19 @@ export async function addPersonObservation(args: {
   if (!r.ok) throw new Error(r.error || 'person.add_observation failed');
 }
 
+export async function fetchPersonObservations(
+  person_uuid: string,
+  client: string,
+): Promise<PersonObservationRow[]> {
+  const r = (await workspace.invoke('person.observations', { person_uuid, client })) as {
+    ok: boolean;
+    observations?: PersonObservationRow[];
+    error?: string;
+  };
+  if (!r.ok) throw new Error(r.error || 'person.observations failed');
+  return r.observations ?? [];
+}
+
 // Org side — reuses record-db-resolver's own capabilities, fed a synthetic
 // {name: org_name} record. No url/socials, so append_preview will always be
 // empty; that's fine, this app never shows or uses it.

apps/person-db-resolver/src/lib/types.ts

@@ -8,13 +8,23 @@ export type PersonNormRecord = {
   org_name?: string | null;
   role?: string | null;
   observation?: string | null;
+  email?: string | null;
+  bio?: string | null;
+};
+
+export type PersonObservationRow = {
+  predicate: string;
+  object: unknown;
+  observed_at: string;
+  source: string;
 };
 
 export type PersonCandidate = {
   person_uuid: string;
   name: string | null;
   headline: string | null;
   linkedin_profile_url: string | null;
+  email: string | null;
   score: number;
   match_reason: string[];
 };
@@ -65,4 +75,6 @@ export type FieldMapping = {
   role: string;
   linkedin_url: string;
   observation: string;
+  email: string;
+  bio: string;
 };