@gotcos/glasses-server 6.36.14 → 6.36.18

package/CHANGELOG.md

@@ -1,4 +1,47 @@
-## Unreleased
+## 6.36.18
+- **Meetings list now carries voice-assignment tags.** Each row includes
+  `voiceReview` from the sidecar head (`speakers[]`) plus whether a human
+  correction landed in the ledger. Control paints NEW / N to name / REVIEWED
+  without opening each meeting. Still a 4 KB head read — not a chunk parse.
+
+## 6.36.17
+- **Naming a new person from a wrong existing label now creates their voice profile.**
+  Enrolment after `POST /relabel` only fired when `from` was a placeholder (`Ext`,
+  `Unknown`, `Unidentified N`). The live path in Speakers review is the other one:
+  the identifier weakly matches someone already enrolled, and the reviewer says
+  **This is someone else → Use "Milo LeBaron"**. Measured 2026-08-20 on
+  `meeting_1787234635703_t4iz74`: Nick Gurney → Milo LeBaron, 19 chunks, ledger
+  `applied`, 78 profiles, no Milo. Backfill used the same guard, so the meeting
+  could not be enrolled after the fact either (`eligible: 0`, `skippedNamedSource: 1`).
+- **Enrol by target, not by source.** `enrolNamedVoice` still skips a placeholder
+  `to` and an empty `changed` list. A real `to` enrols those chunks — creates the
+  profile when it does not exist, appends when it does — through the same raw-index
+  map, coherence gate, 20-sample cap, and `correction:<sessionId>` tag. Global fold
+  of two identities remains `merge-profiles`. Per-meeting chunk assignment is not
+  that. Mutating the old `from`-placeholder guard back in fails the new Nick → Milo
+  test.
+
+## 6.36.16
+- **Cursor Agent Continue.** Continue now resumes a Cursor Agent CLI thread with
+  `agent --resume <id> --workspace <spawn spelling>` in ask-mode. Bindable, not
+  forkable: Fork on Cursor still has no spawn path. Occupancy treats a resolved
+  `~/.cursor/chats/<hash>/<id>/` session (`hasConversation: true`) as attachable
+  with no invented process owner. `--workspace` uses the jsonl folder slug that
+  already exists — never `realpath` of `meta.json.cwd`, which creates a second
+  transcript folder. Queue is refused for Cursor. The 6.36.15 jsonl-mtime write
+  hint is unpublished on the LIST; detail still uses the jsonl mtime the handler
+  already stat'ed as a display-only working signal, never a write gate.
+
+## 6.36.15 (unpublished)
+- **Cursor sessions can show as working.** Occupancy only scanned Claude
+  (registry) and Codex (writer lock). Cursor has neither, so every Cursor row
+  stamped `running: false` even while the jsonl was being written — the lens
+  stayed on the digest and the list never showed a live Cursor turn. The list
+  already paid for Cursor `modified` as the jsonl mtime; a write inside the same
+  30s window Claude/Codex use for `running_active` now synthesizes a display
+  hint (`running` + `running_active`, `running_foreign` still false). Detail
+  uses the file it already stat'ed. Still a hint, never a write gate. Withheld:
+  Continue on Cursor is 6.36.16, and this mtime hint is not in that train.
 
 ## 6.36.14
 - **The session LIST now reports what its caps hid.** The 7-day age gate, the

package/package.json

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

package/server/index.ts

@@ -368,7 +368,7 @@ const occupancyProbes = buildOccupancyProbes(cosSpawnedPids, nativeHeadDeps, thr
  * before a single prompt byte is written, which is the veto the route wants.
  */
 const deliverAttachedTurnForRoute = async (request: {
-  provider: 'claude' | 'codex'
+  provider: 'claude' | 'codex' | 'cursor'
   nativeThreadId: string
   prompt: string
   onSpawn: (pid: number) => boolean

package/server/lib/agent-session-binding-store.ts

@@ -39,10 +39,14 @@ import type { AgentProvider } from './agent-session-store.js'
 
 export type BindingState = 'staging' | 'active' | 'detaching' | 'detached'
 
-/** Providers that can carry a binding. Cursor is Fork-only (plan 2.5). */
-export const BINDABLE_PROVIDERS = ['claude', 'codex'] as const
+/** Providers that can carry a Continue binding. Cursor is bindable, not forkable. */
+export const BINDABLE_PROVIDERS = ['claude', 'codex', 'cursor'] as const
 export type BindableProvider = (typeof BINDABLE_PROVIDERS)[number]
 
+/** Providers that can fork. Cursor Agent has no `--fork-session` equivalent. */
+export const FORKABLE_PROVIDERS = ['claude', 'codex'] as const
+export type ForkableProvider = (typeof FORKABLE_PROVIDERS)[number]
+
 export interface NativeBinding {
   bindingId: string
   cosSessionId: string
@@ -95,6 +99,10 @@ export function isBindableProvider(value: unknown): value is BindableProvider {
   return typeof value === 'string' && (BINDABLE_PROVIDERS as readonly string[]).includes(value)
 }
 
+export function isForkableProvider(value: unknown): value is ForkableProvider {
+  return typeof value === 'string' && (FORKABLE_PROVIDERS as readonly string[]).includes(value)
+}
+
 /**
  * Injective composite key: `<len>:<provider>:<len>:<threadId>`.
  *

package/server/lib/agent-session-store.ts

@@ -58,6 +58,7 @@ export interface AgentSessionRoots {
   claudeCodeSessions: string
   codexSessions: string
   cursorProjects: string
+  cursorChats: string
   cursorComposerDb: string
   cursorWorkspaceStorage: string
 }
@@ -69,6 +70,7 @@ export function agentSessionRoots(home = process.env.COS_AGENT_SESSIONS_HOME ||
     claudeCodeSessions: join(home, 'Library', 'Application Support', 'Claude', 'claude-code-sessions'),
     codexSessions: join(home, '.codex', 'sessions'),
     cursorProjects: join(home, '.cursor', 'projects'),
+    cursorChats: join(home, '.cursor', 'chats'),
     cursorComposerDb: join(home, 'Library', 'Application Support', 'Cursor', 'User', 'globalStorage', 'state.vscdb'),
     cursorWorkspaceStorage: join(home, 'Library', 'Application Support', 'Cursor', 'User', 'workspaceStorage'),
   }

package/server/lib/attached-provider-adapter.ts

@@ -94,8 +94,9 @@ import { isBindableProvider, type BindableProvider } from './agent-session-bindi
 import { recordCosSpawn, releaseCosSpawn } from './agent-session-ownership-store.js'
 import { processStartMs as realProcessStartMs } from './occupancy-probes.js'
 import { getCodexTrustMode } from './codex-run-ledger.js'
+import { CURSOR_SLOT_MODEL_IDS } from './cursor-model-catalog.js'
 
-/** Providers with a certified attached path. Cursor is Fork-only (plan 2.5). */
+/** Providers with a certified attached path. Cursor is bindable, not forkable. */
 export type AttachedProvider = BindableProvider
 
 /**
@@ -486,16 +487,46 @@ export function buildCodexAttachedArgs(nativeThreadId: string, cwd: string): str
   ]
 }
 
+/**
+ * Cursor Agent CLI: ask-mode resume into an existing thread.
+ *
+ * `--force` is the agent-mode bypass and is banned here. Workspace is the
+ * spawn spelling from `spawnWorkspace`, never realpath of `meta.json.cwd`.
+ */
+export function buildCursorAttachedArgs(nativeThreadId: string, cwd: string): string[] {
+  return [
+    '-p',
+    '--mode', 'ask',
+    '--model', CURSOR_SLOT_MODEL_IDS['cursor-composer'],
+    '--output-format', 'stream-json',
+    '--stream-partial-output',
+    '--trust',
+    '--workspace', cwd,
+    '--resume', nativeThreadId,
+  ]
+}
+
+const PATH_VALUED_FLAGS = new Set(['--workspace', '-C', '--cd', '--add-dir'])
+const BARE_BANNED_PERMISSION_ARGS = new Set(
+  BANNED_PERMISSION_ARGS.filter(flag => !flag.startsWith('-')),
+)
+
 /**
  * Is this argv free of every flag plan 4.7 bans?
  *
- * Substring, not equality: a banned token can arrive attached to its value
- * (`--permission-mode=bypassPermissions`, `--sandbox danger-full-access`), and an
- * equality check would wave those through while looking correct.
+ * Flag-position tokens (start with `-`) are substring-matched so
+ * `--permission-mode=bypassPermissions` still hits. Bare tokens
+ * (`danger-full-access`) match only as their own argv slot. Values of
+ * `--workspace` / `-C` are skipped: a cwd containing `--force` is a path,
+ * not a permission flag.
  */
 export function findBannedPermissionArg(args: readonly string[]): string | null {
-  for (const arg of args) {
-    const value = String(arg)
+  for (let i = 0; i < args.length; i++) {
+    const value = String(args[i])
+    const prev = i > 0 ? String(args[i - 1]) : ''
+    if (PATH_VALUED_FLAGS.has(prev)) continue
+    if (BARE_BANNED_PERMISSION_ARGS.has(value)) return value
+    if (!value.startsWith('-')) continue
     for (const banned of BANNED_PERMISSION_ARGS) {
       if (value.includes(banned)) return banned
     }
@@ -520,7 +551,9 @@ export function findBannedPermissionArg(args: readonly string[]): string | null
 function buildArgs(provider: AttachedProvider, nativeThreadId: string, cwd: string): string[] {
   const args = provider === 'claude'
     ? buildClaudeAttachedArgs(nativeThreadId)
-    : buildCodexAttachedArgs(nativeThreadId, cwd)
+    : provider === 'codex'
+      ? buildCodexAttachedArgs(nativeThreadId, cwd)
+      : buildCursorAttachedArgs(nativeThreadId, cwd)
   const banned = findBannedPermissionArg(args)
   if (banned !== null) {
     // The flag name only. Never the argv, which carries the thread id and cwd.

package/server/lib/attached-workspace.ts

@@ -30,8 +30,10 @@ import { createHash } from 'node:crypto'
 import { closeSync, constants as fsConstants, openSync, readSync, statSync } from 'node:fs'
 import { isAbsolute } from 'node:path'
 import { realNativeHeadDeps, transcriptPathFor, type NativeHeadDeps } from './native-head.js'
+import { spawnWorkspace } from './cursor-agent-store.js'
+import { agentSessionRoots } from './agent-session-store.js'
 
-export type AttachedWorkspaceProvider = 'claude' | 'codex'
+export type AttachedWorkspaceProvider = 'claude' | 'codex' | 'cursor'
 
 export interface ResolvedWorkspace {
   /**
@@ -52,6 +54,11 @@ export interface AttachedWorkspaceDeps {
   readHead: (path: string, maxBytes: number) => string | null
   /** Does this directory exist right now? MUST THROW on "cannot tell". */
   dirExists: (path: string) => boolean
+  /**
+   * Spawn-spelling cwd for a Cursor Agent session. Never the realpath of
+   * `meta.json.cwd` — that creates a second jsonl folder (canary H).
+   */
+  cursorSpawnWorkspace?: (threadId: string) => string | null
 }
 
 /** Enough to reach a Claude message row or the Codex session meta row. */
@@ -113,6 +120,29 @@ export function resolveAttachedWorkspace(
   threadId: string,
   deps: AttachedWorkspaceDeps,
 ): ResolvedWorkspace | null {
+  if (provider === 'cursor') {
+    let cwd: string | null
+    let path: string | null
+    try {
+      cwd = deps.cursorSpawnWorkspace?.(threadId) ?? null
+      path = deps.transcriptPath('cursor', threadId)
+    } catch {
+      return null
+    }
+    if (!cwd || !isAbsolute(cwd) || cwd.includes('\0') || !path) return null
+    let exists: boolean
+    try {
+      exists = deps.dirExists(cwd)
+    } catch {
+      return null
+    }
+    if (!exists) return null
+    return {
+      path: cwd,
+      workspaceFingerprint: fingerprint(cwd),
+      sourceFingerprint: fingerprint(path),
+    }
+  }
   if (provider !== 'claude' && provider !== 'codex') return null
   let path: string | null
   let text: string | null
@@ -163,8 +193,13 @@ export function resolveAttachedWorkspace(
 export function realAttachedWorkspaceDeps(
   headDeps: NativeHeadDeps = realNativeHeadDeps(),
 ): AttachedWorkspaceDeps {
+  const roots = agentSessionRoots()
   return {
     transcriptPath: (provider, threadId) => transcriptPathFor(provider, threadId, headDeps),
+    cursorSpawnWorkspace: threadId => spawnWorkspace(threadId, {
+      cursorChatsDir: roots.cursorChats,
+      cursorProjectsDir: roots.cursorProjects,
+    }),
 
     readHead: (path, maxBytes) => {
       let fd: number | null = null

package/server/lib/cos-operations-meetings.ts

@@ -18,6 +18,7 @@ import { basename, dirname, join, resolve } from 'node:path'
 import { discoveredDomains, domainAbbreviation as deriveAbbr, isSafeDomainName as safeName } from './domains.js'
 import type { MeetingDetail, MeetingMeta } from './meeting-store.js'
 import { MEETING_SOURCE_MAX_BYTES, meetingDayCountsFromNames, meetingListLimit } from './meeting-store.js'
+import { meetingVoiceReview, parseSidecarListHead } from './meeting-voice-review.js'
 
 /**
  * The four domains of ONE user's COS. Retained as the documented example layout
@@ -151,30 +152,35 @@ const SIDECAR_HEAD_BYTES = 4096
  * them whole would make listing cost scale with total transcript size — and this
  * lister already reads every markdown file it finds.
  */
-export function sidecarSessionId(monthDir: string, meetingFilename: string): string | undefined {
+export function sidecarListHints(monthDir: string, meetingFilename: string): {
+  sessionId?: string
+  speakers: string[]
+} {
   const sidecarName = meetingFilename.replace(/\.md$/, '.g2-chunks.json')
-  if (sidecarName === meetingFilename) return undefined
+  if (sidecarName === meetingFilename) return { speakers: [] }
   const path = join(monthDir, sidecarName)
   let fd: number | null = null
   try {
     const linkStat = lstatSync(path)
-    if (linkStat.isSymbolicLink() || !linkStat.isFile() || linkStat.size === 0) return undefined
+    if (linkStat.isSymbolicLink() || !linkStat.isFile() || linkStat.size === 0) return { speakers: [] }
     const real = realpathSync(path)
-    if (dirname(real) !== realpathSync(monthDir)) return undefined
+    if (dirname(real) !== realpathSync(monthDir)) return { speakers: [] }
     const stat = statSync(real)
     fd = openSync(path, 'r')
     const buffer = Buffer.alloc(Math.min(SIDECAR_HEAD_BYTES, stat.size))
     const read = readSync(fd, buffer, 0, buffer.length, 0)
-    const match = buffer.subarray(0, read).toString('utf8')
-      .match(/"sessionId"\s*:\s*"([A-Za-z0-9:_-]{3,96})"/)
-    return match ? match[1] : undefined
+    return parseSidecarListHead(buffer.subarray(0, read).toString('utf8'))
   } catch {
-    return undefined
+    return { speakers: [] }
   } finally {
     if (fd !== null) { try { closeSync(fd) } catch { /* already closed */ } }
   }
 }
 
+export function sidecarSessionId(monthDir: string, meetingFilename: string): string | undefined {
+  return sidecarListHints(monthDir, meetingFilename).sessionId
+}
+
 function envPath(name: string): string | null {
   const raw = process.env[name]?.trim()
   if (!raw) return null
@@ -563,8 +569,11 @@ export function listCosOperationsMeetings(options: {
               meta.recordId = `ops:${domain}:${month}:${file}`
               meta.mutable = true
               meta.canonicalRecord = `operations/${domain}/meetings/${month}/${file}`
-              const sessionId = sidecarSessionId(monthDir, file)
-              if (sessionId) meta.sessionId = sessionId
+              const hints = sidecarListHints(monthDir, file)
+              if (hints.sessionId) meta.sessionId = hints.sessionId
+              if (hints.speakers.length > 0) {
+                meta.voiceReview = meetingVoiceReview(hints.speakers, hints.sessionId)
+              }
               if (options.day && meta.date !== options.day) continue
               allMeetings.push(meta)
             } catch { /* skip unreadable files */ }

package/server/lib/cursor-agent-store.ts

@@ -0,0 +1,189 @@
+// Cursor Agent CLI store: `~/.cursor/chats/<hash>/<uuid>/` plus the jsonl
+// project-folder slug Agent keys off `--workspace`.
+//
+// Continue attaches only when this helper resolves. IDE-only composers have a
+// jsonl and no chats dir — Gate 0. Empty `hasConversation: false` stubs are
+// not sessions. Canary H: passing realpath `meta.json.cwd` (`/private/tmp/...`)
+// as `--workspace` creates a SECOND jsonl folder. Spawn must use the spelling
+// whose slug already exists.
+
+import { existsSync, lstatSync, readFileSync, realpathSync, readdirSync } from 'node:fs'
+import { isAbsolute, join } from 'node:path'
+import { isValidNativeThreadId } from './native-thread-id.js'
+
+export const MAX_CURSOR_CHAT_HASH_DIRS = 2048
+export const MAX_CURSOR_CHAT_DIRS = 4096
+export const MAX_CURSOR_PROJECT_DIRS = 2048
+
+export interface CursorAgentSession {
+  dir: string
+  cwd: string
+  hasConversation: boolean
+  createdAtMs: number | null
+}
+
+export interface CursorAgentStoreDirs {
+  cursorChatsDir: string
+  cursorProjectsDir: string
+}
+
+export function encodeCursorWorkspaceSlug(workspace: string): string {
+  const trimmed = workspace.trim()
+  const withoutRoot = trimmed.startsWith('/') ? trimmed.slice(1) : trimmed
+  // Cursor's project-folder alphabet is [A-Za-z0-9-]. Every other run of
+  // characters — underscores, dots, spaces, slashes — collapses to one hyphen.
+  // Matching only `/` and whitespace left `_` and `.` in the slug, so
+  // spawnWorkspace could never find the real folder (wk30_2026, .module, …).
+  return withoutRoot.replace(/[^A-Za-z0-9]+/g, '-')
+}
+
+export function cursorWorkspaceSpellings(cwd: string): string[] {
+  const trimmed = cwd.trim()
+  if (!trimmed) return []
+  const out = [trimmed]
+  if (trimmed.startsWith('/private/tmp/')) {
+    out.push(`/tmp/${trimmed.slice('/private/tmp/'.length)}`)
+  } else if (trimmed.startsWith('/tmp/')) {
+    out.push(`/private/tmp/${trimmed.slice('/tmp/'.length)}`)
+  }
+  return out
+}
+
+function realpathOrNull(path: string): string | null {
+  try {
+    return realpathSync(path)
+  } catch {
+    return null
+  }
+}
+
+function dirExists(path: string): boolean {
+  try {
+    return lstatSync(path).isDirectory()
+  } catch {
+    return false
+  }
+}
+
+function readDirNames(path: string): string[] {
+  return readdirSync(path, { withFileTypes: true }).map(entry => entry.name)
+}
+
+function skipProjectFolder(folder: string): boolean {
+  return folder.includes('var-folders') || folder.includes('private-var') || folder === 'empty-window'
+}
+
+export function resolveCursorAgentSession(
+  threadId: string,
+  chatsDir: string,
+): CursorAgentSession | null {
+  if (!isValidNativeThreadId(threadId)) return null
+  if (!chatsDir || !dirExists(chatsDir)) return null
+
+  let hashes: string[]
+  try {
+    hashes = readDirNames(chatsDir)
+  } catch {
+    return null
+  }
+  if (hashes.length > MAX_CURSOR_CHAT_HASH_DIRS) return null
+
+  const matches: string[] = []
+  let scanned = 0
+  for (const hash of hashes) {
+    const hashDir = join(chatsDir, hash)
+    if (!dirExists(hashDir)) continue
+    const candidate = join(hashDir, threadId)
+    if (++scanned > MAX_CURSOR_CHAT_DIRS) return null
+    if (!dirExists(candidate)) continue
+    if (!existsSync(join(candidate, 'meta.json'))) continue
+    matches.push(candidate)
+    if (matches.length > 1) return null
+  }
+  if (matches.length !== 1) return null
+
+  const dir = matches[0]!
+  let raw: string
+  try {
+    raw = readFileSync(join(dir, 'meta.json'), 'utf8')
+  } catch {
+    return null
+  }
+  let meta: Record<string, unknown>
+  try {
+    const parsed = JSON.parse(raw)
+    if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed)) return null
+    meta = parsed as Record<string, unknown>
+  } catch {
+    return null
+  }
+  if (meta.hasConversation !== true) return null
+  const cwd = typeof meta.cwd === 'string' ? meta.cwd.trim() : ''
+  if (!cwd || !isAbsolute(cwd) || cwd.includes('\0')) return null
+  const resolved = realpathOrNull(cwd)
+  if (!resolved || !dirExists(resolved)) return null
+  const createdAtMs = typeof meta.createdAtMs === 'number' && Number.isFinite(meta.createdAtMs)
+    ? meta.createdAtMs
+    : null
+  return { dir, cwd, hasConversation: true, createdAtMs }
+}
+
+export function transcriptFoldersFor(
+  threadId: string,
+  projectsDir: string,
+): string[] {
+  if (!isValidNativeThreadId(threadId)) return []
+  if (!projectsDir || !dirExists(projectsDir)) return []
+  let folders: string[]
+  try {
+    folders = readDirNames(projectsDir)
+  } catch {
+    return []
+  }
+  if (folders.length > MAX_CURSOR_PROJECT_DIRS) return []
+
+  const found: string[] = []
+  for (const folder of folders) {
+    if (skipProjectFolder(folder)) continue
+    const file = join(projectsDir, folder, 'agent-transcripts', threadId, `${threadId}.jsonl`)
+    try {
+      if (!lstatSync(file).isFile()) continue
+    } catch {
+      continue
+    }
+    found.push(folder)
+  }
+  return found
+}
+
+export function spawnWorkspace(
+  threadId: string,
+  dirs: CursorAgentStoreDirs,
+): string | null {
+  const session = resolveCursorAgentSession(threadId, dirs.cursorChatsDir)
+  if (!session) return null
+  const folders = transcriptFoldersFor(threadId, dirs.cursorProjectsDir)
+  if (folders.length !== 1) return null
+  const expected = folders[0]!
+  const sessionReal = realpathOrNull(session.cwd)
+  if (!sessionReal) return null
+  for (const candidate of cursorWorkspaceSpellings(session.cwd)) {
+    if (encodeCursorWorkspaceSlug(candidate) !== expected) continue
+    const candidateReal = realpathOrNull(candidate)
+    if (!candidateReal || candidateReal !== sessionReal) continue
+    if (!dirExists(candidate) && !dirExists(candidateReal)) continue
+    const still = transcriptFoldersFor(threadId, dirs.cursorProjectsDir)
+    if (still.length !== 1 || still[0] !== expected) return null
+    return candidate
+  }
+  return null
+}
+
+export function cursorTranscriptPath(
+  threadId: string,
+  projectsDir: string,
+): string | null {
+  const folders = transcriptFoldersFor(threadId, projectsDir)
+  if (folders.length !== 1) return null
+  return join(projectsDir, folders[0]!, 'agent-transcripts', threadId, `${threadId}.jsonl`)
+}

package/server/lib/cursor-model-catalog.ts

@@ -5,8 +5,8 @@
 
 import { spawn } from 'node:child_process'
 import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from 'node:fs'
-import { homedir } from 'node:os'
 import { dirname, resolve } from 'node:path'
+import { resolveProviderBinary } from './provider-binary.js'
 import {
   CURSOR_COMPOSER_MODEL,
   CURSOR_GROK_MODEL,
@@ -93,20 +93,10 @@ function catalogCachePath(): string {
   )
 }
 
-/** Resolve the Cursor `agent` binary: PATH first, then ~/.local/bin/agent. */
+/** Resolve the Cursor `agent` binary via the shared provider table. */
 export function resolveAgentBinary(): string | undefined {
-  const configured = process.env.COS_CURSOR_AGENT_BIN?.trim()
-  if (configured && existsSync(configured)) return configured
-
-  const pathEntries = (process.env.PATH ?? '').split(':').filter(Boolean)
-  for (const entry of pathEntries) {
-    const candidate = resolve(entry, 'agent')
-    if (existsSync(candidate)) return candidate
-  }
-
-  const homeLocal = resolve(homedir(), '.local', 'bin', 'agent')
-  if (existsSync(homeLocal)) return homeLocal
-  return undefined
+  const resolved = resolveProviderBinary('cursor')
+  return resolved.ok ? resolved.path : undefined
 }
 
 /** Parse `agent models` text lines shaped like `id - Display Name`. */

package/server/lib/fork-thread.ts

@@ -65,7 +65,7 @@ import { isAbsolute } from 'node:path'
 import { spawn as nodeSpawn } from 'node:child_process'
 
 import { isValidNativeThreadId } from './native-thread-id.js'
-import { isBindableProvider } from './agent-session-binding-store.js'
+import { isForkableProvider, type ForkableProvider } from './agent-session-binding-store.js'
 import { recordCosSpawn, releaseCosSpawn } from './agent-session-ownership-store.js'
 import { processStartMs as realProcessStartMs } from './occupancy-probes.js'
 import {
@@ -82,20 +82,19 @@ import {
   isAttachedPermissionPolicy,
   resolveProviderBinary,
   type AttachedChildProcess,
-  type AttachedProvider,
   type AttachedSpawnRequest,
   type AttachedStderrClass,
   type BinaryResolution,
 } from './attached-provider-adapter.js'
 
 /**
- * Providers that can be forked. Identical to the attached set on purpose.
+ * Providers that can be forked. A strict subset of the attached set.
  *
- * Re-exported from the adapter rather than redeclared: a provider that gains an
- * attached path and not a fork path (or the reverse) would leave one of the two
- * halves of this feature silently unreachable.
+ * Cursor can Continue (ask-mode resume) and cannot Fork: Agent CLI has no
+ * `--fork-session` equivalent, and advertising Fork on Cursor would 404 the
+ * only remaining write path for that row if Continue were also hidden.
  */
-export type ForkProvider = AttachedProvider
+export type ForkProvider = ForkableProvider
 
 /** Same one-member policy as the attached path. An omitted policy is refused. */
 export type ForkPermissionPolicy = 'read_only'
@@ -524,7 +523,7 @@ async function run(request: ForkRequest, deps: ForkDeps, startedAt: number): Pro
   const duration = () => readDuration(deps, startedAt)
 
   // --- 1. Validate ------------------------------------------------------------
-  if (!isBindableProvider(request.provider)) {
+  if (!isForkableProvider(request.provider)) {
     return fail('invalid_provider', 'none', { durationMs: duration() })
   }
   const provider: ForkProvider = request.provider

package/server/lib/meeting-relabel-enrolment.ts

@@ -86,8 +86,9 @@ export interface EnrolmentReport {
   /** Samples the voice store actually accepted. */
   enrolled: number
   /** Candidate embeddings found for the relabelled chunks, before any gating.
-   *  Zero here means this correction was never an enrolment (a real name being
-   *  corrected to another real name), not that enrolment failed. */
+   *  Zero with `skipped: null` means this correction was never an enrolment
+   *  (empty `changed`, or the target is still a placeholder), not that
+   *  enrolment failed. */
   attempted: number
   /** True ONLY when a profile did not exist for this name and now does. An
    *  existing name is APPENDED to, and must never be reported as created. */
@@ -179,12 +180,17 @@ export interface EnrolNamedVoiceInput {
 /**
  * Enrol the voice a human just named.
  *
- * SCOPED to placeholder -> real name. Correcting one real name to another is left
- * alone deliberately: moving a voice between existing people is `merge-profiles`,
- * which is explicit and confirmation-gated, and a sweep of this store put two
- * DISTINCT people at 0.85 similarity, so doing it implicitly would poison both.
+ * SCOPED to a real target name. The reviewer is assigning THESE chunks to `to`.
+ * That is a first training run when `to` has no profile (the live case: Nick
+ * Gurney → Milo LeBaron, 2026-08-20 — 19 chunks relabelled, 78 profiles, no
+ * Milo) and an append when the profile already exists. Global fold of two
+ * identities remains `merge-profiles`. Per-meeting chunk assignment is not
+ * that, and gating on `from` being a placeholder made a wrong existing label
+ * (the identifier's 0.55 Nick match) create no profile at all.
  *
- * An EXISTING name is appended to without a prompt, and reports `created: false`.
+ * Still skipped: a placeholder `to` (Ext → Unidentified 2), and an empty
+ * `changed` list. An EXISTING name is appended to without a prompt, and
+ * reports `created: false`.
  *
  * Samples are stamped `correction:<sessionId>`, not a bare source string. The
  * prefix is load-bearing in four places: `isSampleFromSession` accepts only
@@ -198,11 +204,14 @@ export interface EnrolNamedVoiceInput {
  * on disk; a voice store that refuses must not undo what the user asked for.
  */
 export function enrolNamedVoice(input: EnrolNamedVoiceInput): EnrolmentReport {
-  const { sessionId, from, to, changed, sidecar } = input
+  const { sessionId, to, changed, sidecar } = input
 
   // Not an enrolment at all. `attempted: 0` with `skipped: null` is how the
   // caller tells this apart from an enrolment that found no candidates.
-  if (!isPlaceholderLabel(from) || isPlaceholderLabel(to) || changed.length === 0) return IDLE
+  // `from` is deliberately NOT gated: a wrong existing label is how a new
+  // person first appears in review (Nick Gurney → Milo LeBaron). Gating on
+  // placeholder-only `from` labelled the meeting and taught the store nothing.
+  if (isPlaceholderLabel(to) || changed.length === 0) return IDLE
 
   if (!chunkEmbeddingsEnabled()) return { ...IDLE, skipped: 'disabled' }
   // No extractor/manager means every enrollEmbedding would return success:false.

package/server/lib/meeting-store.ts

@@ -94,6 +94,13 @@ export interface MeetingMeta {
   mutable?: boolean
   /** Present only when the server can state a truthful local record. */
   canonicalRecord?: string
+  /** Additive. Unique sidecar speakers + whether a human correction landed. */
+  voiceReview?: {
+    voices: number
+    unattributedVoices: number
+    namedVoices: number
+    humanTouched: boolean
+  }
 }
 
 export interface MeetingActionItem {

package/server/lib/meeting-voice-review.ts

@@ -0,0 +1,53 @@
+// Cheap voice-assignment stats for the meetings LIST.
+//
+// The Speakers panel's "Meetings to review" row cannot open every sidecar just
+// to paint a tag. The unique `speakers` array sits at the top of the sidecar,
+// so a 4 KB head read already used for `sessionId` is enough. Segment counts
+// stay on the per-meeting review route.
+
+import { isUnattributed } from './meeting-speaker-review.js'
+import { readCorrections } from './meeting-corrections.js'
+
+export interface MeetingVoiceReview {
+  voices: number
+  unattributedVoices: number
+  namedVoices: number
+  humanTouched: boolean
+}
+
+export function parseSidecarListHead(head: string): {
+  sessionId?: string
+  speakers: string[]
+} {
+  const sessionId = head.match(/"sessionId"\s*:\s*"([A-Za-z0-9:_-]{3,96})"/)?.[1]
+  const block = head.match(/"speakers"\s*:\s*\[([^\]]*)\]/)
+  const speakers = block
+    ? [...block[1].matchAll(/"((?:\\.|[^"\\])*)"/g)].map(match => match[1].replace(/\\"/g, '"'))
+    : []
+  return { sessionId, speakers }
+}
+
+export function meetingVoiceReview(
+  speakers: string[],
+  sessionId?: string,
+): MeetingVoiceReview {
+  const labels = [...new Set(speakers.map(name => name.trim()).filter(Boolean))]
+  const unattributedVoices = labels.filter(isUnattributed).length
+  return {
+    voices: labels.length,
+    unattributedVoices,
+    namedVoices: Math.max(0, labels.length - unattributedVoices),
+    humanTouched: sessionWasHumanTouched(sessionId),
+  }
+}
+
+export function sessionWasHumanTouched(sessionId?: string): boolean {
+  if (!sessionId) return false
+  try {
+    return readCorrections(sessionId).rows.some(
+      row => row.phase === 'applied' || row.phase === 'confirmed',
+    )
+  } catch {
+    return false
+  }
+}

package/server/lib/native-head.ts

@@ -121,10 +121,11 @@ import { createHash } from 'node:crypto'
 import { closeSync, constants as fsConstants, fstatSync, openSync, readSync, readdirSync, statSync } from 'node:fs'
 import { join } from 'node:path'
 import { agentSessionRoots, idFromCodexFilename } from './agent-session-store.js'
+import { cursorTranscriptPath } from './cursor-agent-store.js'
 import { isValidNativeThreadId } from './native-thread-id.js'
 
 /** Providers with a certified transcript shape. Anything else has no watermark. */
-export type NativeHeadProvider = 'claude' | 'codex'
+export type NativeHeadProvider = 'claude' | 'codex' | 'cursor'
 
 /**
  * Token prefix. Bumping it forces every stored head to compare as CHANGED,
@@ -163,6 +164,7 @@ export const TAIL_WINDOW_BYTES = 2 * 1024 * 1024
 export const TAIL_WINDOW_BYTES_BY_PROVIDER: Record<NativeHeadProvider, number> = {
   claude: 8 * 1024 * 1024,
   codex: 64 * 1024 * 1024,
+  cursor: 8 * 1024 * 1024,
 }
 
 /**
@@ -185,6 +187,8 @@ export interface NativeHeadDirs {
   claudeProjectsDir: string
   /** `<COS_AGENT_SESSIONS_HOME|~>/.codex/sessions` */
   codexSessionsDir: string
+  /** `<COS_AGENT_SESSIONS_HOME|~>/.cursor/projects` */
+  cursorProjectsDir: string
 }
 
 export interface TailRead {
@@ -308,6 +312,10 @@ export function isMessageBearingRow(
   // does not advance on real messages, i.e. divergence that never reports.
   if (provider === 'claude') return isClaudeMessageRow(row)
   if (provider === 'codex') return isCodexMessageRow(row)
+  if (provider === 'cursor') {
+    const role = row.role
+    return role === 'user' || role === 'assistant'
+  }
   return false
 }
 
@@ -391,12 +399,17 @@ export function transcriptPathFor(
     if (!isValidNativeThreadId(threadId)) return null
     if (provider === 'claude') return claudeTranscriptPath(threadId, deps)
     if (provider === 'codex') return codexRolloutPath(threadId, deps)
+    if (provider === 'cursor') return cursorAgentTranscriptPath(threadId, deps)
     return null
   } catch {
     return null
   }
 }
 
+function cursorAgentTranscriptPath(threadId: string, deps: NativeHeadDeps): string | null {
+  return cursorTranscriptPath(threadId, deps.dirs.cursorProjectsDir)
+}
+
 function claudeTranscriptPath(threadId: string, deps: NativeHeadDeps): string | null {
   const root = deps.dirs.claudeProjectsDir
   if (!deps.dirExists(root)) return null
@@ -494,15 +507,13 @@ export function nativeHead(
   deps: NativeHeadDeps,
 ): string | null {
   try {
-    if (provider !== 'claude' && provider !== 'codex') return null
+    if (provider !== 'claude' && provider !== 'codex' && provider !== 'cursor') return null
     // Validated before any scan. A truncated or malformed id reaches a
     // filesystem path below, and "matched nothing" must never look like a
     // clean read of a real transcript.
     if (!isValidNativeThreadId(threadId)) return null
 
-    const path = provider === 'claude'
-      ? claudeTranscriptPath(threadId, deps)
-      : codexRolloutPath(threadId, deps)
+    const path = transcriptPathFor(provider, threadId, deps)
     if (path === null) return null
 
     const window = deps.tailWindowBytes ?? TAIL_WINDOW_BYTES_BY_PROVIDER[provider] ?? TAIL_WINDOW_BYTES
@@ -555,7 +566,11 @@ export function nativeHead(
 
 export function realNativeHeadDirs(): NativeHeadDirs {
   const roots = agentSessionRoots()
-  return { claudeProjectsDir: roots.claudeProjects, codexSessionsDir: roots.codexSessions }
+  return {
+    claudeProjectsDir: roots.claudeProjects,
+    codexSessionsDir: roots.codexSessions,
+    cursorProjectsDir: roots.cursorProjects,
+  }
 }
 
 function dirExists(path: string): boolean {

package/server/lib/occupancy-probes.ts

@@ -51,6 +51,7 @@ import { basename, join, resolve } from 'node:path'
 import { NATIVE_THREAD_ID_RE } from './native-thread-id.js'
 import { transcriptPathFor, type NativeHeadDeps } from './native-head.js'
 import { parseProcStartUtcMs, type OccupancyDirs, type OccupancyProbes } from './thread-occupancy.js'
+import { resolveCursorAgentSession } from './cursor-agent-store.js'
 
 // Re-exported rather than reimplemented. `claudeSessionsDir` already encodes the
 // COS_CLAUDE_SESSIONS_DIR -> CLAUDE_CONFIG_DIR -> ~/.claude precedence AND is the
@@ -73,7 +74,12 @@ export function codexLocksDir(): string {
 }
 
 export function realOccupancyDirs(): OccupancyDirs {
-  return { claudeSessionsDir: claudeSessionsDir(), codexLocksDir: codexLocksDir() }
+  const home = process.env.COS_AGENT_SESSIONS_HOME?.trim() || homedir()
+  return {
+    claudeSessionsDir: claudeSessionsDir(),
+    codexLocksDir: codexLocksDir(),
+    cursorChatsDir: join(home, '.cursor', 'chats'),
+  }
 }
 
 /** Absolute first, bare name as the fallback: a launchd/Finder-spawned server has no login PATH. */
@@ -441,6 +447,7 @@ export function realOccupancyProbes(ledger: SpawnLedgerAccessor): OccupancyProbe
     readFile,
     lockHolders,
     cosSpawnedPids: () => sanitizeLedger(ledger()),
+    cursorAgentSession: (threadId, chatsDir) => resolveCursorAgentSession(threadId, chatsDir),
     // transcriptMtimeMs is DELIBERATELY absent here. See `withTranscriptClock`.
   }
 }

package/server/lib/provider-binary.ts

@@ -19,7 +19,7 @@ import { homedir } from 'node:os'
 // Binary resolution
 // ---------------------------------------------------------------------------
 
-export type BinaryResolutionFailure = 'env_override_unusable' | 'not_found'
+export type BinaryResolutionFailure = 'env_override_unusable' | 'not_found' | 'unknown_provider'
 
 export type BinaryResolution =
   | { ok: true; path: string; source: 'env' | 'absolute' | 'path' }
@@ -94,7 +94,7 @@ export interface BinarySpec {
  * `attached-provider-adapter.ts`, and importing it back would recreate exactly the cycle
  * this extraction exists to break. Callers pass a string-union value, which is assignable.
  */
-export function providerBinarySpec(provider: string): BinarySpec {
+export function providerBinarySpec(provider: string): BinarySpec | null {
   const home = (() => {
     try {
       return homedir()
@@ -113,18 +113,30 @@ export function providerBinarySpec(provider: string): BinarySpec {
       ].filter(Boolean),
     }
   }
-  return {
-    name: 'codex',
-    envKeys: ['COS_ATTACHED_CODEX_BIN', 'COS_CODEX_BIN'],
-    absolutes: [
-      // Verified 2026-08-15: codex-cli 0.148.0-alpha.9 lives here, and there is
-      // no `codex` on PATH at all on this machine.
-      '/Applications/ChatGPT.app/Contents/Resources/codex',
-      home ? join(home, '.codex', 'bin', 'codex') : '',
-      '/opt/homebrew/bin/codex',
-      '/usr/local/bin/codex',
-    ].filter(Boolean),
+  if (provider === 'codex') {
+    return {
+      name: 'codex',
+      envKeys: ['COS_ATTACHED_CODEX_BIN', 'COS_CODEX_BIN'],
+      absolutes: [
+        // Verified 2026-08-15: codex-cli 0.148.0-alpha.9 lives here, and there is
+        // no `codex` on PATH at all on this machine.
+        '/Applications/ChatGPT.app/Contents/Resources/codex',
+        home ? join(home, '.codex', 'bin', 'codex') : '',
+        '/opt/homebrew/bin/codex',
+        '/usr/local/bin/codex',
+      ].filter(Boolean),
+    }
+  }
+  if (provider === 'cursor') {
+    return {
+      name: 'agent',
+      envKeys: ['COS_ATTACHED_CURSOR_AGENT_BIN', 'COS_CURSOR_AGENT_BIN'],
+      absolutes: [
+        home ? join(home, '.local', 'bin', 'agent') : '',
+      ].filter(Boolean),
+    }
   }
+  return null
 }
 
 /**
@@ -144,7 +156,9 @@ export function resolveProviderBinary(
   provider: string,
   env: NodeJS.ProcessEnv = process.env,
 ): BinaryResolution {
-  return resolveBinaryFromSpec(providerBinarySpec(provider), env)
+  const spec = providerBinarySpec(provider)
+  if (!spec) return { ok: false, binary: provider, detail: 'unknown_provider' }
+  return resolveBinaryFromSpec(spec, env)
 }
 
 /**

package/server/lib/thread-attach-capability.ts

@@ -43,10 +43,11 @@
 // owns the endpoints "so it cannot drift from whether they are actually
 // registered."
 //
-// `providers` is sourced from BINDABLE_PROVIDERS for the same reason. Cursor must
-// not appear (plan 2.5 makes it Fork-only), and the way to guarantee that is to
-// read the list that `isBindableProvider` — the check the attach route itself
-// applies — is built from, rather than restating two names here and hoping.
+// `providers` is sourced from BINDABLE_PROVIDERS for the same reason. Cursor is
+// Continue-capable once bindable; Fork stays on FORKABLE_PROVIDERS (claude/codex).
+// The way to guarantee the published list matches the attach route is to read
+// the list that `isBindableProvider` is built from, rather than restating names
+// here and hoping.
 //
 // ------------------------------------------------- why providers empties out
 //
@@ -86,7 +87,7 @@ export interface ThreadAttachCapability {
   /**
    * Providers that can be CONTINUED, not merely browsed or forked.
    *
-   * Empty whenever `enabled` is false. Cursor is never a member: it is Fork-only.
+   * Empty whenever `enabled` is false. Cursor is a member once bindable.
    */
   providers: BindableProvider[]
   /**

package/server/lib/thread-occupancy.ts

@@ -150,6 +150,16 @@ export interface OccupancyProbes {
    * safety property here.
    */
   transcriptMtimeMs?: (provider: OccupancyProvider, threadId: string) => number | null
+  /**
+   * Cursor Agent CLI session at `~/.cursor/chats/<hash>/<id>/`, or null when
+   * that id is not exactly one continuable chats dir. Occupancy MUST NOT import
+   * fs; this is the only Cursor evidence this detector is allowed to see.
+   */
+  cursorAgentSession?: (threadId: string, chatsDir: string) => {
+    dir: string
+    cwd: string
+    hasConversation: boolean
+  } | null
 }
 
 /**
@@ -464,6 +474,8 @@ export interface OccupancyDirs {
   claudeSessionsDir: string
   /** `<CODEX_HOME|~/.codex>/thread-writer-locks` */
   codexLocksDir: string
+  /** `<COS_AGENT_SESSIONS_HOME|~>/.cursor/chats` */
+  cursorChatsDir: string
 }
 
 // ===========================================================================
@@ -551,8 +563,26 @@ export function threadOccupancy(
   probes: OccupancyProbes,
   dirs: OccupancyDirs,
 ): Occupancy {
+  if (provider === 'cursor') {
+    if (!isValidNativeThreadId(threadId)) {
+      return { attachable: false, owners: [], reason: 'invalid_thread_id' }
+    }
+    if (typeof probes.cursorAgentSession !== 'function' || typeof dirs.cursorChatsDir !== 'string') {
+      return { attachable: false, owners: [], reason: 'probe_failed' }
+    }
+    let session: { dir: string; cwd: string; hasConversation: boolean } | null
+    try {
+      session = probes.cursorAgentSession(threadId, dirs.cursorChatsDir)
+    } catch {
+      return { attachable: false, owners: [], reason: 'probe_failed' }
+    }
+    if (!session || session.hasConversation !== true) {
+      return { attachable: false, owners: [], reason: 'unsupported_provider' }
+    }
+    return { attachable: true, owners: [], reason: null }
+  }
   if (provider !== 'claude' && provider !== 'codex') {
-    // Cursor and anything unrecognised: an honest capability gap, not a failure.
+    // Anything unrecognised: an honest capability gap, not a failure.
     return { attachable: false, owners: [], reason: 'unsupported_provider' }
   }
   // Validated BEFORE any scan. A truncated or malformed id matches no record,

package/server/routes/agent-session-bindings.ts

@@ -109,11 +109,13 @@ import {
   assertUsable,
   boundToMarker,
   isBindableProvider,
+  isForkableProvider,
   isExpired,
   isPinned,
   isTerminal,
   targetKey,
   type BindableProvider,
+  type ForkableProvider,
   type BindingState,
   type NativeBinding,
 } from '../lib/agent-session-binding-store.js'
@@ -798,9 +800,11 @@ function occupancyDepsUsable(deps: AgentSessionBindingsDeps): boolean {
     typeof probes.fileExists === 'function' &&
     typeof probes.lockHolders === 'function' &&
     typeof probes.cosSpawnedPids === 'function' &&
+    typeof probes.cursorAgentSession === 'function' &&
     !!dirs &&
     typeof dirs.claudeSessionsDir === 'string' &&
-    typeof dirs.codexLocksDir === 'string'
+    typeof dirs.codexLocksDir === 'string' &&
+    typeof dirs.cursorChatsDir === 'string'
   )
 }
 
@@ -1097,7 +1101,7 @@ export function isOpaque(value: unknown): value is string {
 
 /** What the route hands `forkThread`. The client supplies none of these but the prompt. */
 export interface ForkRouteRequest {
-  provider: BindableProvider
+  provider: ForkableProvider
   nativeThreadId: string
   prompt: string
   /** Resolved server-side. Plan 4.2: the client never sends a path. */
@@ -1734,7 +1738,7 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
       // Validated HERE rather than inherited from an occupancy verdict, because
       // this route deliberately never asks for one. The id becomes a spawn
       // argument and a lock key, so `isValidNativeThreadId` is the whole guard.
-      if (!isBindableProvider(providerParam)) return refuseFork('fork_unsupported_provider')
+      if (!isForkableProvider(providerParam)) return refuseFork('fork_unsupported_provider')
       if (!isValidNativeThreadId(threadIdParam)) return refuseFork('fork_invalid_thread_id')
 
       const now = readNow()

package/server/routes/agent-sessions.ts

@@ -39,6 +39,7 @@ import {
   occupiedThreads,
   noOccupancyKnown,
   withActiveRecently,
+  isActiveRecently,
   type OccupiedScan,
   type OccupiedThread,
 } from '../lib/occupied-threads.js'
@@ -209,6 +210,16 @@ export function withRunning<T extends { session_id: string }>(entry: T, scan: Oc
  * gate; `attach` re-probes at the write, unchanged.
  */
 function runningForThread(provider: AgentProvider, threadId: string, mtimeMs: number): OccupiedScan {
+  // Cursor: no process registry. The detail handler already stat'ed the jsonl;
+  // freshness of that file is the only honest working signal for the lens.
+  // Occupancy (the write gate) uses chats-dir resolution, not this hint.
+  if (provider === 'cursor') {
+    if (!isActiveRecently(mtimeMs, Date.now())) return { occupied: new Map(), degraded: false }
+    return {
+      occupied: new Map([[threadId, { threadId, owners: 1, foreignOwners: 0, activeRecently: true }]]),
+      degraded: false,
+    }
+  }
   if (provider !== 'claude' && provider !== 'codex') return { occupied: new Map(), degraded: false }
   try {
     const scan = occupiedThreads(
@@ -275,8 +286,8 @@ agentSessionsRouter.get('/agent-sessions', async (req, res) => {
     const sessions = await listAgentSessions(agentSessionRoots(), new Date(), live, limit, sort, dropped)
     const scan = runningThreads(sessions)
     // Freshness is layered on AFTER occupancy, and only over what occupancy
-    // found. `Date.now()` is read once so every row in a payload is judged
-    // against the same instant.
+    // found. Cursor has no process occupancy, so the list does not invent a
+    // working hint from jsonl mtime — detail still can, from the file it stat'ed.
     const running = withActiveRecently(scan, await transcriptMtimes(scan, sessions), Date.now())
     res.json({
       sessions: sessions.map(row => withRunning(toEntry(row), running)),

package/server/routes/meeting.ts

@@ -995,9 +995,10 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
    *
    * SAME GATES, no exceptions. It calls `enrolNamedVoice`, so raw-index mapping,
    * refusal when unmappable, voice coherence, the diversity cap and the
-   * `correction:<sessionId>` tag all apply identically. Rows whose `from` is a real
-   * person are skipped by that function's own placeholder rule, which is what keeps a
-   * mis-attribution correction (Allison Wheeler -> Kirstyn) out of the training set.
+   * `correction:<sessionId>` tag all apply identically. A named `from` is still
+   * enrolled when `to` is a real person — that is how a wrong existing match
+   * becomes a new profile (Nick Gurney → Milo LeBaron). Placeholder targets
+   * stay idle.
    *
    * FAILS CLOSED. Without `confirm: true` it reports what it would enrol and writes
    * nothing.

package/server/routes/thread-turn-queue.ts

@@ -206,6 +206,10 @@ export function createThreadTurnQueueRouter(deps: ThreadTurnQueueDeps): Router {
       return res.status(400).json({ error: 'invalid_request' })
     }
 
+    if (provider === 'cursor') {
+      return res.status(423).json({ error: 'unsupported_provider', queueable: false })
+    }
+
     // THE GATE DECIDES WHETHER PARKING IS EVEN HONEST. A structural refusal can never
     // clear, and telling someone their turn is queued when it can never run is worse
     // than refusing it. An attachable thread is not queued either -- it is sent now,