@gotcos/glasses-server 6.99.12 → 6.99.16

package/server/lib/drop-service.ts

@@ -13,8 +13,8 @@
  * a Messages row or moves the lens message counter (canary 11).
  */
 import { randomBytes } from 'node:crypto'
-import { DROP_DESTS, DROP_ID, DROP_LIMITS, DropStoreError, parseLink, type DropChoice, type DropDest, type DropKind, type DropLink, type DropRecord,
-  type DropSource, type DropFileRef, type FeedAction, type FeedItem, type DropStore, type InboxFeedStore } from './drop-store.js'
+import { ATTACHMENT_ID, DROP_DESTS, DROP_ID, DROP_LIMITS, DropStoreError, parseLink, type DropAttachment, type DropChoice, type DropDest, type DropKind, type DropLink,
+  type DropRecord, type DropSource, type DropFileRef, type FeedAction, type FeedItem, type DropStore, type InboxFeedStore } from './drop-store.js'
 import { choiceFor, cleanDropForJev, DROP_ROUTER_LIMITS, ruleRoute, type DropRouter, type DropTarget, type RouteOutcome } from './drop-router.js'
 import { DropDestinationError, type DropWriters } from './drop-destinations.js'
 import { parseWhen, whenLabel, whenSuggestions, WHEN_MAX_AHEAD_MS } from './drop-when.js'
@@ -31,16 +31,29 @@ export interface DropInput {
   source: DropSource
   hint?: { sessionId: string; label?: string }
   file?: DropFileRef
+  /** 6.99.13: up to five fresh uploads (POST /api/media, /api/media/file) to keep with the drop. Words are still required. */
+  attachmentIds?: string[]
 }
 export interface DropView {
   id: string; text: string; source: DropSource; createdAt: string; updatedAt: string
   state: DropRecord['state']; dest: DropDest | null; kind: DropKind; status: HistoryStatus
   links: DropLink[]; choices?: DropChoice[]; route: DropRecord['route']; undoUntil: string | null
-  canUndo: boolean; hold?: DropRecord['hold']; remind?: DropRecord['remind']; file?: DropFileRef
+  canUndo: boolean; hold?: DropRecord['hold']; remind?: DropRecord['remind']; file?: DropFileRef; attachments?: DropAttachment[]
 }
-export interface DropAnswer { drop: DropView; items: FeedItem[]; replayed: boolean; next?: { kind: 'ask'; prompt: string } }
+/** A drop read as a question: the client runs the Ask with these words, and the drop's files when it has any. */
+export interface DropNextAsk { kind: 'ask'; prompt: string; attachmentIds?: string[] }
+export interface DropAnswer { drop: DropView; items: FeedItem[]; replayed: boolean; next?: DropNextAsk }
 export type HistoryStatus = 'open' | 'in_progress' | 'done' | 'undone'
 export interface AskLookup { status: string; response?: string; sessionId?: string }
+/**
+ * 6.99.13: where a drop's files live (lib/drop-attachments.ts, the media store). `pin` binds fresh uploads to the drop
+ * so they outlive the upload TTL, all or nothing, and throws a DropError that says what to do when one cannot be kept.
+ * `unpin` removes the bytes this drop pinned (Undo).
+ */
+export interface DropAttachmentPins {
+  pin(ids: string[], dropId: string): Promise<DropAttachment[]>
+  unpin(ids: string[], dropId: string): Promise<number>
+}
 
 export interface DropServiceDeps {
   drops: DropStore
@@ -53,16 +66,36 @@ export interface DropServiceDeps {
   timezone?: () => string
   /** 6.99.11 settings: the reminders' default time and snooze length. Absent: 9:00 and an hour. */
   p2Settings?: () => P2Settings
+  /** 6.99.13: files on a drop. Absent: a drop with attachmentIds is refused (attachments_unsupported). */
+  attachments?: DropAttachmentPins
 }
 
 const TEXT_MAX = DROP_LIMITS.text
 const ASK_WINDOW_MS = 6 * 60 * 60_000
 const ANSWER_CHARS = 1_200
+/** The pinned row's line: the item's title, then its line, but never the title twice (6.99.15: a follow-up's line
+ *  already names its card, so "X. 2 follow-ups from X." read as a stutter). A drop shows only its line. */
+export function pinLine(item: { kind: string; title?: string | null; line: string }): string {
+  const title = String(item.title ?? '').trim()
+  const line = String(item.line ?? '').trim()
+  if (!title || item.kind === 'drop') return line
+  if (!line) return title
+  const t = title.replace(/[.!?]+$/, '').toLowerCase()
+  return line.toLowerCase().includes(t) ? line : `${title.replace(/[.!?]+$/, '')}. ${line}`
+}
+
 const short = (text: string, max = 60): string => {
   const one = text.replace(/\s+/g, ' ').trim()
   return one.length <= max ? one : one.slice(0, max - 1).trimEnd() + '…'
 }
 const feedId = () => `fi_${randomBytes(16).toString('hex')}`
+/** A drop's files as chat links (kind `file`, the media id), so the chat can open each one. */
+const fileLinks = (attachments: DropAttachment[] | undefined): DropLink[] =>
+  (attachments ?? []).map(a => ({ kind: 'file' as const, id: a.id, label: a.name.slice(0, DROP_LIMITS.label) }))
+/** Where a drop's files are, said on its receipts: the destinations take words only. */
+const filesLine = (n: number): string => n === 1 ? 'The file stays here in the COS chat with your words.' : `The ${n} files stay here in the COS chat with your words.`
+const nextAsk = (drop: DropRecord): DropNextAsk =>
+  ({ kind: 'ask', prompt: drop.text, ...(drop.attachments?.length ? { attachmentIds: drop.attachments.map(a => a.id) } : {}) })
 /** One item that waits on an answer: a live question, or a live item marked needsReply (6.99.10). */
 export const isWaiting = (i: FeedItem): boolean => i.state === 'live' && (i.kind === 'question' || i.needsReply === true)
 const A = {
@@ -114,15 +147,23 @@ export class DropService {
   }
 
   private async run(input: DropInput): Promise<DropAnswer> {
+    // Files first (6.99.13): they are pinned to the drop before it is saved, so a saved drop never points at an upload
+    // the store could still expire. A file that cannot be kept refuses the whole drop and nothing is saved.
+    let attachments: DropAttachment[] = []
+    if (input.attachmentIds?.length) {
+      if (!this.deps.attachments) throw new DropError('attachments_unsupported', 400, 'This Mac takes words only on a drop. Ask sends the files, or remove them to drop.')
+      attachments = await this.deps.attachments.pin(input.attachmentIds, input.dropId)
+    }
     const at = this.now().toISOString()
     const fresh: DropRecord = {
       id: input.dropId, text: input.text, source: input.source, createdAt: at, updatedAt: at, state: 'routing', dest: null,
       kind: input.file ? 'file' : 'note', links: [], route: null, undoUntil: null, timeline: [{ at, state: 'routing' }],
       ...(input.hint ? { hint: { sessionId: input.hint.sessionId } } : {}), ...(input.file ? { file: input.file } : {}),
+      ...(attachments.length ? { attachments } : {}),
     }
     this.deps.drops.insert(fresh)
     this.deps.feed.insert([{ id: feedId(), kind: 'drop', threadId: fresh.id, createdAt: at, readAt: at, source: input.source,
-      line: input.text, links: [], actions: [], state: 'live', key: `${fresh.id}:drop` }])
+      line: input.text, links: fileLinks(attachments), actions: [], state: 'live', key: `${fresh.id}:drop` }])
     // Before any rule (plan section 8): a drop that looks like it holds a password or key goes nowhere but the drop
     // store. Not to memory (the bridge embeds it), not to the Ask job, not to Jev.
     if (cleanDropForJev(input.text).tripped) return this.file(fresh, 'note', undefined, { by: 'fallback', reason: 'redacted' })
@@ -155,8 +196,8 @@ export class DropService {
     const at = this.now().toISOString()
     const saved = this.deps.drops.update(drop.id, d => ({ ...d, state: 'asked', dest: 'ask', kind: 'ask', route: { by: 'rule' },
       undoUntil: null, timeline: [...d.timeline, { at, state: 'asked', dest: 'ask' }] }))
-    this.receipt(saved, 'receipt', 'Asking COS', 'The answer lands here when it is ready.', [], [], 1)
-    return { ...this.answer(saved, false), next: { kind: 'ask', prompt: saved.text } }
+    this.receipt(saved, 'receipt', 'Asking COS', saved.attachments?.length ? 'The answer lands here when it is ready. The files go with the question.' : 'The answer lands here when it is ready.', [], [], 1)
+    return { ...this.answer(saved, false), next: nextAsk(saved) }
   }
 
   private question(drop: DropRecord, choices: DropChoice[], route: DropRecord['route'], clear: number): DropAnswer {
@@ -263,6 +304,10 @@ export class DropService {
 
   private receipt(drop: DropRecord, kind: 'receipt' | 'question' | 'followup', title: string, line: string, links: DropLink[], actions: FeedAction[], generation: number, needsReply = false): FeedItem {
     const at = this.now().toISOString()
+    // 6.99.13: a drop's files ride on every receipt and question it gets, each one openable, with a line saying where
+    // they are (no destination holds a file: a card, a thread note and a memory take words).
+    const files = kind === 'followup' ? [] : fileLinks(drop.attachments)
+    if (files.length) { links = [...links, ...files]; line = `${line} ${filesLine(files.length)}` }
     const [item] = this.deps.feed.insert([{ id: feedId(), kind, threadId: drop.id, createdAt: at,
       // Receipts are born read (plan section 1); a question and a follow-up count as unread on the pinned row.
       // A receipt that asks (a reminder with no time) is waiting on him until he picks one (P2).
@@ -357,15 +402,36 @@ export class DropService {
       if (drop.state === 'undone') return this.answer(drop, true)
       const generation = this.nextGeneration(drop.id)
       await this.reverse(drop)
+      // 6.99.13: Undo takes the drop's files with it. Only after the destination let go, so a refused Undo keeps them.
+      const fileIds = (drop.attachments ?? []).map(a => a.id)
+      let files: 'none' | 'removed' | 'kept' = 'none'
+      if (fileIds.length) {
+        try {
+          if (!this.deps.attachments) throw new Error('no attachment store')
+          await this.deps.attachments.unpin(fileIds, drop.id)
+          files = 'removed'
+        } catch {
+          files = 'kept'
+          console.warn(`[drops] ${drop.id} files not removed on undo`)
+        }
+      }
       const at = this.now().toISOString()
       const saved = this.deps.drops.update(drop.id, d => {
         const next: DropRecord = { ...d, state: 'undone', links: [], undoUntil: null, timeline: [...d.timeline, { at, state: 'undone' }] }
         delete next.hold; delete next.remind; delete next.choices
+        if (files === 'removed') delete next.attachments
         return next
       })
+      if (files === 'removed') {
+        // The chat stops offering files that are gone.
+        const withFiles = new Set(this.deps.feed.list().filter(i => i.threadId === drop.id && i.links.some(l => l.kind === 'file')).map(i => i.id))
+        if (withFiles.size) this.deps.feed.update(withFiles, i => ({ ...i, links: i.links.filter(l => l.kind !== 'file') }))
+      }
       this.retire(drop.id)
-      this.receipt(saved, 'receipt', 'Undone', undoLine(drop), [], [], generation)
-      console.log(`[drops] ${drop.id} undone from=${drop.dest ?? drop.state}`)
+      const filesWords = files === 'removed' ? (fileIds.length === 1 ? ' The file is removed.' : ` The ${fileIds.length} files are removed.`)
+        : files === 'kept' ? ' COS could not remove the files.' : ''
+      this.receipt(saved, 'receipt', 'Undone', undoLine(drop) + filesWords, [], [], generation)
+      console.log(`[drops] ${drop.id} undone from=${drop.dest ?? drop.state}${files === 'none' ? '' : ` files=${files}`}`)
       return this.answer(this.deps.drops.get(drop.id)!, false)
     })
   }
@@ -500,7 +566,7 @@ export class DropService {
     const asked = items.filter(i => isWaiting(i)).length
     const work = typeof extra.yourMove === 'number' && Number.isSafeInteger(extra.yourMove) && extra.yourMove > 0 ? extra.yourMove : 0
     const last = items[items.length - 1]
-    return { unread, waiting: asked + work, lastLine: last ? short(last.title && last.kind !== 'drop' ? `${last.title}. ${last.line}` : last.line, 120) : '', lastAt: last?.createdAt ?? null, version: this.deps.feed.version() }
+    return { unread, waiting: asked + work, lastLine: last ? short(pinLine(last), 120) : '', lastAt: last?.createdAt ?? null, version: this.deps.feed.version() }
   }
 
   /**
@@ -567,7 +633,7 @@ export class DropService {
     if (options.q) {
       const terms = options.q.normalize('NFKC').toLowerCase().split(/\s+/).filter(Boolean)
       rows = rows.filter(r => {
-        const hay = [r.text, ...r.links.map(l => l.label), r.hold?.label ?? '', r.file?.displayName ?? ''].join(' ').normalize('NFKC').toLowerCase()
+        const hay = [r.text, ...r.links.map(l => l.label), r.hold?.label ?? '', r.file?.displayName ?? '', ...(r.attachments ?? []).map(a => a.name)].join(' ').normalize('NFKC').toLowerCase()
         return terms.every(t => hay.includes(t))
       })
     }
@@ -582,6 +648,18 @@ export class DropService {
     return { drops: views.slice(0, limit), more: views.length > limit, cardStates }
   }
 
+  /**
+   * 6.99.16: the drops a COS thread digest carries (lib/cos-thread.ts): created at or after `sinceIso`, newest first,
+   * undone ones left out. Reads the store only; never touches Work.
+   */
+  recentDrops(sinceIso: string, limit: number): Array<Pick<DropRecord, 'text' | 'createdAt' | 'state' | 'dest' | 'links'>> {
+    return this.deps.drops.list()
+      .filter(r => r.state !== 'undone' && r.createdAt >= sinceIso)
+      .sort((a, b) => b.createdAt.localeCompare(a.createdAt))
+      .slice(0, Math.max(0, limit))
+      .map(r => ({ text: r.text, createdAt: r.createdAt, state: r.state, dest: r.dest, links: r.links }))
+  }
+
   /** Releases both stores' writer locks (shutdown and tests). */
   close(): void { this.deps.drops.close(); this.deps.feed.close() }
 
@@ -589,7 +667,7 @@ export class DropService {
 
   private answer(drop: DropRecord, replayed: boolean): DropAnswer {
     const items = this.deps.feed.list().filter(i => i.threadId === drop.id)
-    return { drop: this.view(drop, null), items, replayed, ...(drop.dest === 'ask' && !drop.ask ? { next: { kind: 'ask' as const, prompt: drop.text } } : {}) }
+    return { drop: this.view(drop, null), items, replayed, ...(drop.dest === 'ask' && !drop.ask ? { next: nextAsk(drop) } : {}) }
   }
 
   private view(drop: DropRecord, cards: Map<string, { workStage: string; checked: boolean }> | null): DropView {
@@ -599,6 +677,7 @@ export class DropService {
       route: drop.route, undoUntil: drop.undoUntil,
       canUndo: ['filed', 'held', 'asking'].includes(drop.state) && !!drop.undoUntil && this.now().getTime() <= Date.parse(drop.undoUntil) && !drop.hold?.sentAt,
       ...(drop.hold ? { hold: drop.hold } : {}), ...(drop.remind ? { remind: drop.remind } : {}), ...(drop.file ? { file: drop.file } : {}),
+      ...(drop.attachments?.length ? { attachments: drop.attachments } : {}),
     }
   }
 
@@ -639,11 +718,23 @@ function checkTarget(target: DropTarget): void {
 function validateInput(input: DropInput): DropInput {
   if (!input || typeof input !== 'object') throw new DropError('invalid_drop', 400)
   if (typeof input.dropId !== 'string' || !DROP_ID.test(input.dropId)) throw new DropError('invalid_drop_id', 400, 'dropId must be a lowercase UUID v4.')
+  // 6.99.13: files, held to the Ask's own rules (media ids, deduplicated, at most five), before the words.
+  let attachmentIds: string[] = []
+  if (input.attachmentIds !== undefined) {
+    const list: unknown = input.attachmentIds
+    if (!Array.isArray(list) || list.some(id => typeof id !== 'string' || !ATTACHMENT_ID.test(id))) {
+      throw new DropError('invalid_attachment', 400, 'A file was not one this Mac uploaded. Add it again, then Drop.')
+    }
+    attachmentIds = [...new Set(list as string[])]
+    if (attachmentIds.length > DROP_LIMITS.attachments) throw new DropError('too_many_attachments', 400, `Up to ${DROP_LIMITS.attachments} files per drop. Remove one, then Drop.`)
+  }
+  // A drop is filed by its words, so files alone have nowhere to go: say so instead of guessing.
+  if (attachmentIds.length && (typeof input.text !== 'string' || !input.text.trim())) throw new DropError('words_needed', 400, 'Add a few words with the files so COS knows where they go.')
   if (typeof input.text !== 'string') throw new DropError('invalid_text', 400)
   const text = input.text.replace(/\r\n?/g, '\n').trim()
   if (!text || [...text].length > TEXT_MAX || /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/.test(text)) throw new DropError('invalid_text', 400, `Text must be 1 to ${TEXT_MAX} characters.`)
   if (!['mac', 'web', 'g2', 'telegram'].includes(input.source)) throw new DropError('invalid_source', 400)
-  const out: DropInput = { dropId: input.dropId, text, source: input.source }
+  const out: DropInput = { dropId: input.dropId, text, source: input.source, ...(attachmentIds.length ? { attachmentIds } : {}) }
   if (input.hint !== undefined) {
     const h = input.hint
     if (!h || typeof h.sessionId !== 'string' || !/^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,199}$/.test(h.sessionId)

package/server/lib/drop-settings.ts

@@ -10,8 +10,11 @@ import { dirname } from 'node:path'
 import { dataPath } from './data-dir.js'
 import { durableAtomicWriteFileSync } from './atomic-fs.js'
 import { securePrivateDirectory } from './secure-user-config.js'
+import { MAX_ATTACHMENTS_PER_PROMPT } from '../../shared/media-attachment.js'
 
 export const DROP_IT_PROTOCOL = 1
+/** 6.99.13: files one drop takes, the Ask's own cap (shared/media-attachment.ts MAX_ATTACHMENTS_PER_PROMPT). */
+export const DROP_ATTACHMENTS_MAX = MAX_ATTACHMENTS_PER_PROMPT
 export const DROP_IT_SETTINGS_FILE = () => dataPath('drop-it-settings.json')
 
 export function dropItSetting(file = DROP_IT_SETTINGS_FILE()): boolean {
@@ -39,7 +42,15 @@ export function writeDropItSetting(enabled: boolean, file = DROP_IT_SETTINGS_FIL
 }
 
 /** The capability block for /api/health and /api/models. Codes only: no counts, no words. Additive. */
-export function dropItCapability(env: NodeJS.ProcessEnv = process.env): { protocol: number; enabled: boolean; source: 'env' | 'settings'; p2Settings: number } {
+export function dropItCapability(env: NodeJS.ProcessEnv = process.env, file = DROP_IT_SETTINGS_FILE()): { protocol: number; enabled: boolean; source: 'env' | 'settings'; p2Settings: number; attachments: number; thread?: { protocol: number } } {
   // p2Settings (6.99.11): GET/PUT /api/drops/settings/p2 exists. Clients that do not see it hide the P2 controls.
-  return { protocol: DROP_IT_PROTOCOL, enabled: dropItEnabled(env), source: dropItSource(env), p2Settings: 1 }
+  // attachments (6.99.13): POST /api/drops takes this many attachmentIds. A client that does not see it sends words only.
+  // thread (6.99.16): the COS thread routes (routes/cos-thread.ts), present only while Drop it is on, as they are.
+  const enabled = dropItEnabled(env, file)
+  return {
+    protocol: DROP_IT_PROTOCOL, enabled, source: dropItSource(env), p2Settings: 1, attachments: DROP_ATTACHMENTS_MAX,
+    ...(enabled ? { thread: { protocol: COS_THREAD_CAPABILITY_PROTOCOL } } : {}),
+  }
 }
+/** 6.99.16: the COS thread's protocol (lib/cos-thread.ts COS_THREAD_PROTOCOL; kept here so this module imports nothing new). */
+export const COS_THREAD_CAPABILITY_PROTOCOL = 1

package/server/lib/drop-store.ts

@@ -45,6 +45,11 @@ export interface DropLink {
 export interface DropChoice { id: string; dest: DropDest; label: string; detail: string; target?: { id: string; domain?: string; label: string } }
 export interface DropRoute { by: 'rule' | 'jev' | 'user' | 'fallback'; p?: number; reason?: string; tokens?: number; provider?: string }
 export interface DropFileRef { store: string; key: string; fileID: string; sha256: string; displayName: string }
+/**
+ * 6.99.13: a file dropped with the words (COS Control Web). `id` is the media store's id: the bytes live there, pinned
+ * to this drop (MediaStore.pinForDrop), and open through GET /api/media/:id/content. Undo removes them.
+ */
+export interface DropAttachment { id: string; name: string; mime: string; size: number }
 export interface DropRemind { at: string | null; tz: string; firedAt: string | null; ackAt: string | null; snoozes: number }
 export interface DropTimelineEntry { at: string; state: DropState; dest?: DropDest; note?: string }
 export interface DropAsk { clientJobId: string; generation: number; answeredAt?: string }
@@ -64,6 +69,7 @@ export interface DropRecord {
   hold?: { sessionId: string; label: string; sentAt?: string }
   remind?: DropRemind
   file?: DropFileRef
+  attachments?: DropAttachment[]
   ask?: DropAsk
   hint?: { sessionId: string }
   /** Undo and Move work until this instant (24 hours after filing). */
@@ -102,6 +108,8 @@ export interface FeedItem {
 export const DROP_LIMITS = {
   text: 2_000, label: 200, line: 2_000, title: 200, links: 12, choices: 3, timeline: 40,
   drops: 20_000, feed: 20_000, fileBytes: 32_000_000, quarantineKept: 500,
+  /** Files on one drop: the Ask's own cap (shared/media-attachment.ts MAX_ATTACHMENTS_PER_PROMPT). */
+  attachments: 5, attachmentName: 255,
   /** Retention (plan section 6): drop records and links a year; undone drops and chat receipts 30 days. */
   keepDropDays: 365, keepUndoneDays: 30, keepReceiptDays: 30,
   undoMs: 24 * 60 * 60_000,
@@ -109,6 +117,8 @@ export const DROP_LIMITS = {
 
 export const DROP_ID = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
 export const FEED_ID = /^fi_[a-f0-9]{32}$/
+/** A media store id (shared/media-attachment.ts MEDIA_ID_RE). */
+export const ATTACHMENT_ID = /^m_[a-f0-9]{24}$/
 const LINK_ID = /^[A-Za-z0-9][A-Za-z0-9._:@/-]{0,199}$/
 const CONTROL = /[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/
 
@@ -145,6 +155,14 @@ function parseChoice(raw: unknown): DropChoice {
   return choice
 }
 
+export function parseAttachment(raw: unknown): DropAttachment {
+  if (!record(raw)) throw new DropStoreError('invalid_drop', 400)
+  const id = typeof raw.id === 'string' && ATTACHMENT_ID.test(raw.id) ? raw.id : null
+  const name = str(raw.name, DROP_LIMITS.attachmentName), mime = str(raw.mime, 100)
+  if (!id || !name || !mime || !/^[a-z]+\/[a-z0-9.+-]+$/i.test(mime) || !Number.isSafeInteger(raw.size) || (raw.size as number) < 0) throw new DropStoreError('invalid_drop', 400)
+  return { id, name, mime, size: raw.size as number }
+}
+
 /** Validate one drop record from the journal. Unknown fields are dropped, never trusted. */
 export function parseDropRecord(raw: unknown): DropRecord {
   if (!record(raw)) throw new DropStoreError('invalid_drop', 400)
@@ -192,6 +210,10 @@ export function parseDropRecord(raw: unknown): DropRecord {
     if (!store || !key || !fileID || !sha256 || !/^[a-f0-9]{64}$/.test(sha256) || !displayName) throw new DropStoreError('invalid_drop', 400)
     drop.file = { store, key, fileID, sha256, displayName }
   }
+  if (raw.attachments !== undefined) {
+    if (!Array.isArray(raw.attachments) || raw.attachments.length > DROP_LIMITS.attachments) throw new DropStoreError('invalid_drop', 400)
+    drop.attachments = raw.attachments.map(parseAttachment)
+  }
   if (raw.ask !== undefined) {
     const a = raw.ask
     if (!record(a) || typeof a.clientJobId !== 'string' || !DROP_ID.test(a.clientJobId.toLowerCase()) || !Number.isSafeInteger(a.generation) || (a.generation as number) < 1) throw new DropStoreError('invalid_drop', 400)

package/server/lib/media-store.ts

@@ -187,8 +187,18 @@ export interface MediaRecord {
    * the public attachment ref; it lets a lost finalize response or server
    * restart rediscover the one record that upload already published. */
   videoUploadId?: string
+  /** 6.99.13: the Drop it drop that holds this upload (pinForDrop). Kept apart
+   *  from runId, which an Ask's association overwrites. Never exposed. */
+  dropId?: string
 }
 
+/** A drop id (lowercase UUID v4), as lib/drop-store.ts DROP_ID. Kept local so
+ *  the media store never imports the drop store. */
+const DROP_ID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/
+/** The kinds a person uploads. Traffic frames and generated visuals carry
+ *  their own content TTL, so they can never be pinned to a drop. */
+const DROPPABLE_KINDS: ReadonlySet<string> = new Set(['user_photo', 'user_document', 'user_video'])
+
 interface MediaIndexFile {
   v: 1
   records: Record<string, MediaRecord>
@@ -324,6 +334,7 @@ function sanitizeRecord(raw: unknown): MediaRecord | null {
     ...(typeof r.videoUploadId === 'string' && /^vu_[0-9a-f]{24}$/.test(r.videoUploadId)
       ? { videoUploadId: r.videoUploadId }
       : {}),
+    ...(typeof r.dropId === 'string' && DROP_ID_RE.test(r.dropId) ? { dropId: r.dropId } : {}),
   }
 }
 
@@ -1212,6 +1223,75 @@ export class MediaStore {
     })
   }
 
+  /**
+   * 6.99.13 Drop it with files: bind fresh uploads to one drop so they outlive
+   * the staged TTL (4 h). An associated record has no lifecycle TTL and GC
+   * never touches it, so the bytes live as long as the drop holds them.
+   * All-or-nothing, like reserve. Refused (nothing changes):
+   *   - unknown or deleted id                        media_not_found
+   *   - expired, or its bytes already gone           media_expired
+   *   - queued with an Ask, sent with a message, held
+   *     by another drop, or not a person's upload   media_conflict
+   *   - bytes missing on disk                        media_unavailable
+   * Replaying the same drop is a no-op that answers the same refs.
+   */
+  pinForDrop(ids: string[], dropId: string): Promise<MediaAttachmentRef[]> {
+    return this.withLock(() => {
+      if (!DROP_ID_RE.test(dropId)) throw new MediaStoreError('media_conflict', 'invalid drop id')
+      const now = Date.now()
+      for (const id of ids) {
+        const rec = isValidMediaId(id) ? this.records.get(id) : undefined
+        if (!rec || rec.lifecycle === 'deleted') throw new MediaStoreError('media_not_found', `attachment ${id} not found`)
+        if (rec.lifecycle === 'associated' && rec.dropId === dropId) continue
+        if (rec.lifecycle === 'expired' || rec.contentRemoved || this.isContentExpired(rec, now)) {
+          throw new MediaStoreError('media_expired', `attachment ${id} expired`)
+        }
+        if (!DROPPABLE_KINDS.has(rec.ref.kind)) throw new MediaStoreError('media_conflict', `attachment ${id} is not an upload`)
+        if (rec.lifecycle !== 'staged') throw new MediaStoreError('media_conflict', `attachment ${id} is already in use`)
+        if (!existsSync(this.absPath(rec.storagePath))) throw new MediaStoreError('media_unavailable', `attachment ${id} content unavailable`)
+      }
+      let dirty = false
+      const refs: MediaAttachmentRef[] = []
+      for (const id of ids) {
+        const rec = this.records.get(id)!
+        refs.push(rec.ref)
+        if (rec.lifecycle === 'associated' && rec.dropId === dropId) continue
+        rec.lifecycle = 'associated'
+        rec.dropId = dropId
+        rec.associatedAtMs = now
+        rec.updatedAtMs = now
+        dirty = true
+      }
+      if (dirty) this.saveIndex()
+      return refs
+    })
+  }
+
+  /**
+   * 6.99.13: Undo of a drop with files. Removes the bytes of the uploads this
+   * drop pinned, and only those: a record another drop holds, or one an Ask
+   * since bound to a message (globalMsgNum), is left alone. Safe to replay.
+   * Answers how many were removed.
+   */
+  unpinDrop(ids: string[], dropId: string): Promise<number> {
+    return this.withLock(() => {
+      if (!DROP_ID_RE.test(dropId)) return 0
+      const now = Date.now()
+      let removed = 0
+      for (const id of ids) {
+        const rec = isValidMediaId(id) ? this.records.get(id) : undefined
+        if (!rec || rec.lifecycle !== 'associated' || rec.dropId !== dropId || rec.globalMsgNum != null) continue
+        this.removeAssetFiles(rec)
+        rec.lifecycle = 'deleted'
+        rec.contentRemoved = true
+        rec.updatedAtMs = now
+        removed++
+      }
+      if (removed) this.saveIndex()
+      return removed
+    })
+  }
+
   /** Hard delete — permitted only while unassociated (staged/reserved).
    *  Associated records follow conversation retention instead. */
   deleteUnassociated(id: string): Promise<boolean> {

package/server/lib/meeting-batch-transcribe.ts

@@ -471,11 +471,24 @@ export interface HqJobPlan {
   strictPrimary?: true
 }
 
+/**
+ * An iPhone recording's saved transcript. Parakeet stays the strict primary. Parakeet takes
+ * no prompt, so the dictionary's vocabulary reaches it only through a second opinion: when
+ * one is on, it is Whisper Large-v3 (prompted with the vocabulary) and the resolver keeps
+ * the user's choice, so its vocabulary rescue can write a dictionary term Parakeet missed.
+ * Off stays off. Before this, a phone plan forced both off and the dictionary never applied
+ * to iPhone recordings beyond the fixed corrections (Miles, 2026-11-05).
+ */
+export function phoneHqPlan(selected: Pick<HqJobPlan, 'secondOpinion' | 'resolver' | 'frontEnd'>): HqJobPlan {
+  const secondOpinion = selected.secondOpinion === 'off' ? 'off' : 'large-v3'
+  return { engine: 'parakeet-ultra', secondOpinion, resolver: secondOpinion !== 'off' && selected.resolver, frontEnd: selected.frontEnd, strictPrimary: true }
+}
+
 export function currentHqJobPlan(sessionId?: string): HqJobPlan {
   const selected = readSttSettings()
   if (sessionId && PHONE_CAPTURE_ID.test(sessionId)) {
     requirePhoneRecording(sessionId)
-    return { engine: 'parakeet-ultra', secondOpinion: 'off', resolver: false, frontEnd: selected.frontEnd, strictPrimary: true }
+    return phoneHqPlan(selected)
   }
   if (sessionId && MAC_CAPTURE_ID.test(sessionId) && selected.hq === 'parakeet-ultra') {
     return { engine: selected.hq, secondOpinion: selected.secondOpinion, resolver: selected.resolver, frontEnd: selected.frontEnd, strictPrimary: true }
@@ -827,7 +840,7 @@ export async function transcribeSegments(
   plan: HqJobPlan,
   deps: HqDecodeDeps = defaultHqDeps,
 ): Promise<BatchResult[]> {
-  if (expectedSessionId?.startsWith('phone_')) { requirePhoneRecording(expectedSessionId); plan = { ...plan, engine: 'parakeet-ultra', secondOpinion: 'off', resolver: false, strictPrimary: true } }
+  if (expectedSessionId?.startsWith('phone_')) { requirePhoneRecording(expectedSessionId); plan = phoneHqPlan(plan) }
   if (expectedSessionId && MAC_CAPTURE_ID.test(expectedSessionId) && plan.engine === 'parakeet-ultra') plan = { ...plan, strictPrimary: true }
   const results: BatchResult[] = []
   const meetingId = basename(audioDir)

package/server/lib/permission-broker.ts

@@ -235,8 +235,9 @@ export const POLL_FUTURE_SKEW_MS = 5_000
 /** The `client` values of a questions poll that count as a live answerer. */
 export const ANSWERING_CLIENTS: ReadonlySet<string> = new Set(['glasses', 'phone'])
 /**
- * 6.99.12: the one `client` value a COS Control Web poll (browser session cookie, never the token) counts under,
- * sent only while the page shows the cards. Kept apart from ANSWERING_CLIENTS: a token poll naming it never counts.
+ * 6.99.12: the `client` value a COS Control Web poll (browser session cookie, never the token) sends while the page
+ * shows the cards. 6.99.13: it never counts as live (the Mac always pops up at once), and a token poll naming it
+ * never counted. Kept apart from ANSWERING_CLIENTS.
  */
 export const WEB_ANSWERING_CLIENT = 'web'
 /** The questions API's own version, advertised at /api/models. */
@@ -1787,8 +1788,9 @@ export interface SessionQuestionsCapability {
    */
   awayRecentClientMs: number
   /**
-   * 6.99.12: the questions route takes the COS Control Web session too, and a poll with `client=web` counts as a
-   * live answering client. A page reads this before it calls the route (an older server answers a cookie 401).
+   * 6.99.12: the questions route takes the COS Control Web session too. 6.99.13: a `client=web` poll no longer
+   * counts as a live answering client, so the Mac pops up at once; the web answers what the glasses or phone hold.
+   * A page reads this before it calls the route (an older server answers a cookie 401).
    */
   webClient: true
 }

package/server/lib/phone-recording.ts

@@ -17,7 +17,7 @@ export function phoneMicrophoneMeetingsCapability(serverInstanceId: string | nul
     try { reason = !serverInstanceId ? 'server_identity_unavailable' : readSttSettings().hq !== 'parakeet-ultra' ? 'parakeet_not_selected' : !parakeetInstalled().installed ? 'parakeet_not_installed' : 'ready' }
     catch { reason = 'parakeet_unavailable' }
   }
-  return { enabled: reason === 'ready', protocolVersion: 1 as const, sourceType: PHONE_SOURCE_TYPE, speakerPolicy: 'anonymous' as const, asrModel: 'parakeet-ultra', dictionary: 'server-profile-corrections', reason }
+  return { enabled: reason === 'ready', protocolVersion: 1 as const, sourceType: PHONE_SOURCE_TYPE, speakerPolicy: 'anonymous' as const, asrModel: 'parakeet-ultra', liveAsrModel: 'server-whisper' as const, dictionary: 'server-profile-corrections', reason }
 }
 /** Phone IDs and the new source marker must agree, including on rejected/replayed requests. */
 export function assertPhoneProvenance(id: unknown, fields: Record<string, unknown> | undefined): boolean {

package/server/routes/cos-thread.ts

@@ -0,0 +1,79 @@
+/**
+ * 6.99.16: the COS thread (lib/cos-thread.ts). Auth comes from the parent /api mount. Every answer is
+ * `Cache-Control: private, no-store`. Gated exactly like the Drop it routes (routes/drops.ts): while Drop it is off,
+ * every route answers 404 `{ error: { code: 'drop_it_off' } }` and no file is created (the store opens on the first
+ * request after the feature is turned on). Advertised as `capabilities.dropIt.thread: { protocol: 1 }` while on.
+ *
+ *   GET  /cos-thread                    CosThreadAnswer: the thread and what the next Ask should do
+ *   POST /cos-thread/new     {}         CosThreadAnswer (next.reason 'manual'): closes this thread, starts another
+ *   POST /cos-thread/turn    { clientId, sessionId, query, answer?, messageNo?, provider? }   CosThreadAnswer
+ *   GET  /cos-thread/search  ?q&limit   { hits: [{ threadId, sessionId, at, query, answerHead, messageNo }], scanned }
+ *   GET  /cos-thread/threads ?limit     { threads: [{ id, startedAt, endedAt, asks, segments, title }] }
+ */
+import { Router, type Response } from 'express'
+import { CosThread, CosThreadError, parseTurnInput } from '../lib/cos-thread.js'
+
+export interface CosThreadRouterDependencies {
+  enabled: () => boolean
+  /** The store, opened on first use. Null when it cannot open. */
+  thread: () => CosThread | null
+}
+
+const fail = (res: Response, error: unknown) => {
+  if (error instanceof CosThreadError) return res.status(error.status).json({ error: { code: error.code } })
+  console.error('[cos-thread] request failed:', error instanceof Error ? error.name : 'error')
+  return res.status(500).json({ error: { code: 'cos_thread_failed' } })
+}
+/** A whole number in [min, max], the default when absent, or null when present and out of range. */
+function intParam(raw: unknown, min: number, max: number, fallback: number): number | null {
+  if (raw === undefined) return fallback
+  if (typeof raw !== 'string' || !/^\d+$/.test(raw)) return null
+  const n = Number(raw)
+  return n >= min && n <= max ? n : null
+}
+
+export function createCosThreadRouter(deps: CosThreadRouterDependencies): Router {
+  const router = Router()
+  router.use('/cos-thread', (_req, res, next) => {
+    res.set('Cache-Control', 'private, no-store')
+    if (!deps.enabled()) return res.status(404).json({ error: { code: 'drop_it_off', message: 'Drop it is off on this server.' } })
+    next()
+  })
+  const withThread = (res: Response, fn: (t: CosThread) => unknown) => {
+    const thread = deps.thread()
+    if (!thread) return res.status(503).json({ error: { code: 'cos_thread_unavailable' } })
+    try { return fn(thread) } catch (e) { return fail(res, e) }
+  }
+
+  router.get('/cos-thread', (_req, res) => withThread(res, t => res.json(t.view())))
+
+  router.post('/cos-thread/new', (req, res) => {
+    const b = req.body
+    if (b !== undefined && (b === null || typeof b !== 'object' || Array.isArray(b) || Object.keys(b).length)) {
+      return res.status(400).json({ error: { code: 'invalid_request', message: 'Send {}.' } })
+    }
+    return withThread(res, t => res.json(t.startNew()))
+  })
+
+  router.post('/cos-thread/turn', (req, res) => {
+    const input = parseTurnInput(req.body)
+    if (!input) return res.status(400).json({ error: { code: 'invalid_turn' } })
+    return withThread(res, t => res.json(t.recordTurn(input)))
+  })
+
+  router.get('/cos-thread/search', (req, res) => {
+    const q = typeof req.query.q === 'string' ? req.query.q.trim() : ''
+    if (q.length < 2 || q.length > 200) return res.status(400).json({ error: { code: 'invalid_query', message: 'Search with 2 to 200 characters.' } })
+    const limit = intParam(req.query.limit, 1, 50, 20)
+    if (limit === null) return res.status(400).json({ error: { code: 'invalid_limit' } })
+    return withThread(res, t => res.json(t.search(q, limit)))
+  })
+
+  router.get('/cos-thread/threads', (req, res) => {
+    const limit = intParam(req.query.limit, 1, 100, 20)
+    if (limit === null) return res.status(400).json({ error: { code: 'invalid_limit' } })
+    return withThread(res, t => res.json(t.list(limit)))
+  })
+
+  return router
+}

package/server/routes/drops.ts

@@ -9,7 +9,9 @@
  *
  *   GET  /drops/settings                      { protocol, enabled, source, router }
  *   PUT  /drops/settings  { enabled }         same answer
- *   POST /drops           { dropId, text, source, hint?: { sessionId, label? }, file? }  DropAnswer
+ *   POST /drops           { dropId, text, source, hint?: { sessionId, label? }, file?, attachmentIds? }  DropAnswer
+ *                         6.99.13: attachmentIds, up to 5 fresh uploads (POST /api/media, /api/media/file), kept with the
+ *                         drop (lib/drop-attachments.ts). Words are still required. Advertised as dropIt.attachments.
  *   GET  /drops           ?q&kind&status&limit&before                                   History
  *   GET  /drops/:id                                                                     DropAnswer
  *   POST /drops/:id/undo                                                                DropAnswer
@@ -144,7 +146,7 @@ export function createDropsRouter(deps: DropsRouterDependencies): Router {
 
   router.post('/drops', (req, res) => withService(res, async service => {
     const b = req.body
-    if (!isRecord(b) || Object.keys(b).some(k => !['dropId', 'text', 'source', 'hint', 'file'].includes(k))) return bad(res, 'invalid_drop')
+    if (!isRecord(b) || Object.keys(b).some(k => !['dropId', 'text', 'source', 'hint', 'file', 'attachmentIds'].includes(k))) return bad(res, 'invalid_drop')
     try { return res.json(await service.submit(b as unknown as DropInput)) } catch (e) { return send(res, e) }
   }))
 

package/server/routes/permission-broker.ts

@@ -197,8 +197,8 @@ export function createSessionQuestionsRouter(deps: SessionQuestionsRouterDeps):
     // Only a client that says it can answer (and shows the cards) counts as live.
     const client = typeof req.query.client === 'string' ? req.query.client : ''
     if (byToken && ANSWERING_CLIENTS.has(client)) notePoll(now(), questionsPollFacts(req.query as Record<string, unknown>))
-    // 6.99.12: a browser counts only as `web`, and never with presence (no away hold from a tab).
-    else if (byWebSession && client === WEB_ANSWERING_CLIENT) notePoll(now(), {})
+    // 6.99.13 (Miles, option B): a browser poll never counts as live, so an open web tab never holds a question
+    // back from the Mac's own pop-up. The web still lists and answers what the glasses or phone are holding.
     const health = deps.broker.health()
     // Listed first: a deadline the timer has not caught yet is settled by the listing.
     const items = deps.broker.list()