@gotcos/glasses-server 6.58.0 → 6.58.2

package/CHANGELOG.md

@@ -1,3 +1,28 @@
+## 6.58.2
+
+### A New session from Work is named after its task, and visible while it runs
+
+- Miles, 2026-09-29 at 20:40, on the first COS Control 0.5.249 New session (job c3878966, 20:36:49 to 20:39:11): Control opened it in Claude 31 s after the run ended, and it sat at the top of the MU-Chief-Staff sidebar as "General coding session". "This is super generic. It should be based off of the same name of the task that we're sending in." And while it ran: "I don't see anything in the sidebar ... We should probably show the session behind this." The card said "session live status unavailable" and Sessions listed the run as a COS server job.
+- **A new Claude session is named.** A query job may carry `sessionName`. The server cleans it: control characters, zero-width spaces and direction marks and overrides become spaces (the joiners U+200C and U+200D stay), whitespace collapses, and a name over 100 characters is cut at 100, back to its last space when that space is in the second half; the cut counts whole characters, so it never splits an emoji. When the job starts a Claude session of its own, the server runs `claude --name=<name>`, which writes the session's title; the Claude app shows it in the sidebar. Never on a Continue into a session the COS session already has, never on a read-only dispatch, and a named session never takes the session the server warmed at boot (that one opens with "ready" under the glasses prompt); it starts clean. The server asks `claude --help` once whether the installed CLI takes `--name`; one that does not runs the session unnamed, as before. The name is outside the request fingerprint, so a retry that renames the same job is the same job, and an older server drops the field.
+- **The job names its Claude session while it runs.** Claude announces its session id in its first stream event (a hook or init line, before any answer text); before this the server recorded it only with the final result, so a New session from Work could not be linked, shown or opened while it ran. The server now records it on the run and on the job (`cliSessionId`, through the same link update as the provider process) from that first event, only while the job is running; a job that already ended keeps what it had. At completion the result's id is recorded as before. Claude only: Codex, Cursor and Ollama jobs are unchanged.
+- **Session titles in long transcripts.** The session list reads a Claude session's custom title from the end of its transcript; a transcript longer than the 256 KB window whose only title sits near the top now falls back to the top.
+- Proven on this Mac first (claude 2.1.285): `claude -p --name` writes `{"type":"custom-title",...}` into the transcript (and again as the session goes on), the same line the Claude app shows as a session's name; `--resume <id> --name` renames; a name that starts with a dash, in the `--name=` form, is taken as the name; and every stream event, from the first hook line, carries the session id.
+- Tests: the name's cleaning, joiners kept, the cut (at the last space, exactly at the limit, a run of emoji and of joined family emoji cut in whole characters), the request carrying it outside the fingerprint; `--name=` only for a session the COS session starts (not a Continue, not a dispatch, not the warmed session, not on a CLI without the option, a dash-leading name kept as one argument); the help probe (asked once, a CLI or help failure is a no); the first event with an id linking once (not an event without one, not a dispatch); the job showing the session while still running and keeping it at completion; a link after the job ended changing nothing; the runtime passing the name down and the early id up; a title at either end of a long transcript.
+
+## 6.58.1
+
+### A copy that lost its audio no longer holds the ring
+
+- 2026-09-29, 07:36 to 07:51, glasses 6.9.558 on 6.57.1, the HC standup while driving: a hidden copy of COS (`mumnr7cf`) lost its audio at 07:38:19 (`meeting.audio.silent`, the bridge probe alive, the glasses connected) and went on claiming `recording: true`. Its timers were throttled: 24 log rows in 14 minutes, gaps of 30 s to 208 s. A new copy started the meeting at 07:38:48 and another at 07:45:10; each was told to yield within a second, which stopped its recording. Only the copy opened at 07:50:46 took the ring. About 12.5 minutes (07:38:19 to 07:51:02) never reached the Mac.
+- The cause: an owner's own `recording` word held the ring for as long as it kept claiming (QA round 3's allowance for uploads that lag after an outage), and nothing checked the word against its chunks.
+- **A copy that says it is not recording is believed over its own chunks.** Before, any chunk of its own in the last 30 s held the ring, including chunks committed before its audio stopped and still uploading or replayed. This applies to a claimant taking the ring, and to an owner holding it while that owner keeps claiming (45 s): a copy's start announcement is one claim with a 1.5 s deadline while its chunks get 30 s, so an older `false` can outlive a start the Mac never heard, and then the chunks speak for it. Glasses 6.9.560 says so within seconds of losing its audio. Only a claim that carries the `recording` field counts (glasses 6.9.510+); older copies keep the 6.50.4 rule.
+- **A copy's word alone holds for 150 s (`CLIENT_INSTANCE_WORD_HOLD_MS`) after its newest proof:** its own newest chunk, the start of its recording claims, or a grace after a gap. The worst gap between two chunks from a copy that is recording is one failed upload (the 30 s timeout) plus the longest backoff (60 s); the hold allows one more backoff on top, and is derived from those two constants. After a gap of more than two ticks (`CLIENT_INSTANCE_GRACE_GAP_MS`, an outage or a sleep) a copy still recording gets one fresh hold for its uploads to catch up, and another only after a chunk of its own has arrived since: the 9/29 zombie's gappy claims would otherwise have renewed it forever. The same test applies to a copy taking the ring and to one holding it.
+- **What each copy has said is kept per copy**, across changes of owner. Without that, a copy that lost the ring and took it back started a fresh clock, and a silent copy and an idle newer one traded the ring every few minutes for a whole meeting. Now the ring moves once. Glasses 6.9.560 then stands aside quietly, keeping its meeting until its audio returns or another copy records.
+- **Known limit for builds before 6.9.560:** once the ring has moved, the silent copy keeps its meeting and, told to yield by an owner that is not recording, keeps answering the ring (6.9.510's rule) alongside the new owner until that owner starts recording, when it is told to yield and saves. The Mac could end that sooner only by telling it the new owner records when it does not.
+- For the builds already out (the Even Hub 6.9.538 included), the hold is bounded, not removed: a copy opened while the silent copy's last chunks are under 30 s old, or its word under 150 s (plus one grace), is still told to yield. From then on the next copy to start the meeting keeps it.
+- Unchanged: a newer copy still waits while the owner's own chunks arrive, a duplicate recording still ends on the claimant, untagged chunks still hold only for an owner that claims, and the 6.52.3 reclaim rules.
+- Tests: the 9/29 timeline over HTTP (the new copy keeps the ring, and the zombie is then told to yield with `captureLive: true`); an older build that never stops saying `recording`, held for exactly the hold after its last chunk; a silent 6.9.538 copy and an idle newer one for 20 minutes (the ring moves once); a real recorder uploading on the worst cadence keeps the ring; a claimant that says `false` never takes on its chunks; a copy with nothing to show cannot take the ring back by saying `recording`; the hold's derivation; the one grace per chunk. Two HTTP fixtures that claimed to be 6.9.509 now omit `recording` as 6.9.509 did. Two review rounds (round 1 FIX FIRST: a claimant's own chunks and a fresh clock on every take-back let the ring alternate, and the 90 s hold had no margin over the uploader; round 2 FIX FIRST: believing an owner's old `false` forever let a second copy record alongside one whose start the Mac missed; all fixed, with a test for each).
+
 ## 6.58.0
 
 ### Work: did the session finish the task?

package/docs/work-intake.md

@@ -34,3 +34,5 @@ The journal is `work-intake/intake.json` in the server data directory, owned by
 Since 6.57.1 `POST /api/work-board/session-recommendation` also takes exactly `{ reviewId, sessions }` for a meeting review (`reviewId` = `wr_` + 32 hex). The server reads the review's meeting title and reviewed follow-up from its own store; the client never sends work text. Errors: 400 `invalid_review_request` (bad id or session list), 404 `review_not_found`, 404 `reviews_unavailable` (reviews off), 503 `review_store_unavailable` (defensive; the stock lookup reads memory).
 
 Since 6.58.0 `POST /api/work-board/completion-check` takes exactly `{ domain, id, provider, sessionId }` plus an optional `after` (ISO time). It asks Jev whether the session's replies since `after` (or its newest reply) show the task finished, judged against its Done when or, without one, its own text. The server reads the task from the board and the replies from its own transcripts; the client sends names and a time only. It answers `{ provider: "jev", verdict: "done" | "not_done" | "unclear", confidence, basis: "done_when" | "task", model, cached }` or `{ provider: "none", reason }` (`no_reply`, `no_task_text`, a Jev condition, `completion_unavailable`). Errors: 400 `invalid_completion_request`, 404 `task_not_found`, 404 `session_not_found`. COS Control 0.5.247 asks only while the session is idle and its newest reply since the handoff has no `COS-WORK` status line, at most twice per handoff, and moves a card to QA only on done at 0.8 (0.85 without a Done when).
+
+Since 6.58.2 `POST /api/query-jobs` also takes an optional `sessionName` (a string; the server cleans it as the 6.58.2 changelog says and keeps at most 100 characters; anything else is no name, never an error). It names only a Claude session the job starts itself (`claude --name=<name>`, when the installed CLI lists `--name`); a Continue, a dispatch, a Codex, Cursor or Ollama job, and an older server ignore it, and it is not part of the request fingerprint. A Claude job's snapshot carries `cliSessionId` from Claude's first stream event while the job is still `running`, not only at completion. COS Control 0.5.250 sends the Work item's title for New session, Start work and Fork to Claude, and links its receipt as soon as the running job names the session.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gotcos/glasses-server",
-  "version": "6.58.0",
+  "version": "6.58.2",
   "description": "COS Glasses \u2014 self-hosted AI heads-up-display server for Even G2 smart glasses, powered by Claude Code, Codex, Cursor Agent CLI, or local Ollama",
   "type": "module",
   "bin": {

package/server/lib/agent-session-store.ts

@@ -580,7 +580,17 @@ export function parseJsonLine(line: string): Record<string, unknown> | null {
 }
 
 export async function lastCustomTitle(path: string): Promise<string | null> {
-  const text = await readWindow(path, true)
+  // The CLI re-writes its custom-title line as a session goes on, so the tail normally holds the
+  // newest. 6.58.2: a transcript longer than the window whose only title sits near the top (a
+  // `claude -p --name` run that wrote a long answer) falls back to the head.
+  const tail = customTitleIn(await readWindow(path, true))
+  if (tail) return tail
+  const st = await fileStat(path)
+  if (!st?.isFile || st.size <= HEAD_BYTES) return null
+  return customTitleIn(await readWindow(path, false))
+}
+
+function customTitleIn(text: string): string | null {
   let found: string | null = null
   for (const line of text.split('\n')) {
     if (!line.includes('custom-title')) continue

package/server/lib/claude-bridge.ts

@@ -60,6 +60,7 @@ import { terminalProviderAuthFailure } from './provider-terminal-error.js'
 import { claudePermissionArgs, getClaudeTrustMode } from './claude-permissions.js'
 import { terminateProviderProcess } from './provider-process-lifecycle.js'
 import { teeJobTrail, type JobTrailDraft } from './job-trail.js'
+import { claudeSupportsSessionName } from './claude-cli-support.js'
 
 // Inactivity = no stdout data for this long → kill (catches stalls)
 const INACTIVITY_BY_MODEL: Record<ClaudeModelPreference, number> = {
@@ -340,6 +341,12 @@ export interface StreamCallbacks {
   /** 6.52.0: readable steps of a durable Messages job (lib/job-trail.ts). Optional, and
    * absent on every path that is not a durable job with the trail on. */
   onTrail?: (draft: JobTrailDraft) => void
+  /**
+   * 6.58.2: the provider named its own session, at the start of the run. Claude announces
+   * its session id in the first stream event; before this the id reached the job only with
+   * the result, so COS Control could not show a New session from Work while it ran.
+   */
+  onNativeSession?: (linkage: { cliSessionId: string }) => void
 }
 
 /** Claude CLI can emit `subtype: success` with `is_error: true`; the boolean
@@ -395,6 +402,8 @@ export interface CallOptions {
   sessionLockHeld?: boolean
   /** Read-only scheduled-task dispatch. Same shape as QueryJobRequest.dispatch. */
   dispatch?: { restricted: true; tools: readonly string[] }
+  /** 6.58.2: `claude --name` for a session this COS session starts fresh (QueryJobRequest.sessionName). */
+  sessionName?: string
 }
 
 export async function callClaudeStreaming(
@@ -426,6 +435,9 @@ export async function callClaudeStreaming(
   // Pass existing CLI session ID if resuming (new sessions get it after first result)
   const resolvedCliKey = cliSessionKey(sid, resolvedModel)
   let existingCliSession = options?.dispatch ? undefined : cliSessionMap.get(resolvedCliKey)
+  // 6.58.2: decided before the pre-warmed session below stands in: a COS session that has no
+  // Claude session of its own yet starts one here, and only that one may be named.
+  const startsOwnCliSession = !existingCliSession
   callbacks.onStart?.(resolvedModel, sid, existingCliSession, {
     clientJobId: options?.clientJobId,
     generation: options?.generation,
@@ -531,7 +543,10 @@ export async function callClaudeStreaming(
   // Check if we have a prior CLI session for this COS session.
   // If not, use the pre-warmed session (eliminates 2-15s cold start on first query).
   // Restricted dispatch never steals the pre-warmed unrestricted session.
-  if (!options?.dispatch && !existingCliSession && preWarmedCliSessionId && resolvedModel === DEFAULT_MODEL) {
+  // 6.58.2: nor does a named New session (COS Control Work). The warmed session opens with the
+  // boot prompt "ready" under the glasses prompt; a session someone will open in the Claude app
+  // under its task's name starts clean.
+  if (!options?.dispatch && !options?.sessionName && !existingCliSession && preWarmedCliSessionId && resolvedModel === DEFAULT_MODEL) {
     // Only the default model consumes the pre-warmed session.
     // Hey Even (Haiku) cold-starts its own session to avoid model contamination.
     existingCliSession = preWarmedCliSessionId
@@ -576,6 +591,11 @@ export async function callClaudeStreaming(
     // Resume prior CLI session — reuses cached context, avoids cold start
     args.push('--resume', existingCliSession)
   }
+  // 6.58.2: name the session this COS session starts (never a Continue, never a dispatch), when
+  // the installed CLI takes --name. The `=` form keeps a name that starts with a dash a value.
+  if (startsOwnCliSession && !options?.dispatch && options?.sessionName && await claudeSupportsSessionName()) {
+    args.push(`--name=${options.sessionName}`)
+  }
 
   // Strip CLAUDECODE env var so claude -p doesn't think it's nested
   const env = { ...process.env }
@@ -856,6 +876,8 @@ export async function callClaudeStreaming(
 
   // ─── Process stdout ───
 
+  // 6.58.2: onNativeSession fires once per run.
+  let nativeSessionAnnounced = false
   proc.stdout.on('data', (chunk: Buffer) => {
     resetInactivity()
     buffer += chunk.toString()
@@ -871,6 +893,15 @@ export async function callClaudeStreaming(
       try {
         const event = JSON.parse(trimmed)
 
+        // 6.58.2: the first event that carries the session id (a hook or init line, before any
+        // answer text) links the run and the job to it. At completion the result's id is
+        // recorded as before, so the finished job names the session the result names.
+        if (!nativeSessionAnnounced && !options?.dispatch && typeof event.session_id === 'string' && event.session_id) {
+          nativeSessionAnnounced = true
+          updateClaudeRun(run.runId, { cliSessionId: event.session_id })
+          callbacks.onNativeSession?.({ cliSessionId: event.session_id })
+        }
+
         if (event.type === 'system' && event.subtype === 'init' && typeof event.model === 'string') {
           updateClaudeRun(run.runId, { resolvedModelId: event.model })
         } else if (event.type === 'stream_event') {

package/server/lib/claude-cli-support.ts

@@ -0,0 +1,37 @@
+import { execFile } from 'node:child_process'
+
+/**
+ * 6.58.2: does the installed Claude CLI take `--name`? A CLI that predates the option rejects
+ * it as unknown and the whole run fails, so the server asks `claude --help` once, in the
+ * background (it answers in about 50 ms on this Mac), and names a session only when the help
+ * lists the option. Any failure to ask is a no: the session then runs unnamed, as before 6.58.2.
+ */
+let sessionNameSupport: Promise<boolean> | null = null
+
+const HELP_TIMEOUT_MS = 5_000
+
+export function claudeSupportsSessionName(): Promise<boolean> {
+  if (!sessionNameSupport) {
+    sessionNameSupport = new Promise<boolean>(resolve => {
+      try {
+        execFile('claude', ['--help'], { timeout: HELP_TIMEOUT_MS, maxBuffer: 1024 * 1024 }, (error, stdout, stderr) => {
+          const supported = !error && helpListsNameOption(`${stdout}\n${stderr}`)
+          if (!supported) console.warn('[claude-bridge] this Claude CLI does not list --name; new sessions stay unnamed')
+          resolve(supported)
+        })
+      } catch {
+        resolve(false)
+      }
+    })
+  }
+  return sessionNameSupport
+}
+
+/** The help line reads `-n, --name <name>` on Claude Code 2.1.285. */
+export function helpListsNameOption(help: string): boolean {
+  return /(^|[\s,])--name[\s=<[]/m.test(help)
+}
+
+export function resetClaudeCliSupportForTests(): void {
+  sessionNameSupport = null
+}

package/server/lib/client-instance-claim.ts

@@ -35,6 +35,28 @@ export const CLIENT_INSTANCE_AWAKE_MS = CLIENT_INSTANCE_LIVE_MS
  * intervals (~6 s each), so a stretch of silence or a slow upload does not end the hold.
  */
 export const CLIENT_INSTANCE_CAPTURE_LIVE_MS = 30_000
+/** The glasses uploader's longest wait between chunk attempts (cos-glasses-app local-first-meeting-uploader.ts, maxBackoffMs). */
+export const GLASSES_UPLOAD_MAX_BACKOFF_MS = 60_000
+/** The glasses chunk upload's request timeout (cos-glasses-app api-client.ts). A failed attempt can take this long. */
+export const GLASSES_UPLOAD_TIMEOUT_MS = 30_000
+/**
+ * 6.58.1: how long a copy's own `recording` word holds without proof. On 2026-09-29 (glasses
+ * 6.9.558) a hidden copy lost its audio at 07:38:19 and kept claiming `recording: true` for 12
+ * minutes; two newer copies started the meeting and were each told to stop within a second, and
+ * 12.5 minutes were never captured. The word exists for upload lag (QA round 3), which is bounded:
+ * the worst gap between two chunk arrivals from a copy that is recording is one failed attempt
+ * (the timeout) plus the longest backoff, 90 s. This allows one more backoff on top (QA, 6.58.1:
+ * exactly 90 s left no margin for a weak link, an ASR stall on the Mac or throttled timers).
+ */
+export const CLIENT_INSTANCE_WORD_HOLD_MS = GLASSES_UPLOAD_TIMEOUT_MS + 2 * GLASSES_UPLOAD_MAX_BACKOFF_MS
+/**
+ * 6.58.1: a gap between an owner's claims longer than two ticks is an outage or a sleep. When the
+ * owner comes back still saying `recording`, its word gets one fresh CLIENT_INSTANCE_WORD_HOLD_MS
+ * for its chunks to catch up, but only if a chunk of its own arrived since the last such grace:
+ * the 2026-09-29 zombie's timers were throttled (gaps of 30 s to 208 s between rows), so a grace
+ * on every gap would have held the ring for it indefinitely.
+ */
+export const CLIENT_INSTANCE_GRACE_GAP_MS = 2 * CLIENT_INSTANCE_TICK_MS
 /** App copies whose newest chunk is remembered; the least recent is dropped past this. */
 export const CLIENT_INSTANCE_MAX_TAGGED = 64
 /** A boot time this far past the server clock is a phone clock set wrong, not a newer copy. */
@@ -45,15 +67,41 @@ export interface ClientInstanceClaim {
   bootAt: number
   version: string
   /**
-   * The copy says it is recording (glasses 6.9.509+; false when absent). Chunk arrival
+   * The copy says it is recording (glasses 6.9.510+; false when absent). Chunk arrival
    * alone lags: after an outage the uploader backs off up to 60 s, and only a visible page
    * or a display reconnect resets it, which a hidden recording copy never gets (QA round 3).
    */
   recording: boolean
+  /**
+   * 6.58.1: the claim carried a `recording` field at all (glasses 6.9.510+). Only then is a
+   * `recording: false` a statement; from older copies it is merely absent.
+   */
+  recordingReported?: boolean
+}
+
+/**
+ * 6.58.1: what one copy has said about recording, kept per copy (not per owner) so it survives
+ * the ring moving between copies. Before this was per copy, a copy that lost the ring and took
+ * it back started a fresh clock each time, and a silent 6.9.538 copy and an idle newer one
+ * traded the ring every few minutes for a whole meeting, both answering the ring (QA, 6.58.1).
+ */
+export interface CopyWord {
+  recording: boolean
+  recordingReported: boolean
+  /** When this copy's current run of `recording: true` claims began. */
+  recordingSince?: number
+  /** When this copy last got a grace after a gap in its claims (see CLIENT_INSTANCE_GRACE_GAP_MS). */
+  graceAt?: number
+  /** When this copy last claimed, under any verdict. */
+  seenAt: number
 }
 
 export interface ClientInstanceOwner extends ClientInstanceClaim {
   seenAt: number
+  /** 6.58.1: the owner's CopyWord.recordingSince. */
+  recordingSince?: number
+  /** 6.58.1: the owner's CopyWord.graceAt. */
+  graceAt?: number
 }
 
 export type ClientInstanceVerdict = 'owner' | 'yield'
@@ -75,6 +123,10 @@ export interface CaptureEvidence {
   owner: boolean
   claimant: boolean
   untagged: boolean
+  /** 6.58.1: when the owner's own newest tagged chunk arrived, however long ago; absent: never (or forgotten). */
+  ownerChunkAt?: number
+  /** 6.58.1: the same for the claimant. */
+  claimantChunkAt?: number
 }
 
 export const NO_CAPTURE: CaptureEvidence = { owner: false, claimant: false, untagged: false }
@@ -97,10 +149,14 @@ export class ClientChunkLedger {
 
   evidence(device: string, ownerId: string, claimId: string, now: number): CaptureEvidence {
     const live = (at: number | undefined) => at !== undefined && now - at < CLIENT_INSTANCE_CAPTURE_LIVE_MS
+    const ownerChunkAt = this.tagged.get(ownerId)
+    const claimantChunkAt = this.tagged.get(claimId)
     return {
-      owner: live(this.tagged.get(ownerId)),
-      claimant: live(this.tagged.get(claimId)),
+      owner: live(ownerChunkAt),
+      claimant: live(claimantChunkAt),
       untagged: live(this.untagged.get(device)),
+      ...(ownerChunkAt !== undefined ? { ownerChunkAt } : {}),
+      ...(claimantChunkAt !== undefined ? { claimantChunkAt } : {}),
     }
   }
 }
@@ -111,10 +167,68 @@ export class ClientChunkLedger {
  * own last claim saying `recording`, and untagged chunks from the device (which could be
  * anyone's), count only while it is still claiming: a dead owner must never be pinned by
  * a stale flag or by the chunks of the copy that replaced it (QA round 2).
+ *
+ * 6.58.1, two limits from the 2026-09-29 zombie (see CLIENT_INSTANCE_WORD_HOLD_MS):
+ * - An owner still claiming that SAYS it is not recording is believed over its trailing chunks.
+ *   Glasses 6.9.560 says so within seconds of its audio stopping; the chunks it had already
+ *   committed can keep arriving and would hold the ring for a copy with nothing left to record.
+ *   Only while it claims (CLIENT_INSTANCE_LIVE_MS): a copy's start announcement is one claim with
+ *   a 1.5 s deadline while its chunks get 30 s, so a `false` from before a meeting can outlive a
+ *   start the Mac never heard, and its chunks must then speak for it (QA round 2: believing the
+ *   old `false` let a second copy record alongside). Only a claim that carries the field counts.
+ * - Its word alone holds for CLIENT_INSTANCE_WORD_HOLD_MS after its newest proof (wordBacked).
  */
 export function ownerIsRecording(owner: ClientInstanceOwner, evidence: CaptureEvidence, now: number): boolean {
-  if (evidence.owner) return true
-  return (owner.recording || evidence.untagged) && now - owner.seenAt <= CLIENT_INSTANCE_LIVE_MS
+  const claiming = now - owner.seenAt <= CLIENT_INSTANCE_LIVE_MS
+  if (evidence.owner && !(claiming && saysNotRecording(owner))) return true
+  if (!claiming) return false
+  if (evidence.untagged) return true
+  return wordBacked(owner, evidence.ownerChunkAt, now)
+}
+
+/** 6.58.1: the claim carried `recording: false` explicitly (glasses 6.9.510+). */
+export function saysNotRecording(claim: Pick<ClientInstanceClaim, 'recording' | 'recordingReported'>): boolean {
+  return claim.recordingReported === true && !claim.recording
+}
+
+/**
+ * 6.58.1: a copy's own `recording: true` still counts: its newest proof (its own newest chunk,
+ * the start of its run of recording claims, or its one grace after a gap) is no older than
+ * CLIENT_INSTANCE_WORD_HOLD_MS. The same rule for an owner holding the ring and a claimant
+ * taking it, so a copy with nothing to show cannot take the ring back by saying so (QA, 6.58.1).
+ */
+export function wordBacked(word: Pick<CopyWord, 'recording' | 'recordingSince' | 'graceAt'>, chunkAt: number | undefined, now: number): boolean {
+  if (!word.recording) return false
+  const provenAt = Math.max(chunkAt ?? 0, word.recordingSince ?? 0, word.graceAt ?? 0)
+  return now - provenAt <= CLIENT_INSTANCE_WORD_HOLD_MS
+}
+
+/**
+ * 6.58.1: a copy's word after its claim at `now`. `recordingSince` starts when its claims start
+ * saying `recording` and clears when they stop. A claim that comes back after a gap longer than
+ * CLIENT_INSTANCE_GRACE_GAP_MS, still recording, gets a grace for its uploads to catch up, once
+ * per chunk of its own: the first grace is free, and another needs a chunk newer than the last.
+ * `chunkAt` is this copy's own newest chunk.
+ */
+export function nextCopyWord(prev: CopyWord | undefined, claim: ClientInstanceClaim, now: number, chunkAt?: number): CopyWord {
+  const recordingReported = claim.recordingReported === true
+  if (!claim.recording) return { recording: false, recordingReported, seenAt: now }
+  if (!prev || !prev.recording || prev.recordingSince === undefined) return { recording: true, recordingReported, recordingSince: now, seenAt: now }
+  const cameBack = now - prev.seenAt > CLIENT_INSTANCE_GRACE_GAP_MS
+  const chunkSinceGrace = prev.graceAt === undefined || (chunkAt ?? 0) > prev.graceAt
+  const graceAt = cameBack && chunkSinceGrace ? now : prev.graceAt
+  return { recording: true, recordingReported, recordingSince: prev.recordingSince, ...(graceAt !== undefined ? { graceAt } : {}), seenAt: now }
+}
+
+/** The owner's word, as a CopyWord. */
+function wordOf(owner: ClientInstanceOwner): CopyWord {
+  return {
+    recording: owner.recording,
+    recordingReported: owner.recordingReported === true,
+    ...(owner.recordingSince !== undefined ? { recordingSince: owner.recordingSince } : {}),
+    ...(owner.graceAt !== undefined ? { graceAt: owner.graceAt } : {}),
+    seenAt: owner.seenAt,
+  }
 }
 
 /** A body the route may act on, or null. Never throws. */
@@ -127,7 +241,7 @@ export function parseClientInstanceClaim(body: unknown, now = Date.now()): Clien
   // as long as the clock stayed wrong (QA, 6.50.3).
   if (o.bootAt > now + CLIENT_INSTANCE_MAX_FUTURE_BOOT_MS) return null
   const version = typeof o.version === 'string' ? o.version.slice(0, 32) : ''
-  return { id: o.id, bootAt: o.bootAt, version, recording: o.recording === true }
+  return { id: o.id, bootAt: o.bootAt, version, recording: o.recording === true, recordingReported: typeof o.recording === 'boolean' }
 }
 
 function isNewer(a: ClientInstanceClaim, b: ClientInstanceClaim): boolean {
@@ -142,27 +256,44 @@ export function arbitrateClientInstance(
   evidence: CaptureEvidence = NO_CAPTURE,
   /** When this claimant last claimed (any verdict), or undefined: never seen. */
   claimantLastSeenAt?: number,
-): { owner: ClientInstanceOwner; verdict: ClientInstanceVerdict; took: boolean } {
-  const fresh: ClientInstanceOwner = { ...claim, seenAt: now }
-  if (!owner) return { owner: fresh, verdict: 'owner', took: true }
-  if (owner.id === claim.id) return { owner: { ...owner, seenAt: now, recording: claim.recording }, verdict: 'owner', took: false }
+  /**
+   * 6.58.1: this claimant's word before this claim (the route keeps one per copy). Undefined:
+   * the owner's own word when the claimant is the owner, otherwise a copy never heard from.
+   */
+  claimantWord?: CopyWord,
+): { owner: ClientInstanceOwner; verdict: ClientInstanceVerdict; took: boolean; word: CopyWord } {
+  const isOwner = owner !== null && owner.id === claim.id
+  const chunkAt = isOwner ? evidence.ownerChunkAt : evidence.claimantChunkAt
+  const word = nextCopyWord(claimantWord ?? (isOwner ? wordOf(owner) : undefined), claim, now, chunkAt)
+  const fresh: ClientInstanceOwner = {
+    ...claim,
+    seenAt: now,
+    ...(word.recordingSince !== undefined ? { recordingSince: word.recordingSince } : {}),
+    ...(word.graceAt !== undefined ? { graceAt: word.graceAt } : {}),
+  }
+  const decide = (o: ClientInstanceOwner, verdict: ClientInstanceVerdict, took: boolean) => ({ owner: o, verdict, took, word })
+  if (!owner) return decide(fresh, 'owner', true)
+  if (isOwner) return decide(fresh, 'owner', false)
   // 6.50.4: the yielding copy stops its recording (that is how a duplicate ends), so the
   // ring must never move in a way that stops the only recording.
   // (1) The claimant is recording and the owner is not: the claimant is the meeting.
   // Reopened offline, the Mac still names the dead copy from before; when signal returns,
   // the new copy's chunks land first and its claim must not be told to stop (QA round 2).
   // Its chunks or its own word: after an outage the uploads lag the claims (QA round 3).
-  if ((evidence.claimant || claim.recording) && !ownerIsRecording(owner, evidence, now)) return { owner: fresh, verdict: 'owner', took: true }
+  // 6.58.1: the claimant's chunks count unless it says it is not recording, and its word only
+  // while it is backed (wordBacked), the same tests the owner meets.
+  const claimantRecords = (evidence.claimant && !saysNotRecording(claim)) || wordBacked(word, chunkAt, now)
+  if (claimantRecords && !ownerIsRecording(owner, evidence, now)) return decide(fresh, 'owner', true)
   // (2) The owner is recording: a newer copy waits, however quiet the owner's claims.
   // Reopening COS on a blank phone page mid-meeting ended the meeting on 6.50.3 (QA).
   // The ring moves on the newer copy's first claim after the meeting stops.
-  if (ownerIsRecording(owner, evidence, now)) return { owner, verdict: 'yield', took: false }
-  if (isNewer(claim, owner)) return { owner: fresh, verdict: 'owner', took: true }
+  if (ownerIsRecording(owner, evidence, now)) return decide(owner, 'yield', false)
+  if (isNewer(claim, owner)) return decide(fresh, 'owner', true)
   // 6.52.3: an older boot takes a quiet ring back only after CLIENT_INSTANCE_RECLAIM_MS,
   // and only while it has itself been claiming (awake), never on the first tick after a
   // gap of its own. A dead newer copy is replaced when the user reopens COS (a newer boot
   // still takes at once); this rule is for the copy that is merely quiet.
   const claimantAwake = claimantLastSeenAt !== undefined && now - claimantLastSeenAt <= CLIENT_INSTANCE_AWAKE_MS
-  if (now - owner.seenAt > CLIENT_INSTANCE_RECLAIM_MS && claimantAwake) return { owner: fresh, verdict: 'owner', took: true }
-  return { owner, verdict: 'yield', took: false }
+  if (now - owner.seenAt > CLIENT_INSTANCE_RECLAIM_MS && claimantAwake) return decide(fresh, 'owner', true)
+  return decide(owner, 'yield', false)
 }

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

@@ -39,6 +39,10 @@ export interface QueryJobRunnerCallbacks {
   /** True only when provider ownership was durably fsynced for this active
    * generation. False means cancel/shutdown won; no prompt may be written. */
   onProviderProcess: (linkage: QueryJobProviderLinkage) => boolean | Promise<boolean>
+  /** 6.58.2: a link the provider names mid-run (the Claude session id). Persisted only while
+   * the job runs (like every link update it restamps providerOwnershipConfirmedAt); unlike
+   * onProviderProcess it gates nothing, and a job that already ended keeps what it had. */
+  onLinkage?: (linkage: QueryJobProviderLinkage) => Promise<void>
   onChunk: (text: string) => void
   onToolStatus: (text: string) => void
   onActivityLine: (line: { kind: 'input' | 'output'; text: string }) => void
@@ -340,6 +344,9 @@ export class QueryJobCoordinator {
         })
       },
       onProviderProcess: linkage => this.providerProcessReady(active, linkage),
+      onLinkage: linkage => this.enqueueCallback(active, async () => {
+        await this.store.updateLinkage(active.jobId, linkage)
+      }),
       onChunk: (text) => { this.queuePartial(active, text) },
       onToolStatus: (text) => {
         if (active.request.activityToolMode === 'off') text = 'Processing...'

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

@@ -234,6 +234,8 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
               ? { ollamaRunId: metadata.runId }
               : { codexRunId: metadata.runId }),
       }),
+      // 6.58.2: the provider's own session id, as soon as it names it (Claude: first stream event).
+      onNativeSession: linkage => { void callbacks.onLinkage?.({ provider: 'claude', cliSessionId: linkage.cliSessionId }) },
       onChunk: text => { callbacks.onChunk(text) },
       onToolStatus: toolName => {
         const message = request.activityToolMode === 'off'
@@ -349,6 +351,7 @@ const runner: QueryJobRunner = async ({ jobId, turnId, request, signal, callback
       attachmentPromptBlock: resolvedAttachments.promptBlock,
       sessionLockHeld: true,
       ...(request.dispatch ? { dispatch: request.dispatch } : {}),
+      ...(request.sessionName ? { sessionName: request.sessionName } : {}),
     },
   )
 }

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

@@ -120,6 +120,45 @@ export interface QueryJobRequest {
   origin?: QueryJobOrigin
   /** Read-only dispatch constraint. Excluded from the fingerprint. */
   dispatch?: { restricted: true; tools: readonly string[] }
+  /**
+   * 6.58.2: the display name a NEW Claude session gets (`claude --name`), so a session COS
+   * Control starts for a Work item shows under that item's name in the Claude app instead of
+   * "General coding session". Sanitized by sanitizeSessionName. Excluded from the fingerprint:
+   * it names the session, it does not change what is asked.
+   */
+  sessionName?: string
+}
+
+/** 6.58.2: longest session name kept (the Claude sidebar shows about 40 characters). */
+export const QUERY_JOB_SESSION_NAME_MAX = 100
+
+/**
+ * 6.58.2: a display name, or undefined. Control characters, zero-width spaces and direction
+ * marks and overrides become spaces (the joiners U+200C and U+200D stay: scripts and emoji need
+ * them), runs of whitespace collapse, and a name longer than QUERY_JOB_SESSION_NAME_MAX
+ * characters (grapheme clusters, as Swift counts them) is cut there, back to its last space when
+ * that space is in the second half. The cut never splits a character. Never throws: a bad name
+ * is no name. COS Control applies the same rules before it sends the name.
+ */
+export function sanitizeSessionName(raw: unknown): string | undefined {
+  if (typeof raw !== 'string') return undefined
+  // eslint-disable-next-line no-control-regex
+  const flat = raw.replace(/[\u0000-\u001f\u007f-\u009f\u200b\u200e\u200f\u202a-\u202e\u2066-\u2069\ufeff]/g, ' ').replace(/\s+/g, ' ').trim()
+  if (!flat) return undefined
+  const chars = graphemes(flat)
+  if (chars.length <= QUERY_JOB_SESSION_NAME_MAX) return flat
+  const cut = chars.slice(0, QUERY_JOB_SESSION_NAME_MAX)
+  const space = cut.lastIndexOf(' ')
+  return (space >= QUERY_JOB_SESSION_NAME_MAX / 2 ? cut.slice(0, space) : cut).join('').trim()
+}
+
+const graphemeSegmenter = typeof Intl !== 'undefined' && typeof Intl.Segmenter === 'function'
+  ? new Intl.Segmenter(undefined, { granularity: 'grapheme' })
+  : null
+
+/** Grapheme clusters when the runtime can segment them, else code points (never half a pair). */
+function graphemes(text: string): string[] {
+  return graphemeSegmenter ? Array.from(graphemeSegmenter.segment(text), part => part.segment) : Array.from(text)
 }
 
 export const DISPATCH_ALLOWED_TOOLS = ['Read', 'Grep', 'Glob'] as const
@@ -325,6 +364,7 @@ export function parseQueryJobRequest(raw: unknown, options: ParseQueryJobRequest
   const messageEra = optionalString(input.messageEra, 'message_era', 80)
   const handoffCode = optionalString(input.handoffCode, 'handoff_code', 128)
   const clientQueueItemId = optionalString(input.clientQueueItemId, 'client_queue_item_id', 120)
+  const sessionName = sanitizeSessionName(input.sessionName)
   const globalMsgNum = input.globalMsgNum == null ? undefined : Number(input.globalMsgNum)
   if (globalMsgNum != null && (!Number.isSafeInteger(globalMsgNum) || globalMsgNum < 1)) {
     throw new QueryJobValidationError('invalid_global_msg_num')
@@ -395,6 +435,7 @@ export function parseQueryJobRequest(raw: unknown, options: ParseQueryJobRequest
     ...(handoffCode ? { handoffCode } : {}),
     ...(input.handoffLatest === true ? { handoffLatest: true } : {}),
     ...(clientQueueItemId ? { clientQueueItemId } : {}),
+    ...(sessionName ? { sessionName } : {}),
     attachmentIds,
     attachmentRefs,
     activityToolMode,
@@ -464,7 +505,7 @@ export const FINGERPRINT_KEYS = [
 /** The request keys deliberately OUTSIDE the identity. Every key of
  * `QueryJobRequest` must appear in exactly one of the two lists: adding a key
  * without naming it here or above fails to compile, so the author picks a side. */
-export const FINGERPRINT_EXCLUDED = ['origin', 'dispatch'] as const satisfies readonly (keyof QueryJobRequest)[]
+export const FINGERPRINT_EXCLUDED = ['origin', 'dispatch', 'sessionName'] as const satisfies readonly (keyof QueryJobRequest)[]
 type FingerprintUncovered = Exclude<keyof QueryJobRequest, typeof FINGERPRINT_KEYS[number] | typeof FINGERPRINT_EXCLUDED[number]>
 export const FINGERPRINT_KEYS_COVER_REQUEST: FingerprintUncovered extends never ? true : never = true
 

package/server/routes/client-instance.ts

@@ -21,8 +21,8 @@ import {
   parseClientInstanceClaim,
   parseInstanceTag,
   ClientChunkLedger,
-  NO_CAPTURE,
   type ClientInstanceOwner,
+  type CopyWord,
 } from '../lib/client-instance-claim.js'
 
 /** Owners kept at once; the least recently seen device is dropped past this. */
@@ -58,6 +58,13 @@ export function createClientInstanceRouter(deps: ClientInstanceRouterDeps | (()
     lastSeen.delete(id); lastSeen.set(id, at)
     while (lastSeen.size > CLIENT_INSTANCE_MAX_SEEN) lastSeen.delete(lastSeen.keys().next().value as string)
   }
+  // 6.58.1: what each copy has said about recording, kept across changes of owner (CopyWord).
+  // Bounded like lastSeen; a check updates it too (the copy still said it).
+  const words = new Map<string, CopyWord>()
+  const noteWord = (id: string, word: CopyWord) => {
+    words.delete(id); words.set(id, word)
+    while (words.size > CLIENT_INSTANCE_MAX_SEEN) words.delete(words.keys().next().value as string)
+  }
   router.use((req, _res, next) => {
     if (isMeetingChunkPost(req.method, req.path)) chunks.note(deviceKey(req.socket?.remoteAddress ?? req.ip), parseInstanceTag(req.query?.clientInstance), now())
     next()
@@ -68,11 +75,13 @@ export function createClientInstanceRouter(deps: ClientInstanceRouterDeps | (()
     if (!claim) return void res.status(400).json({ error: 'invalid_claim' })
     const device = deviceKey(req.socket?.remoteAddress ?? req.ip)
     const previous = owners.get(device) ?? null
-    const evidence = previous ? chunks.evidence(device, previous.id, claim.id, at) : NO_CAPTURE
+    // 6.58.1: evidence even with no owner, so a first claim still knows its own newest chunk.
+    const evidence = chunks.evidence(device, previous?.id ?? '', claim.id, at)
     const captureLive = previous ? ownerIsRecording(previous, evidence, at) : false
     const claimantLastSeenAt = lastSeen.get(claim.id)
     noteSeen(claim.id, at)
-    const result = arbitrateClientInstance(previous, claim, at, evidence, claimantLastSeenAt)
+    const result = arbitrateClientInstance(previous, claim, at, evidence, claimantLastSeenAt, words.get(claim.id))
+    noteWord(claim.id, result.word)
     if (req.body?.check === true) {
       const shown = previous ?? result.owner
       return void res.json({ verdict: result.verdict, owner: { id: shown.id, bootAt: shown.bootAt, version: shown.version, seenAt: shown.seenAt }, check: true, captureLive })