@gotcos/glasses-server 6.99.20 → 6.99.29

package/server/routes/today-brief.ts

@@ -0,0 +1,148 @@
+/**
+ * 6.99.26 candidate: the Today summary for COS Control Web (lib/today-brief.ts says how it stops: switch, caps, breaker).
+ *
+ * - GET  /api/today/brief           the cached summary; never generates.
+ * - POST /api/today/brief           an open Today's ask, with the rows it read (titles, states, how long, last lines,
+ *                                   what needs you). Generates only when the switch is on, the inputs changed, 10 minutes
+ *                                   passed and the day's 60 are not spent. The Work cards in progress come from the
+ *                                   server's own shared board read, never the body.
+ * - GET  /api/today/brief/settings  the switch and what set it.
+ * - POST /api/today/brief/settings  { enabled: boolean }, the Settings toggle. COS_TODAY_BRIEF_LLM, when set, still wins.
+ * Auth is the parent /api gate (token or web session cookie). Every answer is private, no-store.
+ */
+import { Router } from 'express'
+import type { Response } from 'express'
+import { dataPath } from '../lib/data-dir.js'
+import { runClaudeText } from '../lib/claude-text-runner.js'
+import { logTokenAudit } from '../lib/token-audit.js'
+import type { TaskBoardRow } from '../lib/task-store.js'
+import { agentSessionRoots, findAgentSessionFile } from '../lib/agent-session-store.js'
+import { readClaudeSubagents, summarize, type SessionSubagents } from '../lib/session-subagents.js'
+import { readCodexSubagentDetails } from '../lib/codex-subagent-activity.js'
+import { acquireMaintenanceWork, maintenanceAdmissionsOpen } from '../lib/maintenance-lifecycle.js'
+import { isRecordingLive } from '../lib/stt-runtime.js'
+import {
+  TODAY_BRIEF_BODY_MAX_BYTES, TODAY_BRIEF_EFFORT, TODAY_BRIEF_SETTINGS_FILE, TODAY_BRIEF_STATE_FILE, TODAY_BRIEF_TIMEOUT_MS,
+  TodayBriefInputError, createTodayBrief, normalizeTodayBriefInputs, subagentLookups, todayBriefFingerprint, withSubagents, type BriefWork, type SubagentReading, type TodayBrief,
+} from '../lib/today-brief.js'
+
+export interface TodayBriefRouterDeps {
+  brief: TodayBrief
+  /** The Work board as the server already reads it (a shared, bounded read), or null when it cannot be read. */
+  board: () => Promise<TaskBoardRow[] | null>
+  /** Sub-agents for up to 8 sessions, by "provider|id". Missing keys mean "not read"; the page's counts stay. */
+  subagents?: (keys: string[]) => Promise<Map<string, SubagentReading>>
+  now?: () => number
+}
+
+/** How long the sub-agent reads may hold the ask before it goes on without them. */
+export const TODAY_BRIEF_SUBAGENT_WAIT_MS = 2_500
+
+/**
+ * The server's own sub-agent reads: Claude from the session's transcript tail (lib/session-subagents.ts), Codex from
+ * the spawn-edge snapshot (readCodexSubagentDetails, server home only). Cursor has none. Sequential, bounded, read-only.
+ */
+export async function readSubagentsFor(keys: string[], now = Date.now()): Promise<Map<string, SubagentReading>> {
+  const out = new Map<string, SubagentReading>()
+  const roots = agentSessionRoots()
+  const codex = keys.filter(k => k.startsWith('codex|')).map(k => k.slice(6))
+  for (const key of keys.filter(k => k.startsWith('claude|'))) {
+    const file = await findAgentSessionFile('claude', key.slice(7), roots).catch(() => null)
+    const read: SessionSubagents | null = file ? await readClaudeSubagents(file) : null
+    if (read && read.total) out.set(key, read)
+  }
+  if (codex.length) {
+    const details = await readCodexSubagentDetails(codex, roots.codexSessions, now)
+    for (const [id, list] of details) {
+      const rows = list.map(d => ({ name: d.name, task: d.task, status: d.state === 'active' ? 'running' as const : d.state === 'completed' ? 'done' as const : 'unknown' as const, at: d.at }))
+      if (rows.length) out.set('codex|' + id, summarize(rows, false))
+    }
+  }
+  return out
+}
+
+/** The server's own brief: the data folder, Haiku through the isolated text runner, one audit row per start. */
+export function defaultTodayBrief(): TodayBrief {
+  return createTodayBrief({
+    stateFile: dataPath(TODAY_BRIEF_STATE_FILE),
+    settingsFile: dataPath(TODAY_BRIEF_SETTINGS_FILE),
+    generate: (prompt, systemPrompt, model) => runClaudeText(prompt, {
+      model, effort: TODAY_BRIEF_EFFORT, timeoutMs: TODAY_BRIEF_TIMEOUT_MS, systemPrompt, label: 'Today brief',
+    }),
+    audit: row => logTokenAudit({
+      source: 'web-today-brief', model: row.model, inputChars: row.inputChars, outputChars: row.outputChars,
+      durationMs: row.durationMs, caller: row.outcome === 'ok' ? 'today_brief' : `today_brief_${row.guard ?? row.error ?? row.outcome}`,
+    }),
+    // No call while a meeting records (it keeps the Mac's CPU and the CLI for the meeting) or while the server drains.
+    blocked: () => (!maintenanceAdmissionsOpen() ? 'maintenance' : isRecordingLive() ? 'recording' : null),
+    // The call holds api_mutation, as the generic mutation lease would have; this route is lifecycle-owned in index.ts.
+    lease: () => acquireMaintenanceWork('api_mutation'),
+  })
+}
+
+const IN_PROGRESS = new Set(['draft', 'built', 'qa'])
+/** Work cards in progress, by title and stage: open, not delegated, drafting to QA, or with an agent on it. */
+export function workInProgress(rows: TaskBoardRow[] | null): BriefWork[] {
+  if (!rows) return []
+  const out: BriefWork[] = []
+  for (const row of rows) {
+    if (row.checked || row.delegated) continue
+    const stage = row.workStage ?? (row.stage === 'active' ? 'draft' : row.stage === 'review' ? 'qa' : 'planned')
+    const running = row.agentState === 'running'
+    if (!IN_PROGRESS.has(stage) && !running) continue
+    out.push({ title: row.title || row.text || '', stage, running })
+  }
+  return out.sort((a, b) => Number(b.running) - Number(a.running)).slice(0, 12)
+}
+
+export function createTodayBriefRouter(deps: TodayBriefRouterDeps): Router {
+  const router = Router()
+  router.use('/today/brief', (_req, res, next) => { res.set('Cache-Control', 'private, no-store'); next() })
+  const failed = (res: Response) => res.status(503).json({ error: { code: 'today_brief_unavailable', message: 'The Today summary is unavailable right now.' } })
+
+  router.get('/today/brief', (_req, res) => {
+    try { res.json(deps.brief.peek()) } catch { failed(res) }
+  })
+  router.post('/today/brief', async (req, res) => {
+    try {
+      if (Buffer.byteLength(JSON.stringify(req.body ?? null)) > TODAY_BRIEF_BODY_MAX_BYTES) {
+        return res.status(413).json({ error: { code: 'today_brief_too_large', message: 'Too much for the Today summary.' } })
+      }
+      // The switch first: off reads nothing, not even the board.
+      if (!deps.brief.settings().enabled) {
+        normalizeTodayBriefInputs(req.body)
+        return res.json(deps.brief.peek())
+      }
+      // Every gate that needs no reads goes first (switch, recording, drain, breaker, daily cap, interval): a gated ask
+      // answers from the page's rows alone and reads neither the board nor any transcript.
+      const pageInputs = normalizeTodayBriefInputs(req.body)
+      const closed = deps.brief.gate()
+      if (closed) return res.json(deps.brief.askGated(pageInputs, closed))
+      const work = workInProgress(await deps.board().catch(() => null))
+      let inputs = normalizeTodayBriefInputs(req.body, work)
+      const keys = subagentLookups(inputs)
+      if (keys.length && deps.subagents) {
+        let timer: ReturnType<typeof setTimeout> | undefined
+        const late = new Promise<Map<string, SubagentReading>>(resolve => { timer = setTimeout(() => resolve(new Map()), TODAY_BRIEF_SUBAGENT_WAIT_MS) })
+        const readings = await Promise.race([deps.subagents(keys).catch(() => new Map<string, SubagentReading>()), late]).finally(() => clearTimeout(timer))
+        inputs = withSubagents(inputs, readings, (deps.now ?? Date.now)())
+      }
+      res.json(await deps.brief.ask(inputs, todayBriefFingerprint(pageInputs)))
+    } catch (error) {
+      if (error instanceof TodayBriefInputError) return res.status(400).json({ error: { code: error.code, message: 'That is not a Today summary request.' } })
+      console.warn(`[today-brief] ask failed (${error instanceof Error ? error.name : 'error'})`)
+      failed(res)
+    }
+  })
+  router.get('/today/brief/settings', (_req, res) => {
+    try { res.json(deps.brief.settings()) } catch { failed(res) }
+  })
+  router.post('/today/brief/settings', (req, res) => {
+    const body = req.body
+    if (!body || typeof body !== 'object' || Array.isArray(body) || Object.keys(body).some(k => k !== 'enabled') || typeof body.enabled !== 'boolean') {
+      return res.status(400).json({ error: { code: 'invalid_today_brief_settings', message: 'Send { enabled: true } or { enabled: false }.' } })
+    }
+    try { res.json(deps.brief.setEnabled(body.enabled)) } catch { failed(res) }
+  })
+  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/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/web-control/app.css

@@ -200,6 +200,30 @@ select.field {
 
 /* ── Today ───────────────────────────────────────────────── */
 .today-date { color: var(--sub); font-size: 15px; margin: 6px 0 0; }
+/* The session pet on Today: the pet COS Control shows, in the pose the Mac would pick. */
+.today-pet { display: flex; flex-direction: column; align-items: center; margin: 6px 0 14px; min-height: 166px; }
+.today-pet.hidden { display: none; }
+.pet-btn { background: none; border: 0; padding: 0; cursor: pointer; display: flex; flex-direction: column; align-items: center; gap: 4px; color: inherit; font: inherit; }
+.pet-btn:focus-visible { outline: 2px solid var(--sub); outline-offset: 4px; border-radius: 8px; }
+.pet-sprite { height: 140px; background-repeat: no-repeat; }
+.pet-caption { color: var(--sub); font-size: 14px; }
+/* A still pet (gallery pick, Cloud Puff, single image). Small pixel art scales without blur. */
+.pet-still { height: 140px; width: auto; max-width: 220px; object-fit: contain; }
+.pet-still.pixel { image-rendering: pixelated; }
+.pet-change { background: none; border: 0; padding: 6px 10px; margin-top: 2px; color: var(--sub); font: inherit; font-size: 13px; cursor: pointer; text-decoration: underline; text-underline-offset: 3px; }
+.pet-change:focus-visible { outline: 2px solid var(--sub); outline-offset: 2px; border-radius: 6px; }
+/* Settings > Pet */
+.pet-choice .pet-thumb { width: 44px; height: 44px; flex: 0 0 44px; object-fit: contain; image-rendering: pixelated; border-radius: 8px; }
+.pet-search { width: 100%; box-sizing: border-box; margin: 4px 0 10px; padding: 10px 12px; border-radius: 10px; border: 1px solid var(--panel-border); background: var(--panel); color: inherit; font: inherit; }
+.pet-grid { display: grid; grid-template-columns: repeat(auto-fill, minmax(88px, 1fr)); gap: 8px; }
+.pet-tile { display: flex; flex-direction: column; align-items: center; gap: 6px; padding: 10px 6px; border-radius: 12px; border: 1px solid var(--panel-border); background: var(--panel); color: inherit; font: inherit; font-size: 12px; cursor: pointer; min-width: 0; }
+.pet-tile img { width: 56px; height: 56px; object-fit: contain; image-rendering: pixelated; }
+.pet-tile span { max-width: 100%; overflow: hidden; text-overflow: ellipsis; white-space: nowrap; }
+.pet-tile[aria-pressed="true"] { border-color: var(--accent); box-shadow: 0 0 0 1px var(--accent) inset; }
+.pet-tile.hidden { display: none; }
+.pet-tile:focus-visible { outline: 2px solid var(--accent); outline-offset: 2px; }
+/* Unfolded: top of the right-hand column, above Needs you (app.js placePet). */
+.today-side > .today-pet { margin: 0 0 14px; }
 .ask-bar {
   display: flex; align-items: center; gap: 10px; width: 100%;
   min-height: 52px; padding: 0 14px; margin-top: 16px;
@@ -222,6 +246,8 @@ select.field {
 @keyframes rec { 50% { opacity: 0.35; } }
 
 .story { font: 400 24px/1.28 var(--display); letter-spacing: -0.005em; margin: 26px 2px; text-wrap: pretty; }
+/* The Today summary's quiet age line (app.js briefWhen). */
+.story-when { display: block; margin-top: 10px; font: 400 14px/1.35 var(--body); letter-spacing: 0; color: var(--sub); }
 .story-skel { display: grid; gap: 12px; margin: 30px 0; }
 .story-skel .skeleton { height: 22px; }
 
@@ -365,9 +391,6 @@ select.field {
 .speaker-row audio { width: 100%; height: 40px; margin-top: 8px; grid-column: 1 / -1; }
 .speaker-row .capture-row { grid-column: 1 / -1; margin-top: 8px; }
 
-/* Memories: the native Memories page, hosted as-is. */
-.pane.flush { max-width: none; margin: -4px calc(-1 * (var(--gutter) + var(--safe-right))) 0 calc(-1 * (var(--gutter) + var(--safe-left))); }
-.memories-frame { display: block; width: 100%; height: calc(100dvh - var(--topbar-h) - var(--safe-top)); border: 0; background: var(--page); }
 
 /* Ask sheet (⌘K on desktop) */
 .sheet-backdrop { position: fixed; inset: 0; z-index: 50; background: rgba(23, 18, 14, 0.45); display: flex; align-items: flex-start; justify-content: center; animation: fade 160ms ease; }
@@ -445,8 +468,6 @@ select.field {
   .run-title, .run-meta { grid-column: 2; }
   .composer { position: sticky; bottom: calc(var(--safe-bottom) + 12px); }
   .toast { top: auto; bottom: 24px; }
-  .pane.flush { margin: calc(-1 * (var(--safe-top) + 22px)) calc(-1 * (var(--gutter) + var(--safe-right))) calc(-1 * (var(--safe-bottom) + 40px)) calc(-1 * var(--gutter)); }
-  .memories-frame { height: 100dvh; }
   .sheet-backdrop { padding-top: 8vh; }
   .sheet { max-width: 620px; border-radius: 18px; padding: 16px 18px 18px; max-height: 80dvh; box-shadow: 0 24px 60px rgba(0, 0, 0, 0.25); }
 }