@gotcos/glasses-server 6.44.13 → 6.44.15

package/CHANGELOG.md

@@ -1,3 +1,63 @@
+## 6.44.15
+
+Voice profiles named after a spoken sentence are repaired at load.
+
+- Chelsie 2026-09-08: her `voice-profiles.json` held two profiles whose name
+  was the entire enrolment speech ("My Voice My Name Is Chelsie Hodgkiss And I
+  Am The Director…", ~600 characters), written by a client older than the
+  8/25 guards. Speaker ID was "active" and could never match anything, and the
+  file cannot be repaired by hand because the server rewrites it from memory.
+- `normalizeProfileStore` now renames a name that is too long, has more than
+  four words, or is three-plus words with sentence punctuation to
+  `Unnamed voice N`, keeps every embedding and its provenance, records
+  `renamedFrom` (the first 60 characters) and `needsName: true`, and counts it
+  in the load repairs (`profilesRenamed`). Legacy short labels ("MU",
+  "Speaker 2", "Luke H.") are never touched. `GET /api/voice/profiles` carries
+  `needsName` and `renamedFrom` so COS Control's speaker review can offer the
+  rename; `POST /api/voice/merge-profiles` folds the placeholder into the
+  right person as before.
+
+## 6.44.14
+
+The Manage sheet's merge, with a preview, a worker and a receipt, plus a
+duplicates scan that proposes and never merges.
+
+- Miles 2026-09-08: "Build the Manage merge path with the preview", and
+  "address any of the obvious duplicates like the miels and queen example
+  from above without clobbering entities. You did good in deflecting miles
+  mallard vs the other miles profiles."
+- `POST /api/context/graph/merge/preview` `{ source, target }`: both entities
+  from this Mac's index, shared neighbors, the effect (relationships moved and
+  collapsed, texts re-embedded, about how long), a name signal, warnings
+  (types differ, larger into smaller, nothing links them, a large merge), and
+  `blocked` with its reason for a pair the graph knows to be different people
+  (Miles Ukaoma / Miles Mallard, Manoj Bisht / Manoj Kumar, the Kyles, the
+  Jacobuses, and any pair the user kept apart).
+- `POST /api/context/graph/merge` `{ source, target, confirm: true, rule? }`:
+  starts ONE detached worker on the ingestion owner and answers 202 with a
+  ticket and the receipt. The worker takes the exclusive ingest lock, copies
+  the GraphML aside, runs LightRAG's own entity merge (no deprecated strategy
+  argument), appends a curation ledger row, rebuilds the per-Mac index and
+  the Observatory export, and stamps its receipt at every step. Measured: the
+  hand merges of 2026-09-08 took about two minutes, so this is never a request.
+  Without `confirm` the answer is 400 `confirmation_required` with the preview;
+  409 `merge_blocked`, `merge_running`, `lock_held`, `not_owner`, or
+  `embedding_not_ready` (a merge re-embeds 1 + degree texts).
+- `GET /api/context/graph/merge`: the receipt with the worker's log tail. A
+  worker that died reads as failed with the snapshot intact, never as running.
+- `GET /api/context/graph/duplicates?limit=`: person entities whose names are
+  variants of one another (same first name with a surname within two letters,
+  whole names within two letters, one name spelling out the other, a bare
+  first name that matches exactly one full name), grouped under the full name
+  with the most connections, with shared-neighbor counts and a confidence.
+  Possessives ("Miles Ukaoma's Son") and ambiguous first names are left alone;
+  blocked pairs never share a group. Nothing here merges.
+- Four bridge commands: `graph-merge-preview`, `graph-merge`,
+  `graph-merge-status`, `graph-duplicates` (28 in the parity set).
+- Test: the 6.44.13 guardrails-run pin expected a zone-less `created_at` to
+  read as null; the normalizer has always passed a parseable timestamp through,
+  and the pin failed at HEAD. Corrected to the passed-through value.
+
 ## 6.44.13
 
 Prune or accept a captured memory, and guardrails that prune nonsense for you.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.44.13",
+  "version": "6.44.15",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {

package/server/lib/cos-context-browser.ts

@@ -1121,3 +1121,120 @@ export function normalizeContextBrowserStatus(value: unknown): ContextBrowserSta
     ...(graph ? { graph } : {}),
   }
 }
+
+// ── Curation (6.44.14): merge preview, the merge worker's receipt, duplicate proposals ──
+
+export const MERGE_NAME_LIMIT = 200
+export const DUPLICATES_LIMIT_MAX = 100
+export const MERGE_RECEIPT_STATES = ['running', 'merging', 'indexing', 'exporting', 'done', 'failed'] as const
+export type MergeReceiptState = typeof MERGE_RECEIPT_STATES[number]
+
+function entityCard(value: unknown, fallbackId: string): Record<string, unknown> {
+  const r = asRecord(value) ?? {}
+  return {
+    id: stringOrAbsent(r.id, MERGE_NAME_LIMIT) ?? fallbackId,
+    found: r.found === true,
+    type: stringOrAbsent(r.type, 40) ?? null,
+    degree: integerOrAbsent(r.degree) ?? 0,
+    descriptions: (Array.isArray(r.descriptions) ? r.descriptions : []).filter((d): d is string => typeof d === 'string').map(d => cleanContextText(d, 300)).filter(Boolean).slice(0, 3),
+    description_count: integerOrAbsent(r.description_count) ?? 0,
+    created_at: integerOrAbsent(r.created_at) ?? null,
+  }
+}
+
+/** `graph-merge-preview`: what a merge would do, read from the index. `blocked` wins over every warning. */
+export function normalizeMergePreview(value: unknown, source = '', target = ''): Record<string, unknown> {
+  const s = asRecord(value) ?? {}
+  const effect = asRecord(s.effect)
+  return {
+    available: s.available === true,
+    index_state: stringOrAbsent(s.index_state, 20) ?? 'missing',
+    index_built_at: isoOrAbsent(s.index_built_at) ?? null,
+    source: entityCard(s.source, source),
+    target: entityCard(s.target, target),
+    shared_neighbors: (Array.isArray(s.shared_neighbors) ? s.shared_neighbors : []).filter((n): n is string => typeof n === 'string').map(n => cleanContextText(n, MERGE_NAME_LIMIT)).filter(Boolean).slice(0, 10),
+    shared_count: integerOrAbsent(s.shared_count) ?? 0,
+    adjacent: s.adjacent === true,
+    effect: effect ? { moved: integerOrAbsent(effect.moved) ?? 0, collapsed: integerOrAbsent(effect.collapsed) ?? 0, embeddings: integerOrAbsent(effect.embeddings) ?? 0, estimated_seconds: integerOrAbsent(effect.estimated_seconds) ?? null } : null,
+    name_signal: stringOrAbsent(s.name_signal, 80) ?? null,
+    blocked: s.blocked === true,
+    block_reason: stringOrAbsent(s.block_reason, 300) ?? null,
+    warnings: (Array.isArray(s.warnings) ? s.warnings : []).flatMap((w) => {
+      const r = asRecord(w); const code = r ? stringOrAbsent(r.code, 40) : undefined; const text = r ? stringOrAbsent(r.text, 300) : undefined
+      return code && text ? [{ code, text }] : []
+    }).slice(0, 8),
+  }
+}
+
+/** The worker's receipt: one merge per Mac at a time, every step stamped. */
+export function normalizeMergeReceipt(value: unknown): Record<string, unknown> | null {
+  const r = asRecord(value)
+  if (!r) return null
+  const state = typeof r.state === 'string' && (MERGE_RECEIPT_STATES as readonly string[]).includes(r.state) ? r.state as MergeReceiptState : null
+  if (!state) return null
+  const before = asRecord(r.before); const after = asRecord(r.after)
+  return {
+    ticket: stringOrAbsent(r.ticket, 40) ?? null,
+    state,
+    step: stringOrAbsent(r.step, 20) ?? null,
+    source: stringOrAbsent(r.source, MERGE_NAME_LIMIT) ?? null,
+    target: stringOrAbsent(r.target, MERGE_NAME_LIMIT) ?? null,
+    by: stringOrAbsent(r.by, 40) ?? null,
+    pid: integerOrAbsent(r.pid) ?? null,
+    started_at: isoOrAbsent(r.started_at) ?? null,
+    finished_at: isoOrAbsent(r.finished_at) ?? null,
+    elapsed_s: typeof r.elapsed_s === 'number' && Number.isFinite(r.elapsed_s) ? r.elapsed_s : null,
+    before: before ? { source: integerOrAbsent(before.source) ?? null, target: integerOrAbsent(before.target) ?? null } : null,
+    after: after ? { target: integerOrAbsent(after.target) ?? null, source_present: after.source_present === true } : null,
+    embedded_texts: integerOrAbsent(r.embedded_texts) ?? null,
+    snapshot: stringOrAbsent(r.snapshot, 400) ?? null,
+    rule: asRecord(r.rule) ? { scope: stringOrAbsent((r.rule as Record<string, unknown>).scope, 40) ?? null, pattern: stringOrAbsent((r.rule as Record<string, unknown>).pattern, MERGE_NAME_LIMIT) ?? null, replacement: stringOrAbsent((r.rule as Record<string, unknown>).replacement, MERGE_NAME_LIMIT) ?? null } : null,
+    error: stringOrAbsent(r.error, 400) ?? null,
+    export_note: stringOrAbsent(r.export_note, 200) ?? null,
+  }
+}
+
+/** `graph-merge` (202) and `graph-merge-status`: the receipt plus the worker's log tail. */
+export function normalizeMergeStatus(value: unknown): Record<string, unknown> {
+  const s = asRecord(value) ?? {}
+  return {
+    running: s.running === true,
+    receipt: normalizeMergeReceipt(s.receipt),
+    log_tail: (Array.isArray(s.log_tail) ? s.log_tail : []).filter((l): l is string => typeof l === 'string').map(l => l.slice(0, 300)).slice(-24),
+  }
+}
+
+export function normalizeMergeKickoff(value: unknown): Record<string, unknown> {
+  const s = asRecord(value) ?? {}
+  return {
+    started: s.started === true,
+    ticket: stringOrAbsent(s.ticket, 40) ?? null,
+    pid: integerOrAbsent(s.pid) ?? null,
+    estimated_seconds: integerOrAbsent(s.estimated_seconds) ?? null,
+    receipt: normalizeMergeReceipt(s.receipt),
+  }
+}
+
+/** `graph-duplicates`: person entities whose names look like one person. Proposals, never merges. */
+export function normalizeDuplicates(value: unknown): Record<string, unknown> {
+  const s = asRecord(value) ?? {}
+  const groups = (Array.isArray(s.groups) ? s.groups : []).flatMap((g) => {
+    const r = asRecord(g); const target = r ? stringOrAbsent(r.target, MERGE_NAME_LIMIT) : undefined
+    if (!r || !target) return []
+    const members = (Array.isArray(r.members) ? r.members : []).flatMap((m) => {
+      const mr = asRecord(m); const id = mr ? stringOrAbsent(mr.id, MERGE_NAME_LIMIT) : undefined
+      if (!mr || !id) return []
+      return [{ id, degree: integerOrAbsent(mr.degree) ?? 0, shared_neighbors: integerOrAbsent(mr.shared_neighbors) ?? 0, description: stringOrAbsent(mr.description, 300) ?? '', why: stringOrAbsent(mr.why, 80) ?? null }]
+    }).slice(0, 6)
+    const confidence = r.confidence === 'high' || r.confidence === 'medium' || r.confidence === 'low' ? r.confidence : 'low'
+    return members.length >= 2 ? [{ target, members, confidence, reasons: (Array.isArray(r.reasons) ? r.reasons : []).filter((x): x is string => typeof x === 'string').map(x => cleanContextText(x, 80)).slice(0, 6), linked: r.linked === true }] : []
+  }).slice(0, DUPLICATES_LIMIT_MAX)
+  return {
+    available: s.available === true,
+    index_state: stringOrAbsent(s.index_state, 20) ?? 'missing',
+    index_built_at: isoOrAbsent(s.index_built_at) ?? null,
+    scanned: integerOrAbsent(s.scanned) ?? 0,
+    total_groups: integerOrAbsent(s.total_groups) ?? groups.length,
+    groups,
+  }
+}

package/server/lib/python-bridge.ts

@@ -70,6 +70,10 @@ export const LEARNING_COMMANDS = [
   'memory-review',
   'memory-guardrails',
   'memory-guardrails-run',
+  'graph-merge-preview',
+  'graph-merge',
+  'graph-merge-status',
+  'graph-duplicates',
 ] as const
 
 // The optional Python bridge is available only when the user points us at a real
@@ -256,6 +260,10 @@ function standaloneNoop(args: string[]): unknown {
     case 'memory-review':
     case 'memory-guardrails':
     case 'memory-guardrails-run':
+    case 'graph-merge-preview':
+    case 'graph-merge':
+    case 'graph-merge-status':
+    case 'graph-duplicates':
       return { error: 'cos_pipeline_not_configured' }
     case 'task-rows':
     case 'task-capture':

package/server/lib/voice-profile-store.ts

@@ -11,6 +11,7 @@
 // by execution rather than by asserting on source text. speaker-embeddings.ts
 // delegates to it and keeps the sherpa-onnx manager in sync.
 
+import { checkSpeakerName, type SpeakerNameRejection } from './speaker-name.js'
 import { existsSync, mkdirSync, readdirSync, statSync, unlinkSync } from 'node:fs'
 import { basename, dirname, join, resolve } from 'node:path'
 import { durableAtomicWriteFileSync, loadJsonOrQuarantine } from './atomic-fs.js'
@@ -21,6 +22,12 @@ export interface VoiceProfile {
   embeddings: number[][]
   /** Provenance: 'manual' | 'fireflies' | 'g2-training' | 'auto:<sessionId>' | … */
   sources?: string[]
+  /** The name on disk was a spoken sentence, not a name (an old client's
+   *  "enroll my voice" fall-through); it was renamed at load and the training
+   *  kept. COS Control's speaker review shows it for renaming. */
+  needsName?: boolean
+  /** The first 60 characters of the name it was loaded with. */
+  renamedFrom?: string
 }
 
 export interface ProfileStore {
@@ -42,6 +49,9 @@ export interface StoreRepairs {
   dimensionMismatch: number
   /** Entries with no usable name, or duplicate names collapsed. */
   profilesDropped: number
+  /** Names that were a whole spoken sentence (too long, too many words, or
+   *  sentence punctuation), renamed to `Unnamed voice N` with the training kept. */
+  profilesRenamed: number
 }
 
 export function emptyRepairs(): StoreRepairs {
@@ -51,17 +61,19 @@ export function emptyRepairs(): StoreRepairs {
     embeddingsDropped: 0,
     dimensionMismatch: 0,
     profilesDropped: 0,
+    profilesRenamed: 0,
   }
 }
 
 export function hasRepairs(r: StoreRepairs): boolean {
   return r.sourcesRealigned > 0 || r.sourcesCoerced > 0 || r.embeddingsDropped > 0
-    || r.dimensionMismatch > 0 || r.profilesDropped > 0
+    || r.dimensionMismatch > 0 || r.profilesDropped > 0 || r.profilesRenamed > 0
 }
 
 export function describeRepairs(r: StoreRepairs): string {
   const parts: string[] = []
   if (r.profilesDropped) parts.push(`${r.profilesDropped} unusable profile(s)`)
+  if (r.profilesRenamed) parts.push(`${r.profilesRenamed} profile(s) named after a spoken sentence, renamed for review`)
   if (r.embeddingsDropped) parts.push(`${r.embeddingsDropped} unusable embedding row(s)`)
   if (r.sourcesRealigned) parts.push(`${r.sourcesRealigned} profile(s) with misaligned sources[]`)
   if (r.sourcesCoerced) parts.push(`${r.sourcesCoerced} null/non-string source slot(s)`)
@@ -106,11 +118,27 @@ export function normalizeProfileStore(raw: unknown): { store: ProfileStore; repa
   if (!Array.isArray(rawProfiles)) return { store: { profiles: [] }, repairs }
 
   const byName = new Map<string, VoiceProfile>()
+  let unnamed = 0
   for (const candidate of rawProfiles) {
-    const name = typeof (candidate as VoiceProfile)?.name === 'string'
+    const rawName = typeof (candidate as VoiceProfile)?.name === 'string'
       ? (candidate as VoiceProfile).name.trim()
       : ''
-    if (!name) { repairs.profilesDropped++; continue }
+    if (!rawName) { repairs.profilesDropped++; continue }
+    // Chelsie's store (2026-09-08) held two profiles named with the entire
+    // enrolment speech (~600 characters), written by a client older than the
+    // 6.8.433 / server 8/25 guards. A name like that can never match a speaker
+    // label, and the file cannot be repaired by hand because the server
+    // rewrites it from memory. Keep the training, give it a placeholder name,
+    // and flag it so COS Control offers a rename. Only the sentence shapes are
+    // renamed; legacy short labels ("MU", "Speaker 2") are left exactly as is.
+    const junk = junkNameReason(rawName)
+    let renamedFrom: string | undefined
+    let name = rawName
+    if (junk) {
+      do { name = `Unnamed voice ${++unnamed}` } while (byName.has(name) || rawProfiles.some(p => (p as VoiceProfile)?.name === name))
+      renamedFrom = rawName.slice(0, 60)
+      repairs.profilesRenamed++
+    }
 
     const rawEmbeddings = Array.isArray((candidate as VoiceProfile).embeddings)
       ? (candidate as VoiceProfile).embeddings as unknown[]
@@ -154,12 +182,23 @@ export function normalizeProfileStore(raw: unknown): { store: ProfileStore; repa
       existing.sources!.push(...sources)
       continue
     }
-    byName.set(name, { name, embeddings, sources })
+    byName.set(name, { name, embeddings, sources, ...(renamedFrom ? { needsName: true, renamedFrom } : {}) })
   }
 
   return { store: { profiles: [...byName.values()] }, repairs }
 }
 
+/** The sentence shapes only: too long, too many words, or sentence punctuation. */
+export function junkNameReason(name: string): SpeakerNameRejection | null {
+  const check = checkSpeakerName(name, { ownerLabel: name })
+  if (check.ok) return null
+  if (check.reason === 'too_long' || check.reason === 'too_many_words') return check.reason
+  // Sentence punctuation alone is not enough: "Luke H." is a legitimate legacy
+  // alias. Three or more words with punctuation is speech, not a name.
+  if (check.reason === 'sentence_like' && name.trim().split(/\s+/).length >= 3) return check.reason
+  return null
+}
+
 export type StoreLoad = {
   store: ProfileStore
   repairs: StoreRepairs

package/server/routes/memory.ts

@@ -34,6 +34,12 @@ import { normalizeReviewDecision, LEARNING_REVIEW_LIMIT,
   normalizeExtractionBlock,
   normalizeGuardrails,
   normalizeGuardrailsRun,
+  normalizeMergePreview,
+  normalizeMergeStatus,
+  normalizeMergeKickoff,
+  normalizeDuplicates,
+  MERGE_NAME_LIMIT,
+  DUPLICATES_LIMIT_MAX,
   EMBEDDING_PROVIDERS,
   EXTRACTION_TIERS,
   KNOWLEDGE_SETUP_SAMPLE_MAX,
@@ -289,6 +295,106 @@ memoryRouter.post('/context/memory-guardrails/run', async (req, res) => {
   }
 })
 
+// ── Curation (6.44.14): the Manage sheet's merge, with a preview, a worker and a receipt ──
+//
+// Miles 2026-09-08: "Build the Manage merge path with the preview" and "address any of
+// the obvious duplicates like the miels and queen example without clobbering entities."
+// The merge is a DETACHED worker: the two hand merges of 2026-09-08 took ~2 minutes of
+// vector-store rewriting, far past any request budget. The kickoff answers 202 with a
+// ticket; GET /context/graph/merge is the receipt to poll. Two people the graph knows
+// to be different (Miles Ukaoma / Miles Mallard) come back 409 merge_blocked.
+
+function mergeNames(body: unknown): { source: string; target: string } | null {
+  const b = (body ?? {}) as { source?: unknown; target?: unknown }
+  const source = typeof b.source === 'string' ? b.source.trim() : ''
+  const target = typeof b.target === 'string' ? b.target.trim() : ''
+  if (source.length < 1 || source.length > MERGE_NAME_LIMIT || target.length < 1 || target.length > MERGE_NAME_LIMIT) return null
+  return { source, target }
+}
+
+/** `{ source, target }` → what the merge would do. Read-only; a blocked pair answers 200 with `blocked: true`. */
+memoryRouter.post('/context/graph/merge/preview', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const names = mergeNames(req.body)
+  if (!names) { res.status(400).json({ error: 'invalid_entity', message: `source and target must be 1 to ${MERGE_NAME_LIMIT} characters` }); return }
+  try {
+    const data = await callPython(['graph-merge-preview', `--source=${names.source}`, `--target=${names.target}`], 20_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    res.json(normalizeMergePreview(data, names.source, names.target))
+  } catch (error) {
+    console.warn('[context] merge preview bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/**
+ * `{ source, target, confirm: true, rule? }` → start the merge worker on the owner Mac; 202 with the ticket and receipt.
+ * Without `confirm: true` the answer is 400 confirmation_required with the preview. 409 when the pair is blocked, a merge
+ * is already running, the ingest lock is held, this is a replica, or the chosen embedding cannot embed right now.
+ */
+memoryRouter.post('/context/graph/merge', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const names = mergeNames(req.body)
+  if (!names) { res.status(400).json({ error: 'invalid_entity', message: `source and target must be 1 to ${MERGE_NAME_LIMIT} characters` }); return }
+  const body = (req.body ?? {}) as { confirm?: unknown; rule?: unknown }
+  if (body.confirm !== undefined && typeof body.confirm !== 'boolean') { res.status(400).json({ error: 'invalid_confirm', message: 'confirm must be true or false' }); return }
+  if (body.rule !== undefined && body.rule !== null && (typeof body.rule !== 'object' || Array.isArray(body.rule))) { res.status(400).json({ error: 'invalid_rule', message: 'rule must be an object' }); return }
+  const argv = ['graph-merge', `--source=${names.source}`, `--target=${names.target}`, '--by=control']
+  if (body.confirm === true) argv.push('--confirm')
+  if (body.rule && typeof body.rule === 'object') {
+    const r = body.rule as Record<string, unknown>
+    const rule: Record<string, string> = {}
+    for (const key of ['scope', 'pattern', 'replacement']) if (typeof r[key] === 'string') rule[key] = (r[key] as string).slice(0, MERGE_NAME_LIMIT)
+    argv.push(`--rule=${JSON.stringify(rule)}`)
+  }
+  try {
+    // 20 s: the kickoff reads the index and probes the embedding, then spawns and answers.
+    const data = await callPython(argv, 20_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    res.status(202).json(normalizeMergeKickoff(data))
+  } catch (error) {
+    console.warn('[context] merge bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/** The current or last merge's receipt with the worker's log tail. A dead worker reads as failed, never as running. */
+memoryRouter.get('/context/graph/merge', async (_req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  try {
+    const data = await callPython(['graph-merge-status'], 10_000)
+    const code = bridgeErrorCode(data)
+    if (code) { res.status(503).json({ error: code }); return }
+    res.json(normalizeMergeStatus(data))
+  } catch (error) {
+    console.warn('[context] merge status bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
+/** `?limit=` → person entities whose names look like one person, grouped with a confidence. Proposals only. */
+memoryRouter.get('/context/graph/duplicates', async (req, res) => {
+  noStore(res)
+  if (!contextConfigured()) { res.status(503).json({ error: pythonBridgeState() }); return }
+  const raw = req.query.limit
+  const limit = raw === undefined ? 25 : Number(raw)
+  if (!Number.isInteger(limit) || limit < 1 || limit > DUPLICATES_LIMIT_MAX) { res.status(400).json({ error: 'invalid_limit', message: `limit must be an integer from 1 to ${DUPLICATES_LIMIT_MAX}` }); return }
+  try {
+    const data = await callPython(['graph-duplicates', `--limit=${limit}`], 30_000)
+    const code = bridgeErrorCode(data)
+    if (code) { sendSetupError(res, code, data); return }
+    res.json(normalizeDuplicates(data))
+  } catch (error) {
+    console.warn('[context] duplicates bridge failure:', (error as Error).message)
+    res.status(503).json({ error: 'graph_unavailable' })
+  }
+})
+
 memoryRouter.get('/context/learning/:id', async (req, res) => {
   noStore(res)
   if (!LEARNING_EVENT_ID_PATTERN.test(req.params.id)) { res.status(400).json({ error: 'invalid_event_id' }); return }
@@ -467,6 +573,19 @@ function sendSetupError(res: import('express').Response, code: string, data: unk
   const detail = asDetail(data)
   if (code === 'not_owner') { res.status(409).json({ error: code, message: detail.message, owner_host: detail.owner_host ?? null }); return }
   if (code === 'embedding_locked' || code === 'embedding_mismatch') { res.status(409).json({ error: code, message: detail.message }); return }
+  if (code === 'merge_blocked') {
+    // 6.44.14: two entities the graph knows to be different people. The preview rides along so the page can say why.
+    const d = (typeof data === 'object' && data !== null ? data : {}) as { preview?: unknown }
+    res.status(409).json({ error: code, message: detail.message, preview: d.preview ? normalizeMergePreview(d.preview) : null }); return
+  }
+  if (code === 'merge_running' || code === 'lock_held') {
+    const d = (typeof data === 'object' && data !== null ? data : {}) as { receipt?: unknown; lock?: unknown }
+    res.status(409).json({ error: code, message: detail.message, receipt: d.receipt ? normalizeMergeStatus({ receipt: d.receipt }).receipt : null, lock: normalizeIngestKickoff({ lock: d.lock }).lock }); return
+  }
+  if (code === 'confirmation_required') {
+    const d = (typeof data === 'object' && data !== null ? data : {}) as { preview?: unknown }
+    res.status(400).json({ error: code, message: detail.message, preview: d.preview ? normalizeMergePreview(d.preview) : null }); return
+  }
   if (code === 'embedding_not_ready') {
     // 6.44.12: the chosen embedding cannot embed on this Mac right now. The
     // bridge refused before spawning; pass its fix through so the page can show it.

package/server/routes/voice.ts

@@ -540,6 +540,10 @@ voiceRouter.get('/voice/profiles', (_req, res) => {
             embeddings: p.embeddings.length,
             isOwner: p.name === owner,
             sources: bySource,
+            // 6.44.15: a profile whose name on disk was a spoken sentence was
+            // renamed at load; the client offers a rename.
+            needsName: p.needsName === true,
+            ...(p.renamedFrom ? { renamedFrom: p.renamedFrom } : {}),
             // Provenance alignment is now an invariant; surfacing it makes a
             // future regression visible instead of silent.
             sourcesAligned: (p.sources?.length ?? 0) === p.embeddings.length,