@gotcos/glasses-server 6.99.16 → 6.99.25

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

@@ -0,0 +1,81 @@
+/**
+ * Prep v1.1 routes (6.99.19). Mounted under /api, so the X-Cos-Token check in index.ts runs first. Every answer is
+ * Cache-Control: no-store and carries the top-level `serverInstanceId` (errors included; the original-bytes route
+ * sends it as the X-COS-Server-Instance header). Errors are `{ error: '<code>' }` like Meeting Ask; a revision conflict
+ * also carries `draft`, run_in_progress carries `run`, and file_context_limit carries needBytes and haveBytes.
+ * Every mutation requires X-COS-Expected-Server-Instance (v1.1 #19), checked before the runtime is called. The
+ * behaviour lives in lib/prep-runtime.ts; shared/prep.ts lists the routes and DTOs.
+ */
+import { Router, type Request, type Response } from 'express'
+import { PrepError } from '../lib/prep-store.js'
+import { wellFormed, type PrepRuntime } from '../lib/prep-runtime.js'
+
+export const EXPECTED_SERVER_HEADER = 'x-cos-expected-server-instance'
+
+/** An ASCII fallback name plus the RFC 5987 UTF-8 name: no quotes, slashes or control characters reach the header. */
+export function attachmentDisposition(name: string): string {
+  // By code point, without lone surrogates: encodeURIComponent throws URIError on half an emoji.
+  const whole = Array.from(wellFormed(name)).slice(0, 240).join('')
+  const ascii = whole.replace(/[^A-Za-z0-9._ -]/g, '_').replace(/^[ .]+/, '').slice(0, 120) || 'file'
+  return `attachment; filename="${ascii}"; filename*=UTF-8''${encodeURIComponent(whole)}`
+}
+
+export function createPrepRouter(runtime: PrepRuntime): Router {
+  const router = Router()
+  router.use('/prep', (_q, res, next) => { res.set('Cache-Control', 'no-store'); next() })
+
+  const serverInstanceId = () => { try { return runtime.serverInstanceId() } catch { return null } }
+  const send = (res: Response, status: number, body: Record<string, unknown>) => res.status(status).json({ ...body, serverInstanceId: serverInstanceId() })
+  const failure = (res: Response, error: unknown) => {
+    if (error instanceof PrepError) {
+      send(res, error.status, { error: error.code, ...error.extra, ...(error.draft ? { draft: error.draft } : {}) })
+      return
+    }
+    console.warn('[prep] request failed:', error instanceof Error ? error.message : 'unknown')
+    send(res, 503, { error: 'prep_unavailable' })
+  }
+  /** A mutation: the expected server is checked before the runtime runs anything. */
+  const write = (status: number, fn: (req: Request) => Promise<Record<string, unknown>>) => async (req: Request, res: Response) => {
+    try {
+      runtime.authorize(req.get(EXPECTED_SERVER_HEADER))
+      send(res, status, await fn(req))
+    } catch (e) { failure(res, e) }
+  }
+  const read = (fn: (req: Request) => Promise<Record<string, unknown>> | Record<string, unknown>) => async (req: Request, res: Response) => {
+    try { send(res, 200, await fn(req)) } catch (e) { failure(res, e) }
+  }
+
+  router.post('/prep/drafts', async (req, res) => {
+    try {
+      runtime.authorize(req.get(EXPECTED_SERVER_HEADER))
+      const { draft, created } = await runtime.create(req.body)
+      send(res, created ? 201 : 200, { draft })
+    } catch (e) { failure(res, e) }
+  })
+  router.get('/prep/drafts', read(req => ({ drafts: runtime.list({ occurrence: req.query.occurrence, state: req.query.state, limit: req.query.limit }) })))
+  router.get('/prep/drafts/:id', read(async req => ({ draft: await runtime.get(String(req.params.id)) })))
+  router.delete('/prep/drafts/:id', write(200, async req => ({ draft: await runtime.archive(String(req.params.id)) })))
+  router.patch('/prep/drafts/:id', write(200, async req => ({ draft: await runtime.patch(String(req.params.id), req.body) })))
+  router.post('/prep/drafts/:id/files', write(200, async req => ({ draft: await runtime.addFiles(String(req.params.id), req.body) })))
+  router.delete('/prep/drafts/:id/files/:fileId', write(200, async req => ({ draft: await runtime.removeFile(String(req.params.id), String(req.params.fileId), req.query.revision, req.query.serverInstanceId) })))
+  router.get('/prep/drafts/:id/files/:fileId', (req, res) => {
+    try {
+      const file = runtime.readOriginal(String(req.params.id), String(req.params.fileId))
+      res.set({ 'Content-Type': file.mime, 'Content-Disposition': attachmentDisposition(file.name), 'X-Content-Type-Options': 'nosniff', 'X-COS-Server-Instance': serverInstanceId() ?? '' })
+      res.send(file.bytes)
+    } catch (e) { failure(res, e) }
+  })
+  router.get('/prep/drafts/:id/files/:fileId/text', read(req => ({ text: runtime.readText(String(req.params.id), String(req.params.fileId)) })))
+  router.post('/prep/drafts/:id/run', write(202, async req => ({ ...await runtime.run(String(req.params.id), req.body) })))
+  router.get('/prep/drafts/:id/runs/:clientRequestId', async (req, res) => {
+    try {
+      const { status, run, job } = await runtime.getRun(String(req.params.id), String(req.params.clientRequestId))
+      send(res, status, status === 202 ? { run } : { run, job })
+    } catch (e) { failure(res, e) }
+  })
+  router.post('/prep/drafts/:id/bind', write(200, async req => ({ ...await runtime.bind(String(req.params.id), req.body) })))
+  router.delete('/prep/drafts/:id/bind/:sessionId', write(200, async req => ({ draft: await runtime.unbind(String(req.params.id), String(req.params.sessionId), req.query.serverInstanceId) })))
+  router.get('/prep/by-session/:sessionId', read(req => ({ snapshots: runtime.bySession(String(req.params.sessionId)) })))
+  router.get('/prep/suggest', read(req => ({ drafts: runtime.suggest({ sessionId: req.query.sessionId, startedAt: req.query.startedAt }) })))
+  return router
+}

package/server/routes/web-control.ts

@@ -1,4 +1,7 @@
 import express, { Router, type Request, type Response } from 'express'
+import fs from 'node:fs'
+import crypto from 'node:crypto'
+import path from 'node:path'
 import { hostname, networkInterfaces } from 'node:os'
 import {
   hasProxyForwardedHeaders,
@@ -39,11 +42,20 @@ import {
 } from '../lib/web-memories-bridge.js'
 import { listLiveTranscriptSessions, readLiveTranscriptSession } from '../lib/web-live-chunks.js'
 import { getWebUsageSummary } from '../lib/web-usage-bridge.js'
+import { WEB_PET_POSES, controlSupportDir, petChunk, petPreview, planPose, readPetSources, webPetManifest, type WebPetPose } from '../lib/web-pet.js'
+import { controlResourcesDir, galleryPets, galleryThumb, parsePetChoice, petChoiceKey, resolvePet, shippedPets, type PetChoice, type PetFetcher } from '../lib/web-pet-choice.js'
+import { dataPath } from '../lib/data-dir.js'
 
 export { isMemoryWebOpReadOnly, MUTATING_MEMORY_WEB_OPS, READ_ONLY_MEMORY_WEB_OPS }
 
 export interface WebControlRouterDeps {
   apiToken: () => string
+  /** Tests: where the pet's state map and strips live, the chunk cache, and a stand-in for sips. */
+  petSupportDir?: () => string
+  petCacheDir?: () => string
+  petRun?: (cmd: string, args: string[]) => Promise<void>
+  petResourcesDir?: () => string | null
+  petFetch?: PetFetcher
   port: () => number
   publicPort?: () => number
   httpsPort?: () => number | null
@@ -166,17 +178,15 @@ export function webControlEnabled(env: NodeJS.ProcessEnv = process.env): boolean
 }
 
 /**
- * CSP for `/control/*`. The shell (index.html, app.js, theme.js) has no inline script, so it
- * gets `script-src 'self'`: an injected `<img onerror>` in rendered session or meeting text
- * cannot run. The hosted Memories page is the native bundle as shipped and still uses inline
- * `onclick` handlers, so only `/control/memories/*` keeps `'unsafe-inline'`.
+ * CSP for `/control/*`. No page has inline script, so every path gets `script-src 'self'`: an injected
+ * `<img onerror>` in rendered session or meeting text cannot run. 6.99.25: Memories is a native pane
+ * (panes/memories.js); the hosted page and its `/control/memories/*` 'unsafe-inline' exception are gone.
  * `frame-ancestors 'self'` stops another site framing the signed-in page.
  */
-export function webControlCsp(requestPath: string): string {
-  const inlineScripts = requestPath.startsWith('/memories/')
+export function webControlCsp(_requestPath: string): string {
   return [
     "default-src 'self'",
-    inlineScripts ? "script-src 'self' 'unsafe-inline'" : "script-src 'self'",
+    "script-src 'self'",
     "style-src 'self' 'unsafe-inline'",
     "font-src 'self' data:",
     "img-src 'self' data: blob:",
@@ -550,6 +560,99 @@ export function createWebControlRouter(deps: WebControlRouterDeps): Router {
     res.json(summary)
   })
 
+  // The session pet on Home (lib/web-pet.ts) and the pet picker (lib/web-pet-choice.ts). `?pet=` is the browser's
+  // choice: mac (default), shipped:<id> or gallery:<id>. Everything here reads COS Control's files; nothing writes them.
+  const petDir = (): string => deps.petSupportDir?.() ?? controlSupportDir()
+  const petResources = (): string | null => (deps.petResourcesDir ? deps.petResourcesDir() : controlResourcesDir())
+  const petCacheRoot = (): string => deps.petCacheDir?.() ?? dataPath('web-pet')
+  const petCacheFor = (name: string): string => (name ? path.join(petCacheRoot(), name) : petCacheRoot())
+  const petChoiceOf = (req: Request): PetChoice | null => parsePetChoice(req.query.pet ?? 'mac')
+  const resolveFor = (choice: PetChoice) => resolvePet(choice, { supportDir: petDir(), resources: petResources() })
+  const sendImage = async (res: Response, file: string, type: string, immutable: boolean): Promise<void> => {
+    res.set('Cache-Control', immutable ? 'private, max-age=31536000, immutable' : 'private, no-cache')
+    // Not sendFile: it refuses any path with a dot folder, and the cache lives under ~/.cos-glasses.
+    res.type(type).send(await fs.promises.readFile(file))
+  }
+  const fileTag = (file: string): string => { try { const st = fs.statSync(file); return `${st.size}-${Math.round(st.mtimeMs)}` } catch { return '0' } }
+
+  router.get('/web-pet', (req: Request, res: Response) => {
+    res.set('Cache-Control', 'private, no-store')
+    const choice = petChoiceOf(req)
+    if (!choice) return res.status(400).json({ error: 'pet_choice_invalid' })
+    const key = petChoiceKey(choice)
+    const found = resolveFor(choice)
+    if (!found) return res.json({ available: false, pet: key, poses: {} })
+    if (found.kind === 'strips') return res.json({ ...webPetManifest(found.dir, key), pet: key, kind: 'strips' })
+    const tag = found.kind === 'still' ? fileTag(found.file) : found.preview
+    return res.json({ available: true, pet: key, kind: 'still', poses: {}, still: `/api/web-pet/still?pet=${encodeURIComponent(key)}&v=${encodeURIComponent(crypto.createHash('sha256').update(tag).digest('hex').slice(0, 16))}` })
+  })
+
+  router.get('/web-pet/sheet/:pose/:chunk', async (req: Request, res: Response) => {
+    const choice = petChoiceOf(req)
+    const found = choice ? resolveFor(choice) : null
+    if (!found || found.kind !== 'strips') return res.status(404).json({ error: 'pet_unavailable' })
+    const pose = String(req.params.pose) as WebPetPose
+    const src = (WEB_PET_POSES as readonly string[]).includes(pose) ? readPetSources(found.dir)[pose] : undefined
+    if (!src) return res.status(404).json({ error: 'pet_pose_unavailable' })
+    const plan = planPose(src)
+    const index = Number(req.params.chunk)
+    if (!Number.isInteger(index) || index < 0 || index >= plan.chunks) return res.status(404).json({ error: 'pet_chunk_unavailable' })
+    try {
+      const file = await petChunk(plan, index, { cacheDir: petCacheFor(found.cacheName), run: deps.petRun })
+      await sendImage(res, file, 'png', req.query.v === plan.key)
+    } catch (err) {
+      log(`[web-pet] could not build ${pose} chunk ${index}: ${err instanceof Error ? err.message : String(err)}`)
+      res.status(503).json({ error: 'pet_build_failed' })
+    }
+  })
+
+  // A still pet: COS Control's single sprite, Cloud Puff, or a gallery picture (downloaded once, as the Mac does).
+  router.get('/web-pet/still', async (req: Request, res: Response) => {
+    const choice = petChoiceOf(req)
+    const found = choice ? resolveFor(choice) : null
+    if (!found || found.kind === 'strips') return res.status(404).json({ error: 'pet_unavailable' })
+    try {
+      const art = found.kind === 'still' ? found : await galleryThumb(found, petCacheFor('gallery'), deps.petFetch, petDir())
+      await sendImage(res, art.file, art.type, typeof req.query.v === 'string' && req.query.v.length > 0)
+    } catch (err) {
+      log(`[web-pet] gallery picture failed for ${found.kind === 'gallery' ? found.id : 'still'}: ${err instanceof Error ? err.message : String(err)}`)
+      res.status(502).json({ error: 'pet_picture_unavailable' })
+    }
+  })
+
+  // The picker's small picture: an animated pet's first frame, or the still itself.
+  router.get('/web-pet/preview', async (req: Request, res: Response) => {
+    const choice = petChoiceOf(req)
+    const found = choice ? resolveFor(choice) : null
+    if (!found) return res.status(404).json({ error: 'pet_unavailable' })
+    try {
+      if (found.kind === 'strips') return await sendImage(res, await petPreview(found.dir, petCacheFor(found.cacheName || 'mac-preview'), { run: deps.petRun }), 'png', typeof req.query.v === 'string')
+      const art = found.kind === 'still' ? found : await galleryThumb(found, petCacheFor('gallery'), deps.petFetch, petDir())
+      await sendImage(res, art.file, art.type, typeof req.query.v === 'string')
+    } catch (err) {
+      log(`[web-pet] preview failed: ${err instanceof Error ? err.message : String(err)}`)
+      res.status(502).json({ error: 'pet_picture_unavailable' })
+    }
+  })
+
+  // What the picker lists: the Mac's pet, the characters COS Control ships, and its OpenPets gallery.
+  router.get('/web-pet/catalog', (_req: Request, res: Response) => {
+    res.set('Cache-Control', 'private, no-store')
+    const preview = (key: string, tag: string) => `/api/web-pet/preview?pet=${encodeURIComponent(key)}&v=${encodeURIComponent(crypto.createHash('sha256').update(tag).digest('hex').slice(0, 16))}`
+    const mac = resolveFor({ kind: 'mac' })
+    const macTag = mac ? (mac.kind === 'still' ? fileTag(mac.file) : fileTag(path.join(petDir(), 'session-pet-states.json'))) : ''
+    res.json({
+      mac: { available: !!mac, preview: mac ? preview('mac', 'mac:' + macTag) : null },
+      // The tag follows the art on disk, so a COS Control update with new art gets a new preview URL.
+      shipped: shippedPets(petResources()).map((p) => {
+        const r = resolveFor({ kind: 'shipped', id: p.id })
+        const tag = r?.kind === 'strips' ? fileTag(path.join(r.dir, 'session-pet-states.json')) : r?.kind === 'still' ? fileTag(r.file) : ''
+        return { ...p, pet: `shipped:${p.id}`, preview: preview(`shipped:${p.id}`, `shipped:${p.id}:${tag}`) }
+      }),
+      gallery: galleryPets(petDir()).map((p) => ({ id: p.id, name: p.name, description: p.description, category: p.category, pet: `gallery:${p.id}`, preview: preview(`gallery:${p.id}`, p.preview) })),
+    })
+  })
+
   // Today / Work "Your Move" compatibility route
   router.get('/work-board/your-move', async (_req: Request, res: Response) => {
     res.set('Cache-Control', 'private, no-store')

package/server/routes/welcome-context.ts

@@ -4,6 +4,8 @@
 
 import { Router } from 'express'
 import { callPython, pythonBridgeAvailable } from '../lib/python-bridge.js'
+import { parsePrepOccurrence } from '../lib/prep-store.js'
+import type { PrepOccurrence } from '../../shared/prep.js'
 
 export const welcomeContextRouter = Router()
 
@@ -14,7 +16,29 @@ const CALENDAR_TTL_MS = 2 * 60_000
 const COORD_MOVE_DEG = 0.05 // ~5km
 
 type WeatherPayload = { temp: string; desc: string; location: string }
-type NextEventPayload = { title: string; time: string; inMinutes?: number }
+/**
+ * 6.99.19: `occurrence` (shared/prep.ts PrepOccurrence) is present ONLY when the bridge answers the event with a
+ * provider, calendar id, event id or external id, and start. The bridge sends no event ids today, so it is absent.
+ * It lets a client find a Prep draft for this exact event; it never binds one, and nothing is inferred from the title.
+ */
+type NextEventPayload = { title: string; time: string; inMinutes?: number; occurrence?: PrepOccurrence }
+
+/** The bridge event's provider identity, or undefined. snake_case (calendar_context.py) or camelCase is accepted. */
+export function bridgeOccurrence(evt: Record<string, unknown> | null | undefined): PrepOccurrence | undefined {
+  if (!evt || typeof evt !== 'object') return undefined
+  const pick = (...keys: string[]) => keys.map(k => evt[k]).find(v => v !== undefined && v !== null)
+  try {
+    return parsePrepOccurrence({
+      provider: pick('provider'),
+      account: pick('account', 'account_id', 'accountId') ?? null,
+      calendarId: pick('calendar_id', 'calendarId'),
+      eventId: pick('event_id', 'eventId') ?? null,
+      externalId: pick('external_id', 'externalId') ?? null,
+      startsAt: pick('start_time', 'start', 'startsAt'),
+      endsAt: pick('end_time', 'end', 'endsAt') ?? null,
+    }) ?? undefined
+  } catch { return undefined }
+}
 
 let cachedWeather: WeatherPayload | null = null
 let weatherFetchedAt = 0
@@ -327,16 +351,20 @@ export async function fetchNextEvent(): Promise<{ event: NextEventPayload | null
       const minsUntil = Number.isFinite(eventTime)
         ? Math.max(0, Math.round((eventTime - now) / 60_000))
         : undefined
+      const occurrence = bridgeOccurrence(meaningful as Record<string, unknown>)
       cachedNextEvent = {
         title: meaningful.title || 'Meeting',
         time: meaningful.start_time || meaningful.start || '',
         ...(minsUntil != null ? { inMinutes: minsUntil } : {}),
+        ...(occurrence ? { occurrence } : {}),
       }
     } else if (cal?.next_event && !isGenericNoiseEvent(cal.next_event.title || '')) {
+      const occurrence = bridgeOccurrence(cal.next_event as Record<string, unknown>)
       cachedNextEvent = {
         title: cal.next_event.title || 'Meeting',
         time: cal.next_event.start_time || '',
         ...(cal.minutes_until_next != null ? { inMinutes: cal.minutes_until_next } : {}),
+        ...(occurrence ? { occurrence } : {}),
       }
     } else {
       cachedNextEvent = null

package/server/routes/work-lens-rounds.ts

@@ -1,11 +1,16 @@
 /**
  * 6.83.0: lens plans in Work chat history, and "Send this plan" (docs/work-orchestrator.md, "Lens plans").
  *
- * Lens (over the network, token auth from the parent /api mount):
- *   POST /api/work/chat/lens-rounds                       record a plan the lens made (idempotent on clientRoundId)
+ * Lens, and COS Control Web (over the network, token or browser sign-in from the parent /api mount):
+ *   POST /api/work/chat/lens-rounds                       record a plan the lens or the web made (idempotent on clientRoundId;
+ *                                                         source "lens" with a lens- id, or "web" with a web- id)
  *   GET  /api/work/chat/lens-rounds/:roundId              the round's live state, never its prompts
  *   POST /api/work/chat/lens-rounds/:roundId/send         ask COS Control to send it (two-step confirm, or card Auto-send)
  *   POST /api/work/chat/lens-rounds/:roundId/stop         ask COS Control to Stop assignments
+ * COS Control Web:
+ *   GET  /api/work/chat/web-plans                         { protocolVersion: 1, webPlans: 1, sources }: this server records web plans
+ *                                                         (a web round is refused 409 round_id_conflict when its id is reused
+ *                                                         for a different plan; GET /api/work/chat is unchanged)
  * COS Control (this Mac only):
  *   GET  /api/work/chat/lens-inbox?since=<cursor>[&autoSend=1]   rounds not yet in history, send and stop requests
  *   POST /api/work/chat/lens-rounds/:roundId/history      { state: "in_history", autoSendCard? }
@@ -17,8 +22,8 @@
  * (index.ts leaves these paths to this router so the error code is the contract's).
  */
 import { Router, type Request, type Response } from 'express'
-import { LensRoundError, LensRoundStore, LENS_ROUND_BODY_BYTES, ROUND_ID, SEND_ID, cardSessionsOf, parseLensRound, parseResultBody,
-  parseSendBody, parseStopBody, roundView, defaultLensRoundStore } from '../lib/work-lens-rounds.js'
+import { LensRoundError, LensRoundStore, LENS_ROUND_BODY_BYTES, ROUND_ID, ROUND_SOURCES, SEND_ID, cardSessionsOf, parseLensRound, parseResultBody,
+  parseSendBody, parseStopBody, roundView, sameRoundContent, defaultLensRoundStore } from '../lib/work-lens-rounds.js'
 import type { ControlSnapshot } from '../lib/work-orchestrator/snapshot.js'
 import { orchestratorSnapshots } from '../lib/work-orchestrator/runtime.js'
 import { acquireMaintenanceWork, maintenanceAdmissionsOpen } from '../lib/maintenance-lifecycle.js'
@@ -96,6 +101,9 @@ export function createWorkLensRoundsRouter(given: Partial<WorkLensRoundsDeps> =
     const input = parseLensRound(req.body)
     // A repeat is answered from the store, even when the board has since changed or is unreachable.
     const replay = deps.store.replay(input.clientRoundId)
+    if (replay && input.source === 'web' && !sameRoundContent(replay, input)) {
+      throw new LensRoundError('round_id_conflict', 409, 'This round id was used for a different plan. Plan again.')
+    }
     if (!replay) {
       let known: boolean
       try { known = await deps.knownWork(input.workID) }
@@ -103,10 +111,16 @@ export function createWorkLensRoundsRouter(given: Partial<WorkLensRoundsDeps> =
       if (!known) throw new LensRoundError('unknown_work', 404, 'This card is not on the Work board any more.')
     }
     const { round, created } = deps.store.record(input, cardSessionsOf(deps.snapshot(), input.workID))
-    if (created) console.log(`[work-lens-rounds] recorded ${round.roundId} work=${round.workID} assignments=${round.assignments.length}`)
+    if (created) console.log(`[work-lens-rounds] recorded ${round.roundId} work=${round.workID} assignments=${round.assignments.length}${round.source === 'web' ? ' source=web' : ''}`)
     return res.status(created ? 201 : 200).json({ roundId: round.roundId, workID: round.workID, state: roundView(round).state, control: { connected: connected() } })
   }))
 
+  // COS Control Web asks this before it shows Work chat. A server without it answers 404, and the web says it needs an update.
+  router.get('/work/chat/web-plans', (_req, res) => {
+    res.set('Cache-Control', 'private, no-store')
+    return res.json({ protocolVersion: 1, webPlans: 1, sources: [...ROUND_SOURCES] })
+  })
+
   router.get('/work/chat/lens-rounds/:roundId', (req, res) => {
     try {
       const round = deps.store.find(roundIdOf(req))

package/server/routes/work-orchestrator.ts

@@ -5,6 +5,9 @@
  *   POST /api/work/orchestrator/input  {workID, meetingWorkIDs?, snapshot?}
  *        Stores Control's snapshot when one is sent (Phase A: Control pushes, the server keeps the copy), then answers
  *        the card's planner rows, what was left out and why, and the usage snapshot.
+ *   POST /api/work/orchestrator/snapshot {workID, revision, serverInstanceId, snapshot}
+ *        Bound to this server and a current canonical card revision. Stores validated Control evidence only;
+ *        no discovery, usage refresh, model, link/receipt write or dispatch.
  *   GET  /api/work/orchestrator/usage[?refresh=1]
  *        The usage snapshot per provider, read on demand: Claude and Codex are re-read when their reading is older than
  *        10 minutes (`refresh=1`: 2 minutes). No timer reads usage unless COS_WORK_USAGE_POLL=1.
@@ -14,6 +17,11 @@ import { parseSnapshot, type ControlSnapshot } from '../lib/work-orchestrator/sn
 import type { OrchestratorInput } from '../lib/work-orchestrator/input.js'
 import type { UsageMonitor, UsageView } from '../lib/work-orchestrator/usage.js'
 import { orchestratorInputFor, orchestratorSnapshots, orchestratorUsage } from '../lib/work-orchestrator/runtime.js'
+import { listBoard, type TaskBoardRow } from '../lib/task-store.js'
+import { createWorkBoardReader } from '../lib/work-board-reader.js'
+import { getServerInstanceId } from '../lib/server-instance-id.js'
+import { maintenanceAdmissionsOpen, acquireMaintenanceWork } from '../lib/maintenance-lifecycle.js'
+import { AskWorkPlanError, resolveAskWorkTask } from '../lib/ask-work-plan.js'
 
 const WORK_ID = /^task:[a-z_]+:[a-f0-9]{12}$/
 const MEETING_ID = /^meeting:[^\u0000-\u001f]{1,250}$/
@@ -24,6 +32,10 @@ export interface WorkOrchestratorDeps {
   input: (workID: string, meetingWorkIDs: string[]) => Promise<OrchestratorInput>
   usage: (refresh: boolean) => Promise<UsageView[]>
   now: () => number
+  board: () => Promise<TaskBoardRow[]>
+  serverInstanceId: () => string | null
+  admissions: () => boolean
+  lease: () => { release(): void }
 }
 
 /** GET /usage reads on demand: a reading older than 10 minutes is re-read (`refresh=1`: 2 minutes). */
@@ -34,12 +46,57 @@ const DEFAULTS: WorkOrchestratorDeps = {
   input: orchestratorInputFor,
   usage: refresh => readUsage(refresh),
   now: () => Date.now(),
+  board: () => createWorkBoardReader(() => listBoard()).read(0),
+  serverInstanceId: getServerInstanceId,
+  admissions: maintenanceAdmissionsOpen,
+  lease: () => acquireMaintenanceWork('api_mutation'),
 }
 
 export function createWorkOrchestratorRouter(given: Partial<WorkOrchestratorDeps> = {}) {
   const deps = { ...DEFAULTS, ...given }
   const router = Router()
   router.use('/work/orchestrator', (_req, res, next) => { res.set('Cache-Control', 'private, no-store'); next() })
+  router.post('/work/orchestrator/snapshot', async (req, res) => {
+    const body = req.body
+    if (!body || typeof body !== 'object' || Array.isArray(body)
+      || Object.keys(body).some(k => !['workID', 'revision', 'serverInstanceId', 'snapshot'].includes(k))
+      || typeof body.workID !== 'string' || body.workID.length > 256 || !WORK_ID.test(body.workID)
+      || typeof body.revision !== 'string' || !/^[a-f0-9]{64}$/.test(body.revision)
+      || typeof body.serverInstanceId !== 'string'
+      || !/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i.test(body.serverInstanceId)) {
+      return res.status(400).json({ error: 'invalid_snapshot_binding' })
+    }
+    if (Buffer.byteLength(JSON.stringify(body)) > ORCHESTRATOR_BODY_BYTES) return res.status(413).json({ error: 'snapshot_too_large' })
+    let snapshot: ControlSnapshot
+    try { snapshot = parseSnapshot(body.snapshot, deps.now()) }
+    catch { return res.status(400).json({ error: 'invalid_snapshot' }) }
+    const binding = () => {
+      const id = deps.serverInstanceId()
+      if (!id) throw new AskWorkPlanError('server_instance_unavailable', 503)
+      if (id !== body.serverInstanceId) throw new AskWorkPlanError('server_instance_changed', 409)
+      if (!deps.admissions()) throw new AskWorkPlanError('maintenance', 503)
+      return id
+    }
+    let lease: ReturnType<WorkOrchestratorDeps['lease']> | undefined
+    try {
+      binding()
+      lease = deps.lease()
+      let rows: TaskBoardRow[]
+      try { rows = await deps.board() }
+      catch { throw new AskWorkPlanError('work_board_unavailable', 503) }
+      resolveAskWorkTask(body, rows)
+      const serverInstanceId = binding()
+      if (res.destroyed) return
+      // This is the same paired-client evidence cache as /input, not execution authority. parseSnapshot
+      // retains only its known fields; arbitrary automatic/forkable/capability fields never enter the cache.
+      deps.putSnapshot(snapshot)
+      return res.json({ protocolVersion: 1, accepted: true, workID: body.workID, revision: body.revision, serverInstanceId })
+    } catch (error) {
+      if (res.destroyed) return
+      const known = error instanceof AskWorkPlanError
+      return res.status(known ? error.status : 503).json({ error: known ? error.code : 'snapshot_unavailable' })
+    } finally { lease?.release() }
+  })
   router.post('/work/orchestrator/input', async (req, res) => {
     const body = req.body
     const meetings: unknown = body?.meetingWorkIDs ?? []