@gotcos/glasses-server 6.99.12 → 6.99.20

package/server/lib/prep-store.ts

@@ -0,0 +1,226 @@
+/**
+ * Prep v1.1 (6.99.19): the durable Prep store at dataPath('prep').
+ *
+ *   drafts/<draftId>.json            one PrepDraft, written whole (fsync + rename, mode 0600)
+ *   files/<draftId>/<fileId>.bin     the original bytes, copied out of /api/media at add time (the media stage expires in 4 h)
+ *   files/<draftId>/<fileId>.txt     the extracted text a run and a bind read (ready files only)
+ *   runs/<draftId>/<clientRequestId>.txt   a run's exact prompt, saved before the job is submitted
+ *   binds/<draftId>/<sessionId>/<revision>.json   the exact Meeting Ask rows a bind attaches, saved before its intent
+ *
+ * Drafts are read back from disk on first use, so a restarted server (a fresh instance) serves the same drafts. Writes
+ * are synchronous inside one server process; prep-runtime.ts serializes each draft's read-modify-write. Nothing is
+ * auto-deleted in v1. A draft file that cannot be read is skipped and logged, never deleted.
+ */
+import { createHash } from 'node:crypto'
+import { lstatSync, mkdirSync, readFileSync, readdirSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { durableAtomicWriteFileSync } from './atomic-fs.js'
+import { dataPath } from './data-dir.js'
+import { ASK_SESSION } from './ask-session-id.js'
+import { PREP_DRAFT_ID, PREP_FILE_ID, PREP_PROVIDERS, PREP_UUID_V4, type PrepDraft, type PrepOccurrence } from '../../shared/prep.js'
+
+export class PrepError extends Error {
+  constructor(readonly code: string, readonly status = 400, readonly draft?: PrepDraft, readonly extra: Record<string, unknown> = {}) {
+    super(code)
+    this.name = 'PrepError'
+  }
+}
+
+/**
+ * v1.1 #16: "occ:v2:" + sha256("occ:v2:" + provider|account|calendarId|eventId or ""|externalId or ""|startsAt exact
+ * UTC ISO). Every part, no quantization, so distinct occurrences never coalesce. Finds a draft; never binds one.
+ */
+export function prepOccurrenceKey(o: Pick<PrepOccurrence, 'provider' | 'account' | 'calendarId' | 'eventId' | 'externalId' | 'startsAt'>): string {
+  const text = 'occ:v2:' + [o.provider, o.account ?? '', o.calendarId, o.eventId ?? '', o.externalId ?? '', new Date(Date.parse(o.startsAt)).toISOString()].join('|')
+  return 'occ:v2:' + createHash('sha256').update(text).digest('hex')
+}
+
+/**
+ * The provider identity, or null. All of provider, calendarId, eventId or externalId, and startsAt must be present
+ * (account is optional and part of the key); anything less is no identity at all, never a guess from title or time.
+ * A client-sent `key` is ignored and recomputed. A non-object is a 400.
+ */
+export function parsePrepOccurrence(raw: unknown): PrepOccurrence | null {
+  if (raw === null) return null
+  if (!raw || typeof raw !== 'object' || Array.isArray(raw)) throw new PrepError('invalid_occurrence')
+  const o = raw as Record<string, unknown>
+  const id = (v: unknown) => typeof v === 'string' && v.trim() && v.length <= 512 ? v : null
+  const iso = (v: unknown) => typeof v === 'string' && v.length <= 64 && Number.isFinite(Date.parse(v)) ? new Date(Date.parse(v)).toISOString() : null
+  const provider = PREP_PROVIDERS.includes(o.provider as never) ? o.provider as PrepOccurrence['provider'] : null
+  const account = id(o.account), calendarId = id(o.calendarId), eventId = id(o.eventId), externalId = id(o.externalId)
+  const startsAt = iso(o.startsAt)
+  if (!provider || !calendarId || (!eventId && !externalId) || !startsAt) return null
+  const base = { provider, account, calendarId, eventId, externalId, startsAt }
+  return { key: prepOccurrenceKey(base), ...base, endsAt: iso(o.endsAt) }
+}
+
+/** The loader skips a draft file larger than this; writes stop well short of it. */
+export const DRAFT_LOAD_BYTES = 5_000_000
+export const DRAFT_WRITE_BYTES = 4_000_000
+
+export class PrepStore {
+  readonly root: string
+  private cache: Map<string, PrepDraft> | null = null
+
+  constructor(root = dataPath('prep')) { this.root = resolve(root) }
+
+  private dir(...parts: string[]): string {
+    mkdirSync(this.root, { recursive: true, mode: 0o700 })
+    if (lstatSync(this.root).isSymbolicLink()) throw new PrepError('prep_store_unsafe', 503)
+    let p = this.root
+    for (const part of parts) {
+      p = join(p, part)
+      mkdirSync(p, { recursive: true, mode: 0o700 })
+      if (lstatSync(p).isSymbolicLink()) throw new PrepError('prep_store_unsafe', 503)
+    }
+    return p
+  }
+
+  private load(): Map<string, PrepDraft> {
+    if (this.cache) return this.cache
+    const drafts = new Map<string, PrepDraft>()
+    const dir = this.dir('drafts')
+    for (const name of readdirSync(dir)) {
+      if (!name.endsWith('.json')) continue
+      const id = name.slice(0, -5)
+      try {
+        const path = join(dir, name), st = lstatSync(path)
+        if (!PREP_DRAFT_ID.test(id) || !st.isFile() || st.size > DRAFT_LOAD_BYTES) throw new Error('unsafe')
+        const draft = JSON.parse(readFileSync(path, 'utf8')) as PrepDraft
+        if (draft?.id !== id || !Number.isSafeInteger(draft.revision) || !Array.isArray(draft.files)) throw new Error('shape')
+        draft.snapshots ??= []
+        draft.fileOperations ??= []
+        drafts.set(id, draft)
+      } catch {
+        // Kept on disk for a person to look at; it simply is not served.
+        console.warn(`[prep] skipped an unreadable draft file (${id.slice(0, 12)})`)
+      }
+    }
+    this.cache = drafts
+    return drafts
+  }
+
+  get(id: string): PrepDraft | undefined {
+    if (!PREP_DRAFT_ID.test(id)) return undefined
+    const d = this.load().get(id)
+    return d ? structuredClone(d) : undefined
+  }
+
+  list(): PrepDraft[] { return [...this.load().values()].map(d => structuredClone(d)) }
+
+  byClientDraftId(clientDraftId: string): PrepDraft | undefined {
+    for (const d of this.load().values()) if (d.clientDraftId === clientDraftId) return structuredClone(d)
+    return undefined
+  }
+
+  write(draft: PrepDraft): PrepDraft {
+    if (!PREP_DRAFT_ID.test(draft.id)) throw new PrepError('invalid_draft_id')
+    const encoded = JSON.stringify(draft)
+    // Never write a draft the loader would refuse: it would vanish on the next restart.
+    if (Buffer.byteLength(encoded, 'utf8') > DRAFT_WRITE_BYTES) throw new PrepError('prep_draft_too_large', 507)
+    try {
+      durableAtomicWriteFileSync(join(this.dir('drafts'), draft.id + '.json'), encoded, { mode: 0o600 })
+    } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+    this.load().set(draft.id, structuredClone(draft))
+    return structuredClone(draft)
+  }
+
+  private blobPath(draftId: string, fileId: string, ext: 'bin' | 'txt'): string {
+    if (!PREP_DRAFT_ID.test(draftId) || !PREP_FILE_ID.test(fileId)) throw new PrepError('invalid_file_id')
+    return join(this.dir('files', draftId), `${fileId}.${ext}`)
+  }
+
+  putOriginal(draftId: string, fileId: string, bytes: Buffer): void {
+    try { durableAtomicWriteFileSync(this.blobPath(draftId, fileId, 'bin'), bytes, { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  putText(draftId: string, fileId: string, text: string): void {
+    try { durableAtomicWriteFileSync(this.blobPath(draftId, fileId, 'txt'), text, { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  readOriginal(draftId: string, fileId: string): Buffer {
+    try { return readFileSync(this.blobPath(draftId, fileId, 'bin')) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('file_not_found', 404)
+    }
+  }
+
+  /** The stored text, or '' when the file has none (not ready, or never extracted). */
+  readText(draftId: string, fileId: string): string {
+    try { return readFileSync(this.blobPath(draftId, fileId, 'txt'), 'utf8') } catch (e) {
+      if (e instanceof PrepError) throw e
+      return ''
+    }
+  }
+
+  /** The exact prompt of a run, saved before its job is submitted so a retry after a crash resubmits the same bytes. */
+  putPrompt(draftId: string, clientRequestId: string, prompt: string): void {
+    try { durableAtomicWriteFileSync(this.promptPath(draftId, clientRequestId), prompt, { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  readPrompt(draftId: string, clientRequestId: string): string | null {
+    try { return readFileSync(this.promptPath(draftId, clientRequestId), 'utf8') } catch (e) {
+      if (e instanceof PrepError) throw e
+      return null
+    }
+  }
+
+  private promptPath(draftId: string, clientRequestId: string): string {
+    if (!PREP_DRAFT_ID.test(draftId) || !PREP_UUID_V4.test(clientRequestId)) throw new PrepError('invalid_client_request_id')
+    return join(this.dir('runs', draftId), `${clientRequestId}.txt`)
+  }
+
+  /**
+   * The exact Meeting Ask rows one bind attaches, saved before the binding intent, so a retry after a crash re-applies
+   * the frozen revision rather than whatever the draft holds by then.
+   */
+  putBindPayload(draftId: string, sessionId: string, revision: number, rows: unknown[]): void {
+    try { durableAtomicWriteFileSync(this.bindPath(draftId, sessionId, revision), JSON.stringify(rows), { mode: 0o600 }) } catch (e) {
+      if (e instanceof PrepError) throw e
+      throw new PrepError('prep_write_failed', 507)
+    }
+  }
+
+  readBindPayload(draftId: string, sessionId: string, revision: number): unknown[] | null {
+    try {
+      const rows = JSON.parse(readFileSync(this.bindPath(draftId, sessionId, revision), 'utf8'))
+      return Array.isArray(rows) ? rows : null
+    } catch (e) {
+      if (e instanceof PrepError) throw e
+      return null
+    }
+  }
+
+  /** Keyed by (draft, meeting, revision): a replay of one bind can never read another bind's rows. */
+  private bindPath(draftId: string, sessionId: string, revision: number): string {
+    if (!PREP_DRAFT_ID.test(draftId) || !ASK_SESSION.test(sessionId) || !Number.isSafeInteger(revision) || revision < 0) throw new PrepError('invalid_session_id')
+    return join(this.dir('binds', draftId, sessionId), `${revision}.json`)
+  }
+
+  /** Bytes on disk under the store root (drafts, originals, text). Walked on each add: at most 300 drafts x 10 files. */
+  usageBytes(): number {
+    let total = 0
+    const walk = (p: string) => {
+      for (const name of readdirSync(p)) {
+        const child = join(p, name), st = lstatSync(child)
+        if (st.isSymbolicLink()) continue
+        if (st.isDirectory()) walk(child)
+        else if (st.isFile()) total += st.size
+      }
+    }
+    walk(this.dir())
+    return total
+  }
+}

package/server/lib/stt-resolver.ts

@@ -17,6 +17,13 @@
 //      holds a profile vocabulary term the primary's side does not, the second
 //      opinion's words are taken.
 //
+// A third caller (6.99.18) is the saved iPhone transcript, where the second
+// side is the live Whisper words the phone already heard with the vocabulary
+// prompt. Those words have approximate clocks and a prompted Whisper can echo a
+// vocabulary term into a pause, so that caller sets anchoredVocabularyOnly: a
+// term is taken only where the primary heard other words in the same place,
+// and the taken words are clocked across the primary words they replace.
+//
 // Everything else stays as the primary heard it. No region whose two sides
 // differ in a negation, a number or a unit is ever changed, whatever its length
 // (the 2026-10-13 diagnostic saw "born lacking" become "born having" and
@@ -37,7 +44,7 @@ export interface Hypothesis {
 }
 
 export type DisagreementKind = 'substitution' | 'primary_only' | 'second_only'
-export type ResolutionReason = 'gap_fill' | 'vocabulary' | 'protected' | 'not_speech' | 'low_confidence' | 'too_wide' | null
+export type ResolutionReason = 'gap_fill' | 'vocabulary' | 'protected' | 'not_speech' | 'low_confidence' | 'too_wide' | 'unanchored' | null
 
 export interface Disagreement {
   kind: DisagreementKind
@@ -66,6 +73,10 @@ export interface ResolveOptions {
    *  10 s) made the resolver worse than plain text alignment, because Large-v3's
    *  remapped token clocks have a heavy tail (median skew 0.23 s, p90 1.0 s). */
   maxSkewSec?: number | null
+  /** The second side's clocks are approximate (live words). A vocabulary term is
+   *  taken only from a substitution, never an insertion the primary has nothing
+   *  for, and the taken words are clocked across the primary words they replace. */
+  anchoredVocabularyOnly?: boolean
 }
 
 export interface ResolveResult {
@@ -241,6 +252,15 @@ function gapVerdict(q: Token[], options: ResolveOptions): ResolutionReason {
   return 'gap_fill'
 }
 
+/** The second side's words spread evenly over the time the replaced primary words took. */
+function reclock(q: Token[], p: Token[]): Token[] {
+  const { start, end } = span(p)
+  if (start === null) return q.map(t => ({ ...t, start: null, end: null }))
+  const stop = Math.max(start, end ?? start)
+  const step = (stop - start) / q.length
+  return q.map((t, i) => ({ ...t, start: start + i * step, end: start + (i + 1) * step }))
+}
+
 export function resolveHypotheses(primary: Hypothesis, second: Hypothesis, options: ResolveOptions): ResolveResult {
   const P = tokens(primary), Q = tokens(second)
   const toWords = (ts: Token[]): HypWord[] => ts.map(t => ({
@@ -290,6 +310,7 @@ export function resolveHypotheses(primary: Hypothesis, second: Hypothesis, optio
       const wantVocab = newTerms.length > 0
       if (wantGap || wantVocab) {
         if (!sameProtected(p, q)) reason = 'protected'
+        else if (wantVocab && options.anchoredVocabularyOnly && !p.length) reason = 'unanchored'
         else if (wantVocab && (q.length > MAX_VOCAB_REGION_WORDS || p.length > q.length + MAX_VOCAB_REGION_SLACK)) {
           // A term inside a long disagreement is not a reason to swap the whole region.
           reason = wantGap ? gapVerdict(q, options) : 'too_wide'
@@ -308,7 +329,10 @@ export function resolveHypotheses(primary: Hypothesis, second: Hypothesis, optio
       taken: options.apply ? take : 'primary',
       reason,
     })
-    if (options.apply && take === 'second') { out.push(...q); wordsFromSecond += q.length }
+    if (options.apply && take === 'second') {
+      out.push(...(options.anchoredVocabularyOnly ? reclock(q, p) : q))
+      wordsFromSecond += q.length
+    }
     else out.push(...p)
   }
   return {

package/server/lib/transcript-cleanup.ts

@@ -28,6 +28,7 @@
 
 import { existsSync, mkdirSync, appendFileSync, readFileSync, renameSync, statSync } from 'node:fs'
 import { dirname } from 'node:path'
+import { isPrepCopyId } from '../../shared/prep.js'
 import { LensGistLimitError, runLensGistEngine } from './lens-gist-engines.js'
 import { resolveProviderBinary } from './provider-binary.js'
 import { getVocabulary, getWhisperCorrections } from './profile.js'
@@ -167,11 +168,19 @@ const notesSearchDefault: CleanupDeps['searchNotes'] = async (queries, sessionId
   })(queries, sessionId, signal)
 }
 
+/**
+ * The meeting files whose words may steer saved-transcript cleanup. Pasted text and read pages (paste_, web_) are
+ * article words, not the room's vocabulary, and so are Prep copies (prep_prep_..., 6.99.19): notes and documents
+ * written before the call. None of them may rewrite the saved transcript.
+ */
+export function cleanupVocabularyFiles(files: ReadonlyArray<{ id: string; name: string; status: string; text: string }>, isPastedFileId: (id: string) => boolean): CleanupFile[] {
+  return files.filter(f => !isPastedFileId(f.id) && !isPrepCopyId(f.id) && f.status === 'ready' && typeof f.text === 'string' && f.text.trim()).map(f => ({ name: f.name, text: f.text }))
+}
+
 const filesDefault: CleanupDeps['files'] = async sessionId => {
   try {
     const { MeetingAskStore, isPastedFileId } = await import('./meeting-ask-store.js')
-    // Pasted text and read pages (paste_, web_) are article words, not the room's vocabulary: they must not rewrite the saved transcript.
-    return new MeetingAskStore().files(sessionId).filter(f => !isPastedFileId(f.id) && f.status === 'ready' && typeof f.text === 'string' && f.text.trim()).map(f => ({ name: f.name, text: f.text }))
+    return cleanupVocabularyFiles(new MeetingAskStore().files(sessionId), isPastedFileId)
   } catch { return [] }
 }
 

package/server/lib/work-orchestrator/runtime.ts

@@ -48,14 +48,20 @@ export const INPUT_SCAN_WAIT_MS = 20_000
 
 /** What one plan input reads. The server passes the process-wide stores; a test passes its own. */
 export interface OrchestratorParts { tags: TagIndex; usage: UsageMonitor; snapshot: () => ControlSnapshot | null }
+export interface OrchestratorInputOptions {
+  /** Read the existing usage view only, without starting provider usage subprocesses. Default retains Work's refresh. */
+  usageMode?: 'cached'
+}
 
-export async function orchestratorInputFor(workID: string, meetingWorkIDs: string[], parts?: OrchestratorParts): Promise<OrchestratorInput> {
+export async function orchestratorInputFor(workID: string, meetingWorkIDs: string[], parts?: OrchestratorParts,
+  options: OrchestratorInputOptions = {}): Promise<OrchestratorInput> {
   const tags = parts?.tags ?? orchestratorTagIndex()
   const monitor = parts?.usage ?? orchestratorUsage()
   const scan = tags.refresh().catch(() => null)
   const scanned = await Promise.race([scan, new Promise<null>(r => setTimeout(() => r(null), INPUT_SCAN_WAIT_MS).unref?.())])
   // On demand: the plan this input feeds may fork or start a session, so a reading older than 2 minutes is re-read.
-  const usageViews = await monitor.forPlan()
+  // Ask's proposal-only adapter uses cache-only evidence; it does not own the usage probes' child lifetimes.
+  const usageViews = options.usageMode === 'cached' ? monitor.views() : await monitor.forPlan()
   const roots = agentSessionRoots()
   return buildOrchestratorInput(workID, meetingWorkIDs, {
     snapshot: parts ? parts.snapshot() : orchestratorSnapshots().get(),

package/server/routes/ask-work-plan.ts

@@ -0,0 +1,114 @@
+/** Mounted under authenticated /api. Plan-only: never records a round, sends a handoff or writes a task. */
+import { Router } from 'express'
+import { ASK_WORK_PLAN_PROTOCOL, ASK_WORK_PLAN_BODY_BYTES, ASK_WORK_PLAN_DEADLINE_MS, ASK_WORK_PLAN_RULES,
+  AskWorkPlanError, parseAskWorkPlanRequest, resolveAskWorkTask, askWorkMeetingIDs, prepareAskWorkPlan, askWorkProposalID } from '../lib/ask-work-plan.js'
+import { listBoard, type TaskBoardRow } from '../lib/task-store.js'
+import { createWorkBoardReader } from '../lib/work-board-reader.js'
+import { orchestratorInputFor, type OrchestratorParts } from '../lib/work-orchestrator/runtime.js'
+import { runMeetingAskModel, AskProcessError } from '../lib/meeting-ask-runner.js'
+import { maintenanceAdmissionsOpen, acquireMaintenanceWork } from '../lib/maintenance-lifecycle.js'
+import { parseWorkChatAnswer, WORK_CHAT_SYSTEM, WORK_CHAT_ORCHESTRATOR_RULES, WORK_CHAT_PLANNERS, WORK_CHAT_EFFORTS,
+  WORK_CHAT_DEFAULT_EFFORT, WORK_CHAT_ORCHESTRATOR_OUTPUT_TOKENS, WORK_CHAT_THINKING_TOKENS,
+  WORK_CHAT_DEADLINE_MS, WORK_CHAT_MAX_ASSIGNMENTS } from '../lib/work-chat.js'
+
+export interface AskWorkPlanDeps {
+  board: () => Promise<TaskBoardRow[]>
+  input: typeof orchestratorInputFor
+  run: typeof runMeetingAskModel
+  admissions: () => boolean
+  lease: () => { release(): void }
+  now: () => number
+}
+/** Ask never launches usage probes; stale or unknown cached headroom disables targets in prepareAskWorkPlan. */
+export function readAskWorkPlanInput(workID: string, meetingWorkIDs: string[], parts?: OrchestratorParts) {
+  return orchestratorInputFor(workID, meetingWorkIDs, parts, { usageMode: 'cached' })
+}
+const defaults: AskWorkPlanDeps = {
+  // A new reader guarantees the post-plan revision check starts a new bounded board read.
+  board: () => createWorkBoardReader(() => listBoard()).read(0), input: readAskWorkPlanInput, run: runMeetingAskModel,
+  admissions: maintenanceAdmissionsOpen, lease: () => acquireMaintenanceWork('work_chat'), now: Date.now,
+}
+
+export function createAskWorkPlanRouter(given: Partial<AskWorkPlanDeps> = {}) {
+  const deps = { ...defaults, ...given }, router = Router()
+  let running = false
+  router.use('/ask/work-plan', (_req, res, next) => { res.set('Cache-Control', 'private, no-store'); next() })
+  router.get('/ask/work-plan', (_req, res) => res.json({ protocolVersion: ASK_WORK_PLAN_PROTOCOL, planOnly: true,
+    requiresExistingWork: true, dispatch: false, controlSnapshot: 1, planner: 'sonnet', planners: WORK_CHAT_PLANNERS,
+    effort: WORK_CHAT_DEFAULT_EFFORT, efforts: WORK_CHAT_EFFORTS, maxAssignments: WORK_CHAT_MAX_ASSIGNMENTS,
+    maxQuestionChars: 2000, maxBodyBytes: ASK_WORK_PLAN_BODY_BYTES }))
+  router.post('/ask/work-plan', async (req, res) => {
+    const fail = (error: unknown) => {
+      const known = error instanceof AskWorkPlanError
+      if (!res.destroyed) res.status(known ? error.status : 503).json({ error: known ? error.code : 'ask_work_plan_unavailable',
+        message: known && error.code === 'question_contains_sensitive_text'
+          ? 'Remove credentials from the question and try again.'
+          : 'No assignment was dispatched. Refresh the task and retry the plan.' })
+    }
+    let request
+    try { request = parseAskWorkPlanRequest(req.body) } catch (error) { fail(error); return }
+    if (!deps.admissions()) { fail(new AskWorkPlanError('maintenance', 503)); return }
+    if (running) { fail(new AskWorkPlanError('ask_work_plan_busy', 409)); return }
+    running = true
+    const controller = new AbortController(), abort = () => controller.abort()
+    const timer = setTimeout(abort, ASK_WORK_PLAN_DEADLINE_MS)
+    res.on('close', abort)
+    let lease: ReturnType<AskWorkPlanDeps['lease']> | undefined
+    let release = true
+    try {
+      lease = deps.lease()
+      let rows: TaskBoardRow[]
+      try { rows = await deps.board() }
+      catch { throw new AskWorkPlanError('work_board_unavailable', 503) }
+      if (controller.signal.aborted) throw new AskWorkPlanError('ask_work_plan_canceled', 408)
+      const task = resolveAskWorkTask(request, rows)
+      let evidence
+      // The default reads cached usage only. Still await the bounded evidence dependency before releasing admission.
+      try { evidence = await deps.input(request.workID, askWorkMeetingIDs(task)) }
+      catch { throw new AskWorkPlanError('orchestrator_input_unavailable', 503) }
+      if (controller.signal.aborted) throw new AskWorkPlanError('ask_work_plan_canceled', 408)
+      const prepared = prepareAskWorkPlan(request, task, evidence, deps.now())
+      if (controller.signal.aborted) throw new AskWorkPlanError('ask_work_plan_canceled', 408)
+      if (!deps.admissions()) throw new AskWorkPlanError('maintenance', 503)
+      const { planner = 'sonnet', effort = WORK_CHAT_DEFAULT_EFFORT, ...prompt } = prepared.input
+      // The runner settles only after termination proof (or explicit unconfirmed exit). Racing its
+      // promise with abort would release the lease and admit another provider during the kill wait.
+      const output = await deps.run({ engine: 'claude', model: planner }, JSON.stringify(prompt),
+        WORK_CHAT_SYSTEM + '\n\n' + WORK_CHAT_ORCHESTRATOR_RULES + '\n\n' + ASK_WORK_PLAN_RULES,
+        controller.signal, undefined, { caller: 'ask_work_plan' }, { effort, maxOutputTokens: WORK_CHAT_ORCHESTRATOR_OUTPUT_TOKENS,
+          maxThinkingTokens: WORK_CHAT_THINKING_TOKENS[effort], deadlineMs: WORK_CHAT_DEADLINE_MS })
+      if (controller.signal.aborted) throw new AskWorkPlanError('ask_work_plan_canceled', 408)
+      let answer
+      try { answer = parseWorkChatAnswer(output.text, prepared.input) }
+      catch { throw new AskWorkPlanError('invalid_plan_answer', 503) }
+      // A model may take minutes; never return an apparently current proposal for a changed/finished task.
+      try { rows = await deps.board() }
+      catch { throw new AskWorkPlanError('work_board_unavailable', 503) }
+      if (controller.signal.aborted) throw new AskWorkPlanError('ask_work_plan_canceled', 408)
+      const currentTask = resolveAskWorkTask(request, rows)
+      try { evidence = await deps.input(request.workID, askWorkMeetingIDs(currentTask)) }
+      catch { throw new AskWorkPlanError('orchestrator_input_unavailable', 503) }
+      if (controller.signal.aborted) throw new AskWorkPlanError('ask_work_plan_canceled', 408)
+      const current = prepareAskWorkPlan(request, currentTask, evidence, deps.now())
+      // Revalidate every proposed target against current discovery, live state and plan headroom.
+      try { answer = parseWorkChatAnswer(output.text, current.input) }
+      catch { throw new AskWorkPlanError('plan_targets_changed', 409) }
+      if (!res.destroyed) res.json({ protocolVersion: ASK_WORK_PLAN_PROTOCOL, planOnly: true, workID: request.workID,
+        revision: request.revision, title: prepared.title, ...answer, evidence: prepared.evidence, revalidatedEvidence: current.evidence,
+        proposalID: askWorkProposalID(prepared.input, answer), question: prepared.input.question, createdAt: new Date(deps.now()).toISOString(),
+        model: output.model ?? `claude:${planner} (requested)`, effort })
+    } catch (error) {
+      if (error instanceof AskProcessError && error.terminationUnconfirmed) {
+        // Match Meeting Ask's orphan policy: no second process or maintenance drain until recovery.
+        release = false
+        console.warn('[ask-work-plan] provider termination unconfirmed; admission and maintenance lease retained')
+        fail(new AskWorkPlanError('provider_termination_unconfirmed', 503))
+      } else fail(error)
+    }
+    finally {
+      clearTimeout(timer); res.off('close', abort)
+      if (release) { lease?.release(); running = false }
+    }
+  })
+  return router
+}

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/health.ts

@@ -1,4 +1,5 @@
 import { dropItCapability } from '../lib/drop-settings.js'
+import { PREP_CAPABILITY } from '../../shared/prep.js'
 import { phoneMicrophoneMeetingsCapability } from '../lib/phone-recording.js'
 import { macLiveVoicesSnapshot } from '../lib/mac-window-replay.js'
 import { DICTATION_CLEAN_MODELS } from '../lib/dictation-clean-models.js'
@@ -465,6 +466,9 @@ healthRouter.get('/health', async (_req, res) => {
       providerObserveFields({ state: cachedHookStatus().state, ready: hookHaltReady(cachedHookStatus()) }),
     ),
     server_instance_id: getServerInstanceId(),
+    // 6.99.20: the same id in camelCase, the name COS Control 0.5.376's Prep discovery reads from /api/health
+    // (it refused Prep with "did not answer Prep discovery" when only server_instance_id was here). Additive.
+    serverInstanceId: getServerInstanceId(),
     boot_id: serverMetrics.bootId,
     generation_id: getServerGenerationId(),
     mediaLimits,
@@ -538,6 +542,8 @@ healthRouter.get('/health', async (_req, res) => {
       titleSteer: TITLE_STEER_CAPABILITY,
       // Drop it P1: the pinned COS chat (routes/drops.ts). Codes only; `enabled` is false unless turned on. Absent on an older server.
       dropIt: dropItCapability(),
+      // 6.99.19 Prep: notes and files before a call, kept in the meeting by an explicit bind (routes/prep.ts). Absent on an older server.
+      prep: { ...PREP_CAPABILITY, serverInstanceId: getServerInstanceId() },
       // 6.77.0: codes only (this route is public): the protocol and whether the switch is on.
       transcriptCleanup: transcriptCleanupAdvertised(),
       richMedia: {
@@ -752,6 +758,8 @@ healthRouter.get('/models', async (req, res) => {
       titleSteer: TITLE_STEER_CAPABILITY,
       // Drop it P1: the pinned COS chat (routes/drops.ts). Codes only; `enabled` is false unless turned on. Absent on an older server.
       dropIt: dropItCapability(),
+      // 6.99.19 Prep: notes and files before a call, kept in the meeting by an explicit bind (routes/prep.ts). Absent on an older server.
+      prep: { ...PREP_CAPABILITY, serverInstanceId: getServerInstanceId() },
       richMedia: {
         video: richMedia.video,
         maxPromptVisuals: MAX_MODEL_IMAGE_INPUTS,

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()