@gotcos/glasses-server 6.75.0 → 6.77.0

package/server/routes/meeting.ts

@@ -10,6 +10,7 @@ import { resolve } from 'node:path'
 import { createHash } from 'node:crypto'
 import { Router } from 'express'
 import { emitDisplay } from '../lib/display-bus.js'
+import { createStopRequestStore, isStopRequestRefusal, STOP_REQUEST_CLAIM_WINDOW_MS, type StopRequest, type StopRequestStore } from '../lib/meeting-stop-requests.js'
 import { cleanTranscriptLines } from '../lib/hallucination-filter.js'
 import { durableAtomicWriteFileSync } from '../lib/atomic-fs.js'
 import { appendCorrection, appliedCorrections, pendingCorrections } from '../lib/meeting-corrections.js'
@@ -181,6 +182,12 @@ import {
 } from '../lib/meeting-finalization-jobs.js'
 import { enrichStandaloneMeeting } from '../lib/meeting-summary-persistence.js'
 import { recordFinalPassSkip, runNemotronFinalPass, type FinalPassOptions, type FinalPassOutcome } from '../lib/nemotron-final.js'
+import { runTranscriptCleanup, type CleanupOutcome } from '../lib/transcript-cleanup.js'
+import { sweepTranscriptCleanupData } from '../lib/transcript-cleanup-screen.js'
+import type { TranscriptCleanupRouteDeps } from './transcript-cleanup.js'
+
+/** 6.77.0: the post-save transcript cleanup. Injectable so tests never reach a model. */
+export type TranscriptCleanupRunner = (input: { sessionId: string; meetingPath: string; sidecarPath: string }) => Promise<CleanupOutcome>
 
 /** 6.61.0: the save-time Nemotron pass. Injectable so tests never spawn the CLI. */
 export type FinalDiarize = (options: Pick<FinalPassOptions, 'meetingPath' | 'sidecarPath' | 'audioDir'>) => Promise<FinalPassOutcome>
@@ -240,6 +247,10 @@ export interface MeetingRouteDependencies {
   emit?: typeof emitDisplay
   finalizationJobs?: MeetingFinalizationJobStore
   finalDiarize?: FinalDiarize
+  /** Control's stop requests for live G2 meetings (lib/meeting-stop-requests.ts). */
+  stopRequests?: StopRequestStore
+  /** 6.77.0: the post-save transcript cleanup (lib/transcript-cleanup.ts). */
+  transcriptCleanup?: TranscriptCleanupRunner
 }
 
 const activeFinalizationJobs = new Set<string>()
@@ -251,6 +262,21 @@ interface FinalizationRuntime {
   scheduleBackground: (task: Promise<void>) => void
   sessions?: MeetingSessionSource
   finalDiarize?: FinalDiarize
+  transcriptCleanup?: TranscriptCleanupRunner
+}
+
+/**
+ * The cleanup as finalization runs it: a meeting whose session is somehow live again is
+ * skipped, and nothing it does can fail the finalization (it never throws; this catch is
+ * the last line of defence should that ever change).
+ */
+async function runCleanupStage(runner: TranscriptCleanupRunner | undefined, input: { sessionId: string; meetingPath: string; sidecarPath: string }, sessions?: MeetingSessionSource): Promise<void> {
+  const run = runner ?? (cleanupInput => runTranscriptCleanup(cleanupInput, { sessionLive: id => (sessions?.getState ?? defaultSessionState)(id) === 'active' }))
+  try {
+    await run(input)
+  } catch (error) {
+    console.warn(`[meeting/save] transcript cleanup threw; the saved transcript is unchanged: ${error instanceof Error ? error.name : 'error'}`)
+  }
 }
 
 function validReplayEntries(raw: unknown[]): IndexedTranscriptChunk[] | null {
@@ -369,6 +395,11 @@ function scheduleFinalizationJob(job: MeetingFinalizationJob, runtime: Finalizat
       markCanonicalFinalizationState(current.sidecarPath, 'ops_pending', current.claimPending)
     }
 
+    // 6.77.0: the transcript is final here (HQ text and the Nemotron relabel are written),
+    // and nothing downstream has read it yet: COS operations imports, and the standalone
+    // summary describes, the cleaned text. Off unless Miles turns it on.
+    await runCleanupStage(runtime.transcriptCleanup, { sessionId: current.sessionId, meetingPath: current.meetingPath, sidecarPath: current.sidecarPath }, runtime.sessions)
+
     if (cosOpsPipelineConfigured() && !MAC_CAPTURE_ID.test(current.sessionId)) {
       await handoffMeetingToOperations(current.meetingPath)
     } else {
@@ -555,8 +586,10 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
   const emit = deps.emit ?? emitDisplay
   const finalizationJobs = deps.finalizationJobs ?? new MeetingFinalizationJobStore()
   const finalDiarize = deps.finalDiarize ?? runNemotronFinalPass
+  const transcriptCleanup = deps.transcriptCleanup
   const router = Router()
   const savingSessions = new Set<string>()
+  const stopRequests = deps.stopRequests ?? createStopRequestStore()
   setNamingSessionLiveness(id => sessions.getStartTime(id) !== null || savingSessions.has(id) || activeFinalizationJobs.has(id))
 
   let recoveryPendingLogged = false
@@ -624,6 +657,114 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     })
   })
 
+  // ── Stop a live G2 meeting from the Mac (COS Control) ────────────────────────────
+  // The Mac never saves a live G2 session itself (lib/meeting-stop-requests.ts says why).
+  // It asks the glasses: POST records the request and puts `meeting_stop_requested` on the
+  // display bus; the companion claims it within the claim window and runs its own Stop;
+  // Control polls GET until the meeting is saved, or says no glasses answered.
+  const stopRequestBody = (request: StopRequest, extra: Record<string, unknown> = {}) => ({
+    sessionId: request.sessionId,
+    requestId: request.requestId,
+    state: request.state,
+    requestedAt: request.requestedAt,
+    claimedAt: request.claimedAt,
+    refusal: request.refusal,
+    claimWindowMs: STOP_REQUEST_CLAIM_WINDOW_MS,
+    ...extra,
+  })
+  const stopRequestSessionId = (req: { params: Record<string, unknown> }, res: { status(code: number): { json(body: unknown): void } }): string | null => {
+    const sessionId = String(req.params.sessionId ?? '')
+    if (!/^[A-Za-z0-9:_-]{3,96}$/.test(sessionId)) {
+      res.status(400).json({ error: 'Invalid sessionId', reason: 'invalid_session_id' })
+      return null
+    }
+    if (MAC_CAPTURE_ID.test(sessionId)) {
+      // A Mac recording stops from Control itself; it has no glasses to ask.
+      res.status(400).json({ error: 'A Mac recording stops from Record on Mac', reason: 'mac_capture' })
+      return null
+    }
+    return sessionId
+  }
+
+  router.post('/meeting/sessions/:sessionId/stop-request', (req, res) => {
+    const sessionId = stopRequestSessionId(req, res)
+    if (!sessionId) return
+    res.set('Cache-Control', 'private, no-store')
+    const saved = store.findBySessionId(sessionId)
+    if (saved) {
+      res.json({ sessionId, state: 'saved', saveReceipt: publicSaveResponse(saved, true) })
+      return
+    }
+    if (savingSessions.has(sessionId)) {
+      res.json({ sessionId, state: 'finalizing' })
+      return
+    }
+    const live = (sessions.getState ?? defaultSessionState)(sessionId)
+    if (live !== 'active') {
+      res.status(409).json({ error: 'This meeting is not recording', reason: 'not_live', state: live })
+      return
+    }
+    const body = req.body as Record<string, unknown> | undefined
+    const source = typeof body?.source === 'string' && /^[a-z][a-z0-9_-]{0,31}$/.test(body.source) ? body.source : 'control'
+    const request = stopRequests.request(sessionId, source)
+    try {
+      emit({
+        type: 'meeting_stop_requested',
+        data: { sessionId, requestId: request.requestId, source, claimWindowMs: STOP_REQUEST_CLAIM_WINDOW_MS },
+      })
+    } catch (error) {
+      console.warn('[meeting/stop-request] Display notification failed:', error)
+    }
+    console.log(`[meeting/stop-request] ${source} asked the glasses to stop ${sessionId} (${request.requestId})`)
+    res.status(202).json(stopRequestBody(request))
+  })
+
+  // The companion's answer: `accept` claims the request (then it stops), `refuse` says why not.
+  router.post('/meeting/sessions/:sessionId/stop-request/:requestId/claim', (req, res) => {
+    const sessionId = stopRequestSessionId(req, res)
+    if (!sessionId) return
+    res.set('Cache-Control', 'private, no-store')
+    const requestId = String(req.params.requestId ?? '')
+    const body = req.body as Record<string, unknown> | undefined
+    const decision = body?.decision
+    if (decision !== 'accept' && decision !== 'refuse') {
+      res.status(400).json({ error: 'decision must be accept or refuse', reason: 'invalid_decision' })
+      return
+    }
+    if (decision === 'refuse' && !isStopRequestRefusal(body?.reason)) {
+      res.status(400).json({ error: 'Unknown refusal reason', reason: 'invalid_refusal' })
+      return
+    }
+    const result = decision === 'accept'
+      ? stopRequests.claim(sessionId, requestId)
+      : stopRequests.refuse(sessionId, requestId, body!.reason as Parameters<StopRequestStore['refuse']>[2])
+    if (!result.ok) {
+      const status = result.reason === 'unknown_request' ? 404 : 409
+      res.status(status).json({ error: 'Stop request is not open', reason: result.reason })
+      return
+    }
+    console.log(`[meeting/stop-request] glasses ${decision === 'accept' ? 'claimed' : 'refused'} ${result.request.requestId}${result.request.refusal ? ` (${result.request.refusal})` : ''}`)
+    res.json(stopRequestBody(result.request))
+  })
+
+  // Control's poll. A saved meeting answers `saved` with its receipt, whatever the request says.
+  router.get('/meeting/sessions/:sessionId/stop-request/:requestId', (req, res) => {
+    const sessionId = stopRequestSessionId(req, res)
+    if (!sessionId) return
+    res.set('Cache-Control', 'private, no-store')
+    const request = stopRequests.get(sessionId, String(req.params.requestId ?? ''))
+    if (!request) {
+      res.status(404).json({ error: 'Unknown stop request', reason: 'unknown_request' })
+      return
+    }
+    const saved = store.findBySessionId(sessionId)
+    if (saved) {
+      res.json(stopRequestBody(request, { state: 'saved', saveReceipt: publicSaveResponse(saved, true) }))
+      return
+    }
+    res.json(stopRequestBody(request, savingSessions.has(sessionId) ? { finalizing: true } : {}))
+  })
+
   router.post('/meeting/save', async (req, res) => {
     let lockedSessionId: string | null = null
     let maintenanceLease: MaintenanceWorkLease | undefined
@@ -668,6 +809,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
         finalizationJobs.reconcileCanonicalSidecars()
         const pendingJob = finalizationJobs.get(sessionId)
         if (pendingJob) scheduleFinalizationJob(pendingJob, {
+          transcriptCleanup,
           finalizationJobs,
           runBatch,
           scheduleBackground,
@@ -844,6 +986,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
           scheduleBackground,
           sessions,
           finalDiarize,
+          transcriptCleanup,
         })
       }
     } catch (error) {
@@ -2326,6 +2469,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
           },
         })
       } catch { /* display is best-effort */ }
+      await runCleanupStage(transcriptCleanup, { sessionId, meetingPath: saved.filepath, sidecarPath: saved.sidecarPath }, sessions)
       if (cosOpsPipelineConfigured() && !macCapture) {
         await handoffMeetingToOperations(saved.filepath)
       } else {
@@ -2508,3 +2652,36 @@ async function finalizeBatch(options: {
 }
 
 export const meetingRouter = createMeetingRouter()
+
+/** 6.77.0: what the transcript cleanup routes need from the meeting layer. */
+export function transcriptCleanupRouteDeps(store: MeetingStore = getMeetingStore()): TranscriptCleanupRouteDeps {
+  return {
+    sessionState: id => defaultSessionState(id),
+    sessionStartedAt: id => getSessionStartTime(id),
+    findMeeting: id => {
+      const meeting = store.findBySessionId(id)
+      return meeting ? { meetingPath: meeting.filepath, sidecarPath: meeting.sidecarPath } : null
+    },
+  }
+}
+
+/**
+ * Boot: delete cleanup data (screen context and ledgers) whose meeting is gone, and screen
+ * text past its retention. Deferred and unref'd, so it never delays startup or a restart.
+ */
+export function scheduleTranscriptCleanupSweep(delayMs = 90_000): void {
+  const timer = setTimeout(() => {
+    try {
+      const store = getMeetingStore()
+      const jobs = new MeetingFinalizationJobStore()
+      const result = sweepTranscriptCleanupData({
+        now: Date.now(),
+        known: id => defaultSessionState(id) !== 'missing' || Boolean(jobs.get(id)) || store.findBySessionId(id) !== null,
+      })
+      if (result.screenDeleted || result.ledgersDeleted) {
+        console.log(`[transcript-cleanup] swept ${result.screenDeleted} screen and ${result.ledgersDeleted} ledger files`)
+      }
+    } catch { /* the next boot sweeps again */ }
+  }, delayMs)
+  timer.unref()
+}

package/server/routes/transcribe.ts

@@ -37,6 +37,9 @@ transcribeRouter.get('/transcribe/capabilities', (_req, res) => {
     localOnly: true,
     dictionary: 'cos',
     benchmark: 1,
+    // 6.77.0: post-save transcript cleanup. suggestions = /api/transcript-cleanup/suggestions,
+    // screenContext = POST /api/meeting/:sessionId/screen-context.
+    transcriptCleanup: { protocol: 1, suggestions: 1, screenContext: 1 },
   })
 })
 

package/server/routes/transcript-cleanup.ts

@@ -0,0 +1,237 @@
+// Transcript cleanup routes (6.77.0). Token-authenticated by the global /api X-Cos-Token
+// middleware (index.ts) like every other /api route; nothing here is public.
+//
+// Settings (COS Control's toggle, later):
+//   GET  /transcript-cleanup/settings                  { enabled, source, model, modelSource, limits, today }
+//   POST /transcript-cleanup/settings { enabled?, model? }   same shape; 409 env_forced when env pins the value
+// Screen context (COS Control supplies on-screen text during a meeting, later):
+//   POST   /meeting/:sessionId/screen-context { lines: [{ at, text, app? }] }  counts of what was stored
+//   GET    /meeting/:sessionId/screen-context            counts only, never the text
+//   DELETE /meeting/:sessionId/screen-context            { deleted }
+// The cleanup ledger of one meeting:
+//   GET  /meeting/:sessionId/transcript-cleanup          { runs, edits }  (edits carry original and replacement words)
+//   POST /meeting/:sessionId/transcript-cleanup/undo { editId } | { runId }
+// Dictionary suggestions (COS Control's Dictionary tab, later):
+//   GET  /transcript-cleanup/suggestions?status=pending|all
+//   POST /transcript-cleanup/suggestions/:id/accept { correction? }
+//   POST /transcript-cleanup/suggestions/:id/dismiss
+
+import { Router } from 'express'
+import { appendScreenContext, deleteScreenContext, ScreenContextError, SESSION_ID, screenContextStats } from '../lib/transcript-cleanup-screen.js'
+import { alreadyCleaned, ledgerView, readLedger, readTranscriptSection, sha256, undoCleanupEdits } from '../lib/transcript-cleanup-ledger.js'
+import { cleanupLimits, resolveCleanupModel, resolveCleanupSwitch, transcriptCleanupBudget, transcriptCleanupSettings, type TranscriptCleanupBudget, type TranscriptCleanupSettings } from '../lib/transcript-cleanup-state.js'
+import { SUGGESTION_ID, suggestionStore, type DictionarySuggestion, type SuggestionStore } from '../lib/transcript-cleanup-suggestions.js'
+import { getVocabulary } from '../lib/profile.js'
+import { readFileSync } from 'node:fs'
+
+export const TRANSCRIPT_CLEANUP_PROTOCOL = 1
+
+type GlossaryOutcome = { status: number; body: unknown }
+
+export interface TranscriptCleanupRouteDeps {
+  env?: NodeJS.ProcessEnv
+  now?: () => Date
+  settings?: TranscriptCleanupSettings
+  budget?: TranscriptCleanupBudget
+  suggestions?: SuggestionStore
+  /** 'active' while the meeting is being recorded. */
+  sessionState?: (sessionId: string) => 'active' | 'closed' | 'missing'
+  sessionStartedAt?: (sessionId: string) => number | null
+  /** The saved meeting's files, or null. */
+  findMeeting?: (sessionId: string) => { meetingPath: string; sidecarPath: string } | null
+  addVocabulary?: (term: string) => Promise<GlossaryOutcome>
+  learnCorrection?: (body: { heard: string; written: string; source: 'meeting' }) => Promise<GlossaryOutcome>
+  vocabulary?: () => string[]
+}
+
+/** Health and capability shape. Codes only: /api/health is public. */
+export function transcriptCleanupAdvertised(env: NodeJS.ProcessEnv = process.env, settings: TranscriptCleanupSettings = transcriptCleanupSettings()): { protocol: number; enabled: boolean } {
+  let enabled = false
+  try { enabled = resolveCleanupSwitch(env, settings).enabled } catch { enabled = false }
+  return { protocol: TRANSCRIPT_CLEANUP_PROTOCOL, enabled }
+}
+
+function suggestionView(s: DictionarySuggestion, vocabulary: string[]): DictionarySuggestion & { inVocabulary: boolean } {
+  const lower = s.written.trim().toLowerCase()
+  return { ...s, inVocabulary: vocabulary.some(v => v.trim().toLowerCase() === lower) }
+}
+
+export function createTranscriptCleanupRouter(deps: TranscriptCleanupRouteDeps = {}): Router {
+  const env = deps.env ?? process.env
+  const now = deps.now ?? (() => new Date())
+  const settings = deps.settings ?? transcriptCleanupSettings()
+  const budget = deps.budget ?? transcriptCleanupBudget()
+  const suggestions = deps.suggestions ?? suggestionStore()
+  const sessionState = deps.sessionState ?? (() => 'missing' as const)
+  const sessionStartedAt = deps.sessionStartedAt ?? (() => null)
+  const findMeeting = deps.findMeeting ?? (() => null)
+  const vocabulary = deps.vocabulary ?? (() => { try { return getVocabulary() } catch { return [] } })
+  const addVocabulary = deps.addVocabulary ?? (async term => (await import('./glossary.js')).glossaryAddVocabulary(term))
+  const learnCorrection = deps.learnCorrection ?? (async body => (await import('./glossary.js')).glossaryLearnCorrection(body))
+  const router = Router()
+
+  const settingsView = () => {
+    const sw = resolveCleanupSwitch(env, settings)
+    const model = resolveCleanupModel(env, settings)
+    const limits = cleanupLimits(env)
+    const state = budget.read()
+    return {
+      protocol: TRANSCRIPT_CLEANUP_PROTOCOL,
+      enabled: sw.enabled,
+      source: sw.source,
+      model: model.choice,
+      modelId: model.id,
+      modelSource: model.source,
+      limits: { dailyCalls: limits.dailyCalls, dailyTokens: limits.dailyTokens, maxSpansPerMeeting: limits.maxSpans },
+      today: {
+        calls: Math.min(state.calls, Number.MAX_SAFE_INTEGER),
+        tokens: Math.min(state.tokens, Number.MAX_SAFE_INTEGER),
+        breakerOpenUntil: state.breakerOpenUntil !== null && state.breakerOpenUntil > now().getTime() ? new Date(state.breakerOpenUntil).toISOString() : null,
+      },
+    }
+  }
+
+  router.get('/transcript-cleanup/settings', (_req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    try { return res.json(settingsView()) } catch { return res.status(503).json({ error: 'settings_unavailable' }) }
+  })
+
+  router.post('/transcript-cleanup/settings', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const body = req.body as { enabled?: unknown; model?: unknown } | undefined
+    if (!body || typeof body !== 'object' || Array.isArray(body)) return res.status(400).json({ error: 'invalid_request' })
+    const hasEnabled = body.enabled !== undefined, hasModel = body.model !== undefined
+    if ((!hasEnabled && !hasModel) || (hasEnabled && typeof body.enabled !== 'boolean') || (hasModel && body.model !== 'haiku' && body.model !== 'sonnet')) {
+      return res.status(400).json({ error: 'invalid_request' })
+    }
+    if (hasEnabled && (env.COS_TRANSCRIPT_CLEANUP === '1' || env.COS_TRANSCRIPT_CLEANUP === '0') && body.enabled !== (env.COS_TRANSCRIPT_CLEANUP === '1')) {
+      return res.status(409).json({ error: 'env_forced' })
+    }
+    if (hasModel && (env.COS_TRANSCRIPT_CLEANUP_MODEL === 'haiku' || env.COS_TRANSCRIPT_CLEANUP_MODEL === 'sonnet') && body.model !== env.COS_TRANSCRIPT_CLEANUP_MODEL) {
+      return res.status(409).json({ error: 'env_forced' })
+    }
+    try {
+      settings.save({ ...(hasEnabled ? { enabled: body.enabled as boolean } : {}), ...(hasModel ? { model: body.model as 'haiku' | 'sonnet' } : {}) }, now())
+      return res.json(settingsView())
+    } catch {
+      return res.status(500).json({ error: 'settings_write_failed' })
+    }
+  })
+
+  const sessionParam = (raw: string | undefined): string | null => (raw && SESSION_ID.test(raw) ? raw : null)
+
+  /** A late flush right after stop is welcome until the cleanup has run on the saved meeting. */
+  function screenAdmission(sessionId: string): { ok: true } | { ok: false; status: number; error: string } {
+    if (sessionState(sessionId) === 'active') return { ok: true }
+    const meeting = findMeeting(sessionId)
+    if (!meeting) return { ok: false, status: 404, error: 'unknown_session' }
+    const done = readLedger(sessionId).rows.some(r => r.kind === 'run' && (r.phase === 'done' || r.phase === 'skipped'))
+    return done ? { ok: false, status: 409, error: 'cleanup_done' } : { ok: true }
+  }
+
+  router.post('/meeting/:sessionId/screen-context', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const sessionId = sessionParam(req.params.sessionId)
+    if (!sessionId) return res.status(400).json({ error: 'invalid_session_id' })
+    const admission = screenAdmission(sessionId)
+    if (!admission.ok) return res.status(admission.status).json({ error: admission.error })
+    try {
+      const result = appendScreenContext(sessionId, req.body, { now: now().getTime(), sessionStartedAt: sessionStartedAt(sessionId) })
+      return res.json({ ok: true, protocol: TRANSCRIPT_CLEANUP_PROTOCOL, ...result })
+    } catch (error) {
+      if (error instanceof ScreenContextError) return res.status(error.status).json({ error: error.code })
+      return res.status(503).json({ error: 'screen_context_unavailable' })
+    }
+  })
+
+  router.get('/meeting/:sessionId/screen-context', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const sessionId = sessionParam(req.params.sessionId)
+    if (!sessionId) return res.status(400).json({ error: 'invalid_session_id' })
+    return res.json({ protocol: TRANSCRIPT_CLEANUP_PROTOCOL, ...screenContextStats(sessionId) })
+  })
+
+  router.delete('/meeting/:sessionId/screen-context', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const sessionId = sessionParam(req.params.sessionId)
+    if (!sessionId) return res.status(400).json({ error: 'invalid_session_id' })
+    try { return res.json({ deleted: deleteScreenContext(sessionId) }) } catch { return res.status(500).json({ error: 'delete_failed' }) }
+  })
+
+  router.get('/meeting/:sessionId/transcript-cleanup', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const sessionId = sessionParam(req.params.sessionId)
+    if (!sessionId) return res.status(400).json({ error: 'invalid_session_id' })
+    const view = ledgerView(sessionId)
+    let current: string | null = null
+    const meeting = findMeeting(sessionId)
+    if (meeting) {
+      try { const section = readTranscriptSection(readFileSync(meeting.meetingPath, 'utf8')); current = section === null ? null : sha256(section) } catch { current = null }
+    }
+    return res.json({ protocol: TRANSCRIPT_CLEANUP_PROTOCOL, ...view, cleanedCurrent: current !== null && alreadyCleaned(sessionId, current) })
+  })
+
+  router.post('/meeting/:sessionId/transcript-cleanup/undo', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const sessionId = sessionParam(req.params.sessionId)
+    if (!sessionId) return res.status(400).json({ error: 'invalid_session_id' })
+    const body = (req.body ?? {}) as { editId?: unknown; runId?: unknown }
+    const editId = typeof body.editId === 'string' && /^te_[0-9a-f]{16}$/.test(body.editId) ? body.editId : undefined
+    const runId = typeof body.runId === 'string' && /^tc_[0-9a-f]{16}$/.test(body.runId) ? body.runId : undefined
+    if (!editId === !runId) return res.status(400).json({ error: 'editId_or_runId_required' })
+    const meeting = findMeeting(sessionId)
+    if (!meeting) return res.status(404).json({ error: 'meeting_missing' })
+    const result = undoCleanupEdits({ sessionId, meetingPath: meeting.meetingPath, sidecarPath: meeting.sidecarPath, editId, runId, now })
+    if (!result.ok) return res.status(result.status).json({ error: result.error })
+    return res.json({ reverted: result.reverted })
+  })
+
+  router.get('/transcript-cleanup/suggestions', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const status = typeof req.query.status === 'string' ? req.query.status : 'pending'
+    if (status !== 'pending' && status !== 'all') return res.status(400).json({ error: 'invalid_status' })
+    const vocab = vocabulary()
+    const list = suggestions.list().filter(s => status === 'all' || s.status === 'pending')
+      .sort((a, b) => b.updatedAt.localeCompare(a.updatedAt)).map(s => suggestionView(s, vocab))
+    return res.json({ protocol: TRANSCRIPT_CLEANUP_PROTOCOL, suggestions: list })
+  })
+
+  router.post('/transcript-cleanup/suggestions/:id/accept', async (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const id = req.params.id
+    if (!SUGGESTION_ID.test(id)) return res.status(400).json({ error: 'invalid_suggestion_id' })
+    const body = (req.body ?? {}) as { correction?: unknown }
+    if (body.correction !== undefined && typeof body.correction !== 'boolean') return res.status(400).json({ error: 'invalid_request' })
+    const suggestion = suggestions.get(id)
+    if (!suggestion) return res.status(404).json({ error: 'suggestion_not_found' })
+    if (suggestion.status === 'dismissed') return res.status(409).json({ error: 'suggestion_dismissed' })
+    try {
+      const heard = suggestion.heard.find(h => h.trim().toLowerCase() !== suggestion.written.trim().toLowerCase())
+      const outcome = body.correction === true && heard
+        ? await learnCorrection({ heard, written: suggestion.written, source: 'meeting' })
+        : await addVocabulary(suggestion.written)
+      if (outcome.status !== 200) return res.status(outcome.status).json(outcome.body)
+      const accepted = suggestions.setStatus(id, 'accepted', now().toISOString()) ?? suggestion
+      const out = outcome.body as { unchanged?: boolean; glossary?: unknown; entry?: unknown }
+      return res.json({ suggestion: suggestionView(accepted, vocabulary()), unchanged: out.unchanged === true, glossary: out.glossary ?? null, entry: out.entry ?? null })
+    } catch {
+      return res.status(500).json({ error: 'accept_failed' })
+    }
+  })
+
+  router.post('/transcript-cleanup/suggestions/:id/dismiss', (req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    const id = req.params.id
+    if (!SUGGESTION_ID.test(id)) return res.status(400).json({ error: 'invalid_suggestion_id' })
+    try {
+      const dismissed = suggestions.setStatus(id, 'dismissed', now().toISOString())
+      if (!dismissed) return res.status(404).json({ error: 'suggestion_not_found' })
+      return res.json({ suggestion: suggestionView(dismissed, vocabulary()) })
+    } catch {
+      return res.status(500).json({ error: 'dismiss_failed' })
+    }
+  })
+
+  return router
+}
+