@gotcos/glasses-server 6.24.2 → 6.24.4

package/server/lib/query-attachments.ts

@@ -15,20 +15,28 @@
 import {
   MAX_ATTACHMENTS_PER_PROMPT,
   isValidMediaId,
+  mediaCategoryOf,
   parseMediaIdList,
   type MediaAttachmentRef,
 } from '../../shared/media-attachment.js'
 import { getMediaStore, MediaStoreError } from './media-store.js'
 import { strictBase64Decode, ImageSafetyError } from './image-safety.js'
 import type { ModelImageInput } from './model-image-input.js'
+import { formatAttachmentSourceData, type AttachmentSourceData } from './prompt-reference-boundary.js'
 
 export interface ResolvedQueryAttachments {
   inputs: ModelImageInput[]
   refs: MediaAttachmentRef[]
   /** Ids to associate with the final message when the run completes. */
   ids: string[]
+  /** Provider-neutral quoted document data. Rebuilt at execution time; never
+   * persisted in a durable job or public attachment ref. */
+  promptBlock?: string
 }
 
+const MAX_MODEL_IMAGE_INPUTS = 12
+const MAX_ATTACHMENT_PROMPT_CHARS = 60_000
+
 export class QueryAttachmentError extends Error {
   readonly status: number
   readonly code: string
@@ -89,6 +97,11 @@ export async function resolveQueryAttachments(body: QueryImageBody): Promise<Res
       : undefined
 
     const inputs: ModelImageInput[] = []
+    const refs: MediaAttachmentRef[] = []
+    const resolvedIds: string[] = []
+    const sourceData: AttachmentSourceData[] = []
+    const optionalDocumentImages: Array<{ path: string; attachment: MediaAttachmentRef }> = []
+    let promptChars = 0
 
     // Reject over-limit requests BEFORE the shared parser caps them. Silent
     // truncation would run a successful vision query while dropping a user's
@@ -107,8 +120,39 @@ export async function resolveQueryAttachments(body: QueryImageBody): Promise<Res
     // 1. Durable attachment ids.
     const ids = parseMediaIdList(body.attachmentIds)
     for (const id of ids) {
-      const { record, path } = store.resolveUsable(id, clientQueueItemId)
-      inputs.push({ path, attachment: record.ref, deleteAfterRun: false })
+      const resolved = store.resolveModelDerivatives(id, clientQueueItemId)
+      const category = mediaCategoryOf(resolved.record.ref)
+      refs.push(resolved.record.ref)
+      resolvedIds.push(id)
+      if (category === 'image') {
+        inputs.push({ path: resolved.originalPath, attachment: resolved.record.ref, deleteAfterRun: false })
+      } else if (category === 'video') {
+        for (const path of resolved.imagePaths) {
+          inputs.push({ path, attachment: resolved.record.ref, deleteAfterRun: false })
+        }
+      } else {
+        // PDF page images are an optional layout aid. Text remains canonical;
+        // use only the remaining image budget instead of dropping user photos
+        // or making a text-readable PDF fail because it has many pages.
+        for (const path of resolved.imagePaths) optionalDocumentImages.push({ path, attachment: resolved.record.ref })
+        if (resolved.text !== undefined) {
+          const room = Math.max(0, MAX_ATTACHMENT_PROMPT_CHARS - promptChars)
+          const content = resolved.text.slice(0, room)
+          const truncated = content.length < resolved.text.length || resolved.record.ref.truncated === true
+          sourceData.push({
+            id,
+            label: resolved.record.ref.label ?? 'Attached document',
+            mime: resolved.record.ref.mime,
+            content,
+            ...(truncated ? { truncated: true } : {}),
+          })
+          promptChars += content.length
+        }
+      }
+    }
+    const requiredVisualCount = inputs.filter(input => mediaCategoryOf(input.attachment) !== 'document').length
+    if (requiredVisualCount > MAX_MODEL_IMAGE_INPUTS) {
+      throw new QueryAttachmentError(400, 'too_many_attachment_frames', `max ${MAX_MODEL_IMAGE_INPUTS} image/video frames per prompt`)
     }
 
     // 2. Legacy base64 — ingested through the SAME store (no bypass).
@@ -118,12 +162,26 @@ export async function resolveQueryAttachments(body: QueryImageBody): Promise<Res
       const ref = await store.ingestImage({ bytes, kind: 'user_photo', sessionId })
       const { path } = store.resolveUsable(ref.id)
       inputs.push({ path, attachment: ref, deleteAfterRun: false })
+      refs.push(ref)
+      resolvedIds.push(ref.id)
+    }
+
+    // PDF page renders are optional aids. Add them only after all required
+    // photo and video inputs so a PDF can never evict a user's visual source.
+    const remaining = Math.max(0, MAX_MODEL_IMAGE_INPUTS - inputs.length)
+    for (const item of optionalDocumentImages.slice(0, remaining)) {
+      inputs.push({ path: item.path, attachment: item.attachment, deleteAfterRun: false })
+    }
+
+    if (inputs.length > MAX_MODEL_IMAGE_INPUTS) {
+      throw new QueryAttachmentError(400, 'too_many_attachment_frames', `max ${MAX_MODEL_IMAGE_INPUTS} image/video frames per prompt`)
     }
 
     return {
       inputs,
-      refs: inputs.map((i) => i.attachment),
-      ids: inputs.map((i) => i.attachment.id),
+      refs,
+      ids: resolvedIds,
+      ...(sourceData.length > 0 ? { promptBlock: formatAttachmentSourceData(sourceData) } : {}),
     }
   } catch (err) {
     if (err instanceof QueryAttachmentError) throw err

package/server/lib/query-job-runtime.ts

@@ -18,6 +18,7 @@ import {
   type ModelPreference,
 } from '../../shared/model-preference.js'
 import { mergeMediaAttachmentRefs } from '../../shared/media-attachment.js'
+import { attachmentHistoryPrefix, defaultAttachmentRequest } from '../../shared/media-attachment.js'
 import {
   findExchangesByJobIdentity,
   flushConversationToDisk,
@@ -99,9 +100,11 @@ async function projectPublicConversationTerminal(
 
   const existing = findExchangesByJobIdentity(request.sessionId, identity)
   const existingAssistant = existing.find(exchange => exchange.role === 'assistant')
-  const imageCount = request.attachmentRefs.length
-  const photoPrefix = imageCount === 1 ? '[Photo]' : imageCount > 1 ? `[${imageCount} Photos]` : ''
-  const userContent = photoPrefix ? `${photoPrefix} ${request.query || 'What do you see?'}` : request.query
+  const attachmentPrefix = attachmentHistoryPrefix(request.attachmentRefs)
+  const defaultRequest = defaultAttachmentRequest(request.attachmentRefs)
+  const userContent = attachmentPrefix
+    ? `${attachmentPrefix} ${request.query || defaultRequest}`
+    : request.query
   const requestIds = new Set(request.attachmentRefs.map(ref => ref.id))
   const outputAttachments = job.attachments.filter(ref => !requestIds.has(ref.id))
   const existingOutputAttachments = existingAssistant?.attachments?.filter(ref => !requestIds.has(ref.id))
@@ -281,6 +284,8 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
         : {}),
       clientJobId: request.clientJobId,
       generation: request.generation,
+      requestAttachments: resolvedAttachments.refs,
+      attachmentPromptBlock: resolvedAttachments.promptBlock,
       sessionLockHeld: true,
     },
   )

package/server/lib/rich-media-safety.ts

@@ -0,0 +1,324 @@
+// Strict document/video validation and derivative generation for user uploads.
+// Paths and filenames never enter the public attachment contract. Inputs are
+// bounded bytes from the authenticated binary route; no URL/path ingestion.
+
+import { spawn } from 'node:child_process'
+import {
+  mkdtempSync,
+  readFileSync,
+  readdirSync,
+  rmSync,
+  writeFileSync,
+} from 'node:fs'
+import { tmpdir } from 'node:os'
+import { extname, join } from 'node:path'
+import type { MediaMime } from '../../shared/media-attachment.js'
+
+export const MAX_RICH_MEDIA_BYTES = 64 * 1024 * 1024
+export const MAX_DOCUMENT_TEXT_CHARS = 100_000
+export const MAX_VIDEO_DURATION_MS = 20 * 60_000
+export const MAX_DERIVATIVE_IMAGES = 8
+const PROCESS_STDERR_MAX = 8_192
+const PROCESS_TIMEOUT_MS = 30_000
+
+let richMediaCapabilityCache: { pdf: boolean; video: boolean } | null = null
+
+export type RichMediaErrorCode =
+  | 'unsupported_attachment_format'
+  | 'attachment_too_large'
+  | 'corrupt_attachment'
+  | 'attachment_processing_unavailable'
+  | 'attachment_processing_failed'
+  | 'video_too_long'
+
+export class RichMediaSafetyError extends Error {
+  constructor(readonly code: RichMediaErrorCode, message: string) {
+    super(message)
+    this.name = 'RichMediaSafetyError'
+  }
+}
+
+export interface PreparedDocument {
+  category: 'document'
+  mime: Extract<MediaMime, 'text/plain' | 'text/markdown' | 'text/csv' | 'application/json' | 'application/pdf'>
+  original: Buffer
+  extractedText: string
+  textTruncated: boolean
+  pageImages: Buffer[]
+}
+
+export interface PreparedVideo {
+  category: 'video'
+  mime: Extract<MediaMime, 'video/mp4' | 'video/quicktime'>
+  original: Buffer
+  width: number
+  height: number
+  durationMs: number
+  frames: Buffer[]
+}
+
+export type PreparedRichMedia = PreparedDocument | PreparedVideo
+
+async function executableReady(command: string, args: string[]): Promise<boolean> {
+  return new Promise(resolve => {
+    let settled = false
+    let timer: ReturnType<typeof setTimeout> | null = null
+    const finish = (ready: boolean) => {
+      if (settled) return
+      settled = true
+      if (timer) clearTimeout(timer)
+      resolve(ready)
+    }
+    let proc: ReturnType<typeof spawn>
+    try {
+      proc = spawn(command, args, { stdio: 'ignore' })
+    } catch {
+      finish(false)
+      return
+    }
+    timer = setTimeout(() => {
+      proc.kill('SIGKILL')
+      finish(false)
+    }, 2_000)
+    timer.unref?.()
+    proc.once('error', () => finish(false))
+    proc.once('close', code => finish(code === 0))
+  })
+}
+
+/** Public capability only—never paths. Cached because health is polled often. */
+export async function getRichMediaProcessingCapabilities(): Promise<{ pdf: boolean; video: boolean }> {
+  if (richMediaCapabilityCache) return { ...richMediaCapabilityCache }
+  const [pdftotext, pdftoppm, ffmpeg, ffprobe] = await Promise.all([
+    executableReady('pdftotext', ['-v']),
+    executableReady('pdftoppm', ['-v']),
+    executableReady('ffmpeg', ['-version']),
+    executableReady('ffprobe', ['-version']),
+  ])
+  richMediaCapabilityCache = { pdf: pdftotext && pdftoppm, video: ffmpeg && ffprobe }
+  return { ...richMediaCapabilityCache }
+}
+
+export function _resetRichMediaCapabilityCacheForTests(): void {
+  richMediaCapabilityCache = null
+}
+
+function boundedLabel(label: string | undefined): string {
+  return (label ?? '').replace(/[\u0000-\u001f\u007f]/g, '').trim().slice(0, 120)
+}
+
+function fileExtension(label: string | undefined): string {
+  return extname(boundedLabel(label)).toLowerCase()
+}
+
+function isPdf(bytes: Buffer): boolean {
+  return bytes.length >= 5 && bytes.subarray(0, 5).toString('ascii') === '%PDF-'
+}
+
+function isIsoBmff(bytes: Buffer): boolean {
+  return bytes.length >= 12 && bytes.subarray(4, 8).toString('ascii') === 'ftyp'
+}
+
+function decodeStrictUtf8(bytes: Buffer): string {
+  if (bytes.includes(0)) throw new RichMediaSafetyError('corrupt_attachment', 'text attachment contains NUL bytes')
+  let text: string
+  try {
+    text = new TextDecoder('utf-8', { fatal: true }).decode(bytes)
+  } catch {
+    throw new RichMediaSafetyError('corrupt_attachment', 'text attachment is not valid UTF-8')
+  }
+  const sample = text.slice(0, 20_000)
+  const printable = [...sample].filter(ch => ch === '\n' || ch === '\r' || ch === '\t' || ch >= ' ').length
+  if (sample.length > 0 && printable / sample.length < 0.9) {
+    throw new RichMediaSafetyError('corrupt_attachment', 'text attachment contains too much control data')
+  }
+  return text.replace(/\r\n?/g, '\n')
+}
+
+function capText(text: string): { text: string; truncated: boolean } {
+  const normalized = text.replace(/\u0000/g, '').trim()
+  if (normalized.length <= MAX_DOCUMENT_TEXT_CHARS) return { text: normalized, truncated: false }
+  return {
+    text: `${normalized.slice(0, MAX_DOCUMENT_TEXT_CHARS)}\n\n[Document truncated by COS at ${MAX_DOCUMENT_TEXT_CHARS} characters.]`,
+    truncated: true,
+  }
+}
+
+async function runProcess(command: string, args: string[], timeoutMs = PROCESS_TIMEOUT_MS): Promise<void> {
+  await new Promise<void>((resolve, reject) => {
+    let settled = false
+    let stderr = ''
+    const proc = spawn(command, args, { stdio: ['ignore', 'ignore', 'pipe'] })
+    const timer = setTimeout(() => {
+      if (settled) return
+      settled = true
+      proc.kill('SIGKILL')
+      reject(new RichMediaSafetyError('attachment_processing_failed', `${command} timed out`))
+    }, timeoutMs)
+    timer.unref?.()
+    proc.stderr.on('data', (chunk: Buffer) => {
+      if (stderr.length < PROCESS_STDERR_MAX) stderr += chunk.toString('utf8').slice(0, PROCESS_STDERR_MAX - stderr.length)
+    })
+    proc.once('error', error => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      const code = (error as NodeJS.ErrnoException).code === 'ENOENT'
+        ? 'attachment_processing_unavailable'
+        : 'attachment_processing_failed'
+      reject(new RichMediaSafetyError(code, `${command} unavailable: ${error.message}`))
+    })
+    proc.once('close', code => {
+      if (settled) return
+      settled = true
+      clearTimeout(timer)
+      if (code === 0) resolve()
+      else reject(new RichMediaSafetyError('corrupt_attachment', `${command} rejected attachment`))
+    })
+  })
+}
+
+async function processPdf(bytes: Buffer): Promise<PreparedDocument> {
+  const root = mkdtempSync(join(tmpdir(), 'cos-pdf-'))
+  const input = join(root, 'input.pdf')
+  const output = join(root, 'content.txt')
+  const pagesPrefix = join(root, 'page')
+  try {
+    writeFileSync(input, bytes, { mode: 0o600 })
+    await runProcess('pdftotext', ['-layout', '-enc', 'UTF-8', input, output])
+    const rawText = readFileSync(output, 'utf8')
+    const capped = capText(rawText)
+    const pageImages: Buffer[] = []
+    try {
+      await runProcess('pdftoppm', ['-jpeg', '-r', '120', '-f', '1', '-l', String(MAX_DERIVATIVE_IMAGES), input, pagesPrefix])
+      for (const name of readdirSync(root).filter(name => /^page-\d+\.jpg$/i.test(name)).sort().slice(0, MAX_DERIVATIVE_IMAGES)) {
+        pageImages.push(readFileSync(join(root, name)))
+      }
+    } catch (error) {
+      if (capped.text.length === 0) throw error
+    }
+    if (capped.text.length === 0 && pageImages.length === 0) {
+      throw new RichMediaSafetyError('corrupt_attachment', 'PDF contains no extractable text or pages')
+    }
+    return {
+      category: 'document', mime: 'application/pdf', original: bytes,
+      extractedText: capped.text, textTruncated: capped.truncated, pageImages,
+    }
+  } finally {
+    try { rmSync(root, { recursive: true, force: true }) } catch { /* private tmp cleanup */ }
+  }
+}
+
+interface ProbePayload {
+  format?: { duration?: string; format_name?: string; tags?: Record<string, string> }
+  streams?: Array<{ codec_type?: string; width?: number; height?: number }>
+}
+
+async function processVideo(bytes: Buffer, label: string | undefined, declaredMime: string | undefined): Promise<PreparedVideo> {
+  const root = mkdtempSync(join(tmpdir(), 'cos-video-'))
+  const ext = fileExtension(label) === '.mov' ? '.mov' : '.mp4'
+  const input = join(root, `input${ext}`)
+  const probePath = join(root, 'probe.json')
+  try {
+    writeFileSync(input, bytes, { mode: 0o600 })
+    await new Promise<void>((resolve, reject) => {
+      let settled = false
+      let stdout = ''
+      let stderr = ''
+      const proc = spawn('ffprobe', [
+        '-v', 'error', '-show_entries', 'format=duration,format_name:stream=codec_type,width,height',
+        '-of', 'json', input,
+      ], { stdio: ['ignore', 'pipe', 'pipe'] })
+      const timer = setTimeout(() => {
+        if (settled) return
+        settled = true
+        proc.kill('SIGKILL')
+        reject(new RichMediaSafetyError('attachment_processing_failed', 'ffprobe timed out'))
+      }, 10_000)
+      proc.stdout.on('data', (chunk: Buffer) => { if (stdout.length < 64_000) stdout += chunk.toString('utf8') })
+      proc.stderr.on('data', (chunk: Buffer) => { if (stderr.length < PROCESS_STDERR_MAX) stderr += chunk.toString('utf8') })
+      proc.once('error', error => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        reject(new RichMediaSafetyError(
+          (error as NodeJS.ErrnoException).code === 'ENOENT' ? 'attachment_processing_unavailable' : 'attachment_processing_failed',
+          `ffprobe unavailable: ${error.message}`,
+        ))
+      })
+      proc.once('close', code => {
+        if (settled) return
+        settled = true
+        clearTimeout(timer)
+        if (code !== 0) {
+          reject(new RichMediaSafetyError('corrupt_attachment', 'ffprobe rejected video'))
+          return
+        }
+        writeFileSync(probePath, stdout, { mode: 0o600 })
+        resolve()
+      })
+    })
+    let probe: ProbePayload
+    try { probe = JSON.parse(readFileSync(probePath, 'utf8')) as ProbePayload } catch {
+      throw new RichMediaSafetyError('corrupt_attachment', 'ffprobe returned invalid metadata')
+    }
+    const stream = probe.streams?.find(item => item.codec_type === 'video')
+    const durationMs = Math.round(Number(probe.format?.duration) * 1000)
+    if (!stream || !Number.isFinite(stream.width) || !Number.isFinite(stream.height)
+      || !Number.isFinite(durationMs) || durationMs <= 0) {
+      throw new RichMediaSafetyError('corrupt_attachment', 'attachment has no valid video stream')
+    }
+    if (durationMs > MAX_VIDEO_DURATION_MS) {
+      throw new RichMediaSafetyError('video_too_long', `video exceeds ${MAX_VIDEO_DURATION_MS / 60_000} minute limit`)
+    }
+    const frameCount = Math.min(MAX_DERIVATIVE_IMAGES, Math.max(1, Math.ceil(durationMs / 15_000)))
+    const fps = Math.max(0.001, frameCount / (durationMs / 1000))
+    await runProcess('ffmpeg', [
+      '-nostdin', '-v', 'error', '-i', input,
+      '-vf', `fps=${fps.toFixed(6)},scale=1280:-2:force_original_aspect_ratio=decrease`,
+      '-frames:v', String(frameCount), '-q:v', '3', join(root, 'frame-%02d.jpg'),
+    ])
+    const frames = readdirSync(root)
+      .filter(name => /^frame-\d+\.jpg$/i.test(name)).sort().slice(0, MAX_DERIVATIVE_IMAGES)
+      .map(name => readFileSync(join(root, name)))
+    if (frames.length === 0) throw new RichMediaSafetyError('corrupt_attachment', 'video produced no review frames')
+    const mime: PreparedVideo['mime'] = declaredMime === 'video/quicktime' || ext === '.mov'
+      ? 'video/quicktime' : 'video/mp4'
+    return {
+      category: 'video', mime, original: bytes,
+      width: Math.floor(stream.width!), height: Math.floor(stream.height!), durationMs, frames,
+    }
+  } finally {
+    try { rmSync(root, { recursive: true, force: true }) } catch { /* private tmp cleanup */ }
+  }
+}
+
+export async function prepareRichMedia(
+  bytes: Buffer,
+  options: { label?: string; declaredMime?: string },
+): Promise<PreparedRichMedia> {
+  if (bytes.length === 0) throw new RichMediaSafetyError('corrupt_attachment', 'attachment is empty')
+  if (bytes.length > MAX_RICH_MEDIA_BYTES) {
+    throw new RichMediaSafetyError('attachment_too_large', `attachment exceeds ${MAX_RICH_MEDIA_BYTES} byte limit`)
+  }
+  if (isPdf(bytes)) return processPdf(bytes)
+  if (isIsoBmff(bytes)) return processVideo(bytes, options.label, options.declaredMime)
+
+  const ext = fileExtension(options.label)
+  const declared = (options.declaredMime ?? '').toLowerCase().split(';', 1)[0]
+  const textMime: PreparedDocument['mime'] | null = ext === '.md' || ext === '.markdown' || declared === 'text/markdown'
+    ? 'text/markdown'
+    : ext === '.csv' || declared === 'text/csv'
+      ? 'text/csv'
+      : ext === '.json' || declared === 'application/json'
+        ? 'application/json'
+        : ext === '.txt' || declared === 'text/plain'
+          ? 'text/plain'
+          : null
+  if (!textMime) throw new RichMediaSafetyError('unsupported_attachment_format', 'supported files: TXT, MD, CSV, JSON, PDF, MP4, MOV')
+  const capped = capText(decodeStrictUtf8(bytes))
+  return {
+    category: 'document', mime: textMime, original: bytes,
+    extractedText: capped.text, textTruncated: capped.truncated, pageImages: [],
+  }
+}

package/server/routes/health.ts

@@ -1,4 +1,5 @@
 import { Router } from 'express'
+import { isWorthRecovering } from '../lib/quarantine-auto-recover.js'
 import { statSync } from 'node:fs'
 import { resolve } from 'node:path'
 import { COS_SCRIPTS_DIR, COS_MODE } from '../lib/python-bridge.js'
@@ -29,6 +30,7 @@ import {
   isCursorProviderReady,
 } from '../lib/cursor-model-catalog.js'
 import { isMediaProcessingReady } from '../lib/image-safety.js'
+import { getRichMediaProcessingCapabilities } from '../lib/rich-media-safety.js'
 import { G2_LENS_VARIANT_CAPABILITY } from '../lib/media-store.js'
 import { durableQueryJobsCapability } from '../lib/query-job-feature.js'
 import { getQueryJobRuntimeHealth } from '../lib/query-job-runtime.js'
@@ -161,6 +163,7 @@ healthRouter.get('/health', async (_req, res) => {
   // Computed once per request; the same value feeds features.liveCues and
   // capabilities.liveCues so the two surfaces can never disagree.
   const liveCues = liveCuesCapability()
+  const richMedia = await getRichMediaProcessingCapabilities()
   const features = {
     claude: claudeAvailable,
     codex: codexAvailable,
@@ -172,6 +175,8 @@ healthRouter.get('/health', async (_req, res) => {
     meetingFinalization: true,
     iphoneAsrCandidates: process.env.COS_IOS_ASR_CANDIDATES === '1',
     mediaProcessingReady: await isMediaProcessingReady(),
+    pdfProcessingReady: richMedia.pdf,
+    videoProcessingReady: richMedia.video,
     g2LensVariant: G2_LENS_VARIANT_CAPABILITY,
     durableQueryJobs: durableJobs.enabled,
     durableQueryJobsProtocol: durableJobs.protocolVersion,
@@ -227,7 +232,7 @@ healthRouter.get('/health', async (_req, res) => {
   // plus the recover action live on the authenticated /api/meeting/orphans.
   const unsavedList = listUnsavedCaptures()
   const unsaved_captures = {
-    count: unsavedList.filter(item => !item.recovered).length,
+    count: unsavedList.filter(isWorthRecovering).length,
     items: unsavedList.slice(0, 10).map(item => ({
       sessionId: item.sessionId,
       ageHours: item.ageHours,
@@ -295,6 +300,15 @@ healthRouter.get('/health', async (_req, res) => {
       },
       cliDebug: CLI_DEBUG_CAPABILITY,
       liveCues,
+      richMedia: {
+        text: true,
+        pdf: richMedia.pdf,
+        video: richMedia.video,
+        maxAttachments: 5,
+        maxBytesPerAttachment: 64 * 1024 * 1024,
+        maxVideoMinutes: 20,
+        maxStillFrames: 8,
+      },
       meetingLifecycle: {
         earlySyncClaim: getEarlyMeetingSyncSnapshot(),
         progressiveHq,

package/server/routes/media.ts

@@ -15,7 +15,7 @@
 // (8 MiB decoded ≈ 10.7 MiB base64) doesn't trip the global 10 MB limit;
 // the allowance stays scoped to /api/media.
 
-import { Router, json, type Request, type Response } from 'express'
+import { Router, json, raw, type Request, type Response } from 'express'
 import { readFileSync } from 'node:fs'
 import {
   MAX_ATTACHMENTS_PER_PROMPT,
@@ -35,11 +35,18 @@ import {
   isMediaProcessingReady,
   strictBase64Decode,
 } from '../lib/image-safety.js'
+import {
+  MAX_RICH_MEDIA_BYTES,
+  RichMediaSafetyError,
+} from '../lib/rich-media-safety.js'
 
 // Route-scoped parser: 16 MB covers the max valid batch after base64 + JSON
 // overhead. Mounted only for /api/media in server/index.ts — the global
 // server limit is unchanged.
 export const mediaBodyParser = json({ limit: '16mb' })
+/** Binary parser is mounted only on /api/media/file before global JSON. It
+ * avoids base64 amplification while retaining a hard route-local cap. */
+export const mediaBinaryBodyParser = raw({ type: () => true, limit: MAX_RICH_MEDIA_BYTES })
 
 export const mediaRouter = Router()
 
@@ -58,6 +65,12 @@ const SAFETY_ERROR_STATUS: Record<string, number> = {
   corrupt_image: 400,
   media_processing_unavailable: 503,
   normalization_failed: 500,
+  unsupported_attachment_format: 400,
+  attachment_too_large: 413,
+  corrupt_attachment: 400,
+  attachment_processing_unavailable: 503,
+  attachment_processing_failed: 500,
+  video_too_long: 400,
 }
 
 function sendMediaError(res: Response, err: unknown): void {
@@ -73,6 +86,10 @@ function sendMediaError(res: Response, err: unknown): void {
     })
     return
   }
+  if (err instanceof RichMediaSafetyError) {
+    res.status(SAFETY_ERROR_STATUS[err.code] ?? 500).json({ error: err.code, detail: err.message })
+    return
+  }
   console.error('[media] unexpected error:', err)
   res.status(500).json({ error: 'media_internal_error' })
 }
@@ -143,6 +160,34 @@ mediaRouter.post('/media', async (req: Request, res: Response) => {
   }
 })
 
+/** One document or video per binary request. The client may issue several
+ * bounded requests, but composer admission still owns the shared five-item
+ * prompt cap. Filename and MIME are hints only; prepareRichMedia sniffs and
+ * validates the actual bytes. */
+mediaRouter.post('/media/file', async (req: Request, res: Response) => {
+  try {
+    if (!Buffer.isBuffer(req.body) || req.body.length === 0) {
+      res.status(400).json({ error: 'attachment_bytes_required' })
+      return
+    }
+    const rawLabel = safeString(req.header('x-cos-filename'), 360)
+    let label: string | undefined
+    if (rawLabel) {
+      try { label = decodeURIComponent(rawLabel).slice(0, 120) } catch { label = rawLabel.slice(0, 120) }
+    }
+    const attachment = await getMediaStore().ingestRichMedia({
+      bytes: req.body,
+      label,
+      declaredMime: safeString(req.header('content-type'), 120),
+      capturedAt: safeString(req.header('x-cos-captured-at'), 40),
+      sessionId: safeString(req.header('x-cos-session-id'), 64),
+    })
+    res.json({ attachment })
+  } catch (err) {
+    sendMediaError(res, err)
+  }
+})
+
 // ── Lifecycle ────────────────────────────────────────────────────────────────
 
 mediaRouter.post('/media/reserve', async (req: Request, res: Response) => {

package/server/routes/meeting.ts

@@ -3,6 +3,7 @@
 // are durable before the session is closed; batch improvement runs afterward.
 
 import { existsSync, readdirSync, readFileSync, rmSync, statSync, unlinkSync } from 'node:fs'
+import { isWorthRecovering } from '../lib/quarantine-auto-recover.js'
 import { resolve } from 'node:path'
 import { Router } from 'express'
 import { emitDisplay } from '../lib/display-bus.js'
@@ -1672,7 +1673,7 @@ export function createMeetingRouter(deps: MeetingRouteDependencies = {}): Router
     // route answered count: 0.
     const stranded = getStrandedCaptures()
     res.json({
-      count: items.filter(item => !item.recovered).length,
+      count: items.filter(isWorthRecovering).length,
       strandedCount: stranded.length,
       stranded,
       recovering: [...recoveringOrphans],

package/server/routes/query.ts

@@ -83,10 +83,10 @@ queryRouter.post('/query', async (req, res) => {
 
   const resolvedQuery = typeof query === 'string' ? query : ''
 
-  // Vision queries can have an empty query (default to "describe what you see")
-  if ((!resolvedQuery || typeof resolvedQuery !== 'string') && !imageInputs) {
+  // Attachment-only queries use a category-aware provider default.
+  if ((!resolvedQuery || typeof resolvedQuery !== 'string') && attachmentRefs.length === 0) {
     maintenanceLease.release()
-    return res.status(400).json({ error: 'query string or image required' })
+    return res.status(400).json({ error: 'query string or attachment required' })
   }
 
   // Validate model if provided
@@ -201,6 +201,8 @@ queryRouter.post('/query', async (req, res) => {
         abortSignal: abortController.signal,
         effort: validEffort,
         messageEra: activeMessageEra,
+        requestAttachments: attachmentRefs,
+        attachmentPromptBlock: resolvedAttachments.promptBlock,
         ...(validModel && isCursorModel(validModel) ? { cursorExecutionMode } : {}),
       },
     )

package/server/routes/transcribe-stream.ts

@@ -1015,8 +1015,22 @@ setInterval(() => {
       }
     }
     purgeExpiredQuarantine()
+  } catch (error) {
+    // Was a bare `catch {}`. That is what made the auto-recover failure below
+    // undiagnosable: three minutes of watching a live server produced no recovery, no
+    // log, and nothing to reason about, because any throw in this block vanished.
+    console.error(`[cleanup] Orphan-audio sweep failed: ${error instanceof Error ? error.message : error}`)
+  }
+  // DELIBERATELY ITS OWN TRY. This used to sit inside the block above, one line after
+  // purgeExpiredQuarantine, so a throw anywhere in that sweep meant auto-recovery
+  // silently never ran — which is exactly what happened in production on 6.23.1
+  // through 6.24.2. Recovering quarantined audio has nothing to do with sweeping
+  // orphaned session-audio dirs and must not depend on it succeeding.
+  try {
     autoRecoverOneQuarantinedCapture()
-  } catch {}
+  } catch (error) {
+    console.error(`[quarantine] Auto-recover pass failed: ${error instanceof Error ? error.message : error}`)
+  }
   // Purge stale pending-batch dirs. HQ large-v3 on long meetings + Control
   // restart can exceed 2h (2026-07-27: two sessions purged before batch).
   // Use 12h, and never purge while a meeting_batch_finalization lease is held.