@gotcos/glasses-server 6.58.1 → 6.58.2

package/CHANGELOG.md

@@ -1,3 +1,14 @@
+## 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

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.1",
+  "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/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