@gotcos/glasses-server 6.99.29 → 7.0.7

package/server/lib/work-activity.ts

@@ -46,6 +46,12 @@ export interface WorkActivity {
    * `unknown` (older clients); with this flag it is "Sending", not an unresolved delivery. Absent otherwise.
    */
   sending?: true
+  /**
+   * 7.0.1: when the current needs-input or blocked report was made: the newest progress event of that kind (Control
+   * records each report as an event at the reply's own time). Absent for any other report, or when no event says.
+   * Today dates a waiting row by this, not by the card's newest event.
+   */
+  waitingSince?: string
 }
 /** 6.59.0 (S4): where Control's saved draft for the task's current revision sends. Never the draft's prompt. */
 export interface SavedDestination { mode: WorkHandoffMode; provider: string; model?: string; sessionId?: string }
@@ -69,7 +75,9 @@ type JournalRecord = Record<string, unknown>
 export interface WorkJournal { available: true; receipts: JournalRecord[]; drafts: JournalRecord[] }
 export type WorkJournalRead = WorkJournal | { available: false; reason: string }
 
-export const WORK_ACTIVITY_LIMITS = { evidence: 280, evidenceUnits: 1_200, openItems: 50, trackedDays: 14, progressEvents: 1_000, sendingSeconds: 600 } as const
+export const WORK_ACTIVITY_LIMITS = { evidence: 280, evidenceUnits: 1_200, openItems: 50, trackedDays: 14, progressEvents: 1_000, sendingSeconds: 600,
+  /** 7.0.1: session activity this long after a needs-input or blocked report supersedes it (the reply that carried it is not). */
+  supersedeSeconds: 60 } as const
 /** Control's `TaskRow.workStages` (and task-store WORK_STAGES). A move naming anything else is not projected. */
 export const WORK_ACTIVITY_STAGES: readonly string[] = ['mentioned', 'planned', 'draft', 'built', 'qa', 'complete']
 const unavailableJournal = (reason: string): WorkJournalRead => ({ available: false, reason })
@@ -147,7 +155,7 @@ export function cleanEvidence(value: unknown): string | undefined {
  * The receipt's optional `progress` block, parsed on its own. Absent is undefined; a malformed block reads
  * `{ unreadable: true }` and never makes the journal unavailable: Control writes it, and a newer Control may write more.
  */
-function parseProgress(raw: unknown): { projection: WorkActivityProgress | UnreadableWorkProgress; newestAt?: number } | undefined {
+function parseProgress(raw: unknown): { projection: WorkActivityProgress | UnreadableWorkProgress; newestAt?: number; reportAt?: number } | undefined {
   if (raw === undefined || raw === null) return undefined
   const unreadable = { projection: { unreadable: true as const } }
   if (!object(raw)) return unreadable
@@ -173,13 +181,20 @@ function parseProgress(raw: unknown): { projection: WorkActivityProgress | Unrea
   }
   const received = isoFromSeconds(receivedAt)
   if (received) projection.receivedAt = received
+  // 7.0.1: when it started waiting. Control records a session's report as an event of the report's own kind, and a Jev
+  // reading as a 'jev' event; the newest such event is the report standing now.
+  let reportAt: number | undefined
+  if (state === 'needsInput' || state === 'blocked') {
+    const kinds = projection.reportedBy === 'jev' ? [state, 'jev'] : [state]
+    for (const event of list as JournalRecord[]) if (kinds.includes(event.kind as string)) reportAt = reportAt === undefined ? event.at as number : Math.max(reportAt, event.at as number)
+  }
   // The newest move COS made, undone or not (Control's timeline order: events are appended).
   const move = [...list].reverse().find(event => (event as JournalRecord).kind === 'moved') as JournalRecord | undefined
   const moveAt = move && isoFromSeconds(move.at)
   if (move && moveAt && WORK_ACTIVITY_STAGES.includes(move.fromStage as string) && WORK_ACTIVITY_STAGES.includes(move.toStage as string)) {
     projection.lastMove = { from: move.fromStage as string, to: move.toStage as string, at: moveAt, undone: finite(move.undoneAt) }
   }
-  return { projection, newestAt }
+  return { projection, newestAt, reportAt }
 }
 /** The report a progress projection carries, or null (none, or unreadable). */
 export function reportOf(progress: WorkActivity['progress']): WorkActivityProgress['reported'] {
@@ -229,6 +244,8 @@ function projectReceipt(receipt: JournalRecord, domain: string, all: readonly Jo
       ? isoFromSeconds(Math.max(receipt.createdAt as number, progress.newestAt)) ?? createdAt : createdAt
   }
   if (progress) activity.progress = progress.projection
+  const waitingSince = isoFromSeconds(progress?.reportAt)
+  if (waitingSince) activity.waitingSince = waitingSince
   // Control's handledByYou: acknowledged, or an unknown or delivered handoff you marked reviewed.
   activity.acknowledged = finite(receipt.acknowledgedAt) || raw === 'reviewed'
   // Ownership is the SESSION's, across every receipt that names it (Control's appOwner and serverHold look at all of them).
@@ -384,9 +401,33 @@ export function savedDestinationFor(journal: WorkJournal, row: WorkBoardRowLite)
   return draft ? draftDestination(draft) : undefined
 }
 
+/**
+ * 7.0.1: the time a report was superseded, or nothing. The report's time is when it started waiting (`waitingSince`),
+ * else the card's newest event. `sessionActivityMs` is the newest turn Miles started in the session
+ * (work-session-activity.ts: a real prompt, never the session's own work, a background agent's notification or a tool
+ * result; review W3). It has to come more than `supersedeSeconds` after the report, a grace for the tracker's clock.
+ */
+function supersededBy(activity: WorkActivity, sessionActivityMs: ReadonlyMap<string, number> | undefined): string | undefined {
+  if (!activity.sessionId || !sessionActivityMs) return undefined
+  const last = sessionActivityMs.get(activity.sessionId)
+  const since = Date.parse(activity.waitingSince ?? activity.updatedAt ?? '')
+  if (last === undefined || !Number.isFinite(last) || !Number.isFinite(since)) return undefined
+  return last - since > WORK_ACTIVITY_LIMITS.supersedeSeconds * 1000 ? new Date(last).toISOString() : undefined
+}
+
 /** S2 groups, in order. */
 export type OpenWorkGroup = 'needsInput' | 'attention' | 'running' | 'done'
-export interface OpenWorkItem extends WorkActivity { workIdentity: string; title: string; taskRevision: string; group: OpenWorkGroup; savedDestination?: SavedDestination }
+export interface OpenWorkItem extends WorkActivity {
+  workIdentity: string; title: string; taskRevision: string; group: OpenWorkGroup; savedDestination?: SavedDestination
+  /**
+   * 7.0.1: the needs-input or blocked report was superseded: you started a turn in its session after the report, at
+   * this time. The item is grouped as if no report stood. The report itself stays in
+   * `progress`, as Control recorded it.
+   */
+  supersededAt?: string
+}
+/** 7.0.1: what the open list knows about each linked session: the newest turn you started in it, ms, by `provider:native`. */
+export interface OpenWorkOptions { sessionActivityMs?: ReadonlyMap<string, number> }
 export interface OpenWorkList { items: OpenWorkItem[]; total: number; truncated: boolean }
 const GROUP_RANK: Record<OpenWorkGroup, number> = { needsInput: 0, attention: 1, running: 2, done: 3 }
 
@@ -400,8 +441,14 @@ const GROUP_RANK: Record<OpenWorkGroup, number> = { needsInput: 0, attention: 1,
  * A report counts only on a receipt that did not fail, was not refused and not canceled (Control's WorkTracking.latest).
  * A checked task shows only while its handoff is queued or running (Control's board). Groups in that order, the most
  * recently updated first within each, cut to 50 after sorting; `total` counts them all. Read-only.
+ *
+ * 7.0.1 (Miles 11/07, a row "Waiting for your reply" since Oct 31 on a session he talks to all day): a needs-input or
+ * blocked report stands only until its session moves on. Control's tracker takes a report from the session's status
+ * line for this task, so a later turn that never mentions the task again leaves the old report in place for the whole
+ * 14 days. When `options.sessionActivityMs` shows a turn you started in the session more than a minute after the report,
+ * the report no longer groups the item. The session's own work never does (review W3).
  */
-export function projectOpenWork(journal: WorkJournal, rows: readonly WorkBoardRowLite[], nowMs: number): OpenWorkList {
+export function projectOpenWork(journal: WorkJournal, rows: readonly WorkBoardRowLite[], nowMs: number, options: OpenWorkOptions = {}): OpenWorkList {
   const newest = new Map<string, JournalRecord>()
   for (const receipt of journal.receipts) {
     const prior = newest.get(receipt.workID as string)
@@ -419,7 +466,9 @@ export function projectOpenWork(journal: WorkJournal, rows: readonly WorkBoardRo
     if (!receipt || nowSeconds - (receipt.createdAt as number) >= WORK_ACTIVITY_LIMITS.trackedDays * 86_400) continue
     const activity = projectReceipt(receipt, row.domain, journal.receipts, nowMs)
     const status = activity.status, handled = activity.acknowledged === true
-    const reported = ['failed', 'refused', 'canceled'].includes(status) ? null : reportOf(activity.progress)
+    let reported = ['failed', 'refused', 'canceled'].includes(status) ? null : reportOf(activity.progress)
+    const supersededAt = reported === 'needsInput' || reported === 'blocked' ? supersededBy(activity, options.sessionActivityMs) : undefined
+    if (supersededAt) reported = null
     // A send in flight is running, not unresolved.
     const sending = activity.sending === true
     const group: OpenWorkGroup | null = (reported === 'needsInput' || reported === 'blocked') && !handled ? 'needsInput'
@@ -431,6 +480,7 @@ export function projectOpenWork(journal: WorkJournal, rows: readonly WorkBoardRo
     // Control drops a completed task's card unless its handoff is still in progress.
     if (row.checked === true && !sending && !['queued', 'running'].includes(status)) continue
     const item: OpenWorkItem = { ...activity, workIdentity: identity, title: typeof row.title === 'string' ? row.title : '', taskRevision: controlSnapshotRevision(row), group }
+    if (supersededAt) item.supersededAt = supersededAt
     const destination = savedDestinationFor(journal, row)
     if (destination) item.savedDestination = destination
     const updatedAt = activity.updatedAt ? Date.parse(activity.updatedAt) : 0

package/server/lib/work-session-activity.ts

@@ -0,0 +1,260 @@
+/**
+ * 7.0.1 (Needs you stale): when Miles last started a turn in each Work session, for the open list's supersede rule
+ * (work-activity.ts projectOpenWork, `sessionActivityMs`).
+ *
+ * Miles, 11/07: Today showed "Waiting for your reply" on a Work card from Oct 31 while he talked to its session all
+ * day. Control's tracker had taken a needs-input report from the session's status line for that task, and no later
+ * turn mentioned the task again, so the report stood. The session's own transcript says he moved on.
+ *
+ * ONLY A TURN HE STARTED COUNTS (review W3). The session's own work is not an answer: a background agent finishing,
+ * a tool result, a Monitor or /loop wakeup, a message from another session, a system reminder or a compaction summary
+ * all write records into the transcript with nobody typing. Counting those cleared a report Miles still owed.
+ * - Claude: a `user` record that is a real prompt: not `isMeta`, not a compaction summary, not a tool result, not a
+ *   task notification, and from a human origin when the record says where it came from (`origin.kind` and
+ *   `turnOrigin` are `human` on a typed prompt; `peer`, `task-notification`, `system` and `sdk` are not). Its text,
+ *   with system reminders taken out, has to say something. Checked against the record shapes of a real transcript.
+ * - Codex: a `response_item` message with role `user` whose text is not an injected block (`<environment_context>`,
+ *   `# AGENTS.md instructions`, the files-mentioned list and the like).
+ * - Cursor: transcripts carry no per-record clock or origin, so a Cursor session answers its file's write time. Any
+ *   write moves it, so a Cursor report can clear on the agent's own work. A listed limit.
+ *
+ * BOUNDED (review W4): at most `sessions` sessions per call, the stalest waiting reports first (waitingSessionIds);
+ * the Claude transcript index is built once per call; each session's answer is cached for `cacheMs`; concurrent
+ * callers share one read per session; and `timeoutMs` is a deadline the walk itself checks between folders, sessions
+ * and read windows, so a slow disk stops the work, not only the wait. A session it cannot find or read in time is left
+ * out, which keeps its report standing: the old behaviour, never a guessed clear.
+ */
+import { open, stat } from 'node:fs/promises'
+import {
+  agentSessionRoots, codexSessionRootsOf, fileStat, findAgentSessionFile, listCodexJsonlFiles, loadClaudeDesktopAliases, loadClaudeTranscriptIndex,
+  type AgentSessionRoots,
+} from './agent-session-store.js'
+import { parseWorkSessionId } from './work-activity.js'
+
+export const WORK_SESSION_ACTIVITY_LIMITS = {
+  sessions: 12,
+  timeoutMs: 2_000,
+  /** One session's answer is reused this long: a list poll and the badge recount never walk the disk again inside it. */
+  cacheMs: 30_000,
+  /** First window read from the end of a transcript, widened x4 while no human turn is found. */
+  tailBytes: 256 * 1024,
+  /** Largest window: a session working for hours since his last prompt writes a lot of tool output. */
+  tailMaxBytes: 64 * 1024 * 1024,
+} as const
+
+export interface WorkSessionActivityOptions {
+  /** Fixture roots. Without them, an isolated runtime (tests) reads nothing rather than this Mac's transcripts. */
+  roots?: AgentSessionRoots
+  env?: NodeJS.ProcessEnv
+  timeoutMs?: number
+  /** Test seam for the cache and deadline clock. */
+  now?: () => number
+}
+
+type Rec = Record<string, unknown>
+const SYSTEM_REMINDER = /<system-reminder>[\s\S]*?<\/system-reminder>/g
+/** Text a Claude user record carries that nobody typed. */
+const CLAUDE_INJECTED = /^(<task-notification>|<local-command-stdout>|<local-command-stderr>|<local-command-caveat>|Caveat: The messages below were generated)/
+/** Codex user-role blocks the app injects around a prompt. */
+const CODEX_INJECTED = /^(<environment_context>|<user_instructions>|<external_[a-z_]+>|# AGENTS\.md instructions|# Files mentioned by the user)/
+
+function originKind(obj: Rec): string | null {
+  const origin = obj.origin
+  if (origin && typeof origin === 'object' && typeof (origin as Rec).kind === 'string') return (origin as Rec).kind as string
+  return null
+}
+
+/** A Claude transcript record that is a turn Miles started. Exported for tests. */
+export function claudeHumanTurn(obj: Rec): boolean {
+  if (obj.type !== 'user' || obj.isMeta === true || obj.isCompactSummary === true || obj.isVisibleInTranscriptOnly === true || obj.toolUseResult) return false
+  const kind = originKind(obj)
+  if (kind !== null && kind !== 'human') return false
+  if (kind === null && typeof obj.turnOrigin === 'string' && obj.turnOrigin !== 'human') return false
+  const content = (obj.message as Rec | undefined)?.content
+  const blocks: Rec[] = typeof content === 'string' ? [{ type: 'text', text: content }]
+    : Array.isArray(content) ? content.filter((b): b is Rec => !!b && typeof b === 'object') : []
+  if (blocks.some(b => b.type === 'tool_result')) return false
+  let said = false
+  for (const block of blocks) {
+    if (block.type === 'image') { said = true; continue }
+    if (block.type !== 'text' || typeof block.text !== 'string') continue
+    const text = block.text.replace(SYSTEM_REMINDER, '').trim()
+    if (!text) continue
+    if (CLAUDE_INJECTED.test(text)) return false
+    said = true
+  }
+  return said
+}
+
+/** A Codex rollout record that is a message Miles sent. Exported for tests. */
+export function codexHumanTurn(obj: Rec): boolean {
+  if (obj.type !== 'response_item' || !obj.payload || typeof obj.payload !== 'object') return false
+  const payload = obj.payload as Rec
+  if (payload.type !== 'message' || payload.role !== 'user' || !Array.isArray(payload.content)) return false
+  return payload.content.some(b => {
+    if (!b || typeof b !== 'object') return false
+    const block = b as Rec
+    if (block.type === 'input_image') return true
+    if (typeof block.text !== 'string') return false
+    const text = block.text.trim()
+    return !!text && !CODEX_INJECTED.test(text)
+  })
+}
+
+/** The newest human turn's time in a transcript tail, ms, or null. Exported for tests. */
+export function lastHumanTurnFromTail(provider: 'claude' | 'codex', text: string, startsMidFile: boolean): number | null {
+  const lines = text.split('\n')
+  if (startsMidFile) lines.shift()
+  const isHuman = provider === 'claude' ? claudeHumanTurn : codexHumanTurn
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const line = lines[i]!
+    // Cheap prefilter before a parse: every candidate names a user role.
+    if (!line.includes('"user"')) continue
+    let obj: unknown
+    try { obj = JSON.parse(line) } catch { continue }
+    if (!obj || typeof obj !== 'object' || Array.isArray(obj) || !isHuman(obj as Rec)) continue
+    const at = Date.parse(String((obj as Rec).timestamp ?? ''))
+    if (Number.isFinite(at)) return at
+  }
+  return null
+}
+
+const turnMemo = new Map<string, { mtimeMs: number; size: number; at: number | null }>()
+const TURN_MEMO_MAX = 200
+
+/** One transcript's newest human turn, memoized on mtime and size. undefined: the deadline came first. */
+async function readLastHumanTurn(provider: 'claude' | 'codex', file: string, pastDeadline: () => boolean): Promise<number | null | undefined> {
+  const st = await stat(file)
+  const hit = turnMemo.get(file)
+  if (hit && hit.mtimeMs === st.mtimeMs && hit.size === st.size) return hit.at
+  let at: number | null = null
+  const handle = await open(file, 'r')
+  try {
+    for (let window: number = WORK_SESSION_ACTIVITY_LIMITS.tailBytes; ; window *= 4) {
+      if (pastDeadline()) return undefined
+      const length = Math.min(st.size, window), start = st.size - length
+      const buffer = Buffer.alloc(length)
+      const { bytesRead } = await handle.read(buffer, 0, length, start)
+      at = lastHumanTurnFromTail(provider, buffer.subarray(0, bytesRead).toString('utf8'), start > 0)
+      if (at !== null || start === 0 || window >= WORK_SESSION_ACTIVITY_LIMITS.tailMaxBytes) break
+    }
+  } finally {
+    await handle.close()
+  }
+  turnMemo.delete(file)
+  while (turnMemo.size >= TURN_MEMO_MAX) { const oldest = turnMemo.keys().next().value; if (oldest === undefined) break; turnMemo.delete(oldest) }
+  turnMemo.set(file, { mtimeMs: st.mtimeMs, size: st.size, at })
+  return at
+}
+
+/** Per session: the answer and when it was read. `at` null: read, and no human turn (or no transcript, or unreadable). */
+const cache = new Map<string, { at: number | null; readAt: number }>()
+const inflight = new Map<string, Promise<number | null | undefined>>()
+const CACHE_MAX = 500
+let walks = 0
+
+function cacheKey(roots: AgentSessionRoots, id: string): string { return `${roots.claudeProjects}\u0000${roots.cursorProjects}\u0000${id}` }
+
+/** Newest human turn, ms since 1970, of each session it could read, keyed by the id exactly as given. */
+export async function workSessionActivity(sessionIds: readonly string[], options: WorkSessionActivityOptions = {}): Promise<Map<string, number>> {
+  const found = new Map<string, number>()
+  const env = options.env ?? process.env
+  if (!options.roots && (env.NODE_ENV === 'test' || env.VITEST)) return found
+  const roots = options.roots ?? agentSessionRoots()
+  const now = options.now ?? (() => Date.now())
+  const ids = [...new Set(sessionIds)].filter(id => parseWorkSessionId(id) !== null).slice(0, WORK_SESSION_ACTIVITY_LIMITS.sessions)
+  if (!ids.length) return found
+  const started = now(), deadline = started + (options.timeoutMs ?? WORK_SESSION_ACTIVITY_LIMITS.timeoutMs)
+  const pastDeadline = () => now() >= deadline
+  const keep = (id: string, at: number | null | undefined) => { if (typeof at === 'number' && Number.isFinite(at)) found.set(id, at) }
+
+  const missing: string[] = []
+  const waits: Array<Promise<void>> = []
+  for (const id of ids) {
+    const key = cacheKey(roots, id), hit = cache.get(key)
+    if (hit && started - hit.readAt < WORK_SESSION_ACTIVITY_LIMITS.cacheMs) { keep(id, hit.at); continue }
+    const running = inflight.get(key)
+    if (running) waits.push(running.then(at => keep(id, at)))
+    else missing.push(id)
+  }
+
+  if (missing.length) {
+    // One walk for every missing session. Each session's promise is registered first, so a concurrent caller waits on
+    // this read instead of starting its own.
+    const settle = new Map<string, (at: number | null | undefined) => void>()
+    for (const id of missing) {
+      const key = cacheKey(roots, id)
+      const one = new Promise<number | null | undefined>(resolve => settle.set(id, resolve))
+      inflight.set(key, one)
+      waits.push(one.then(at => keep(id, at)))
+    }
+    void (async () => {
+      let indexed = false
+      let claudeFiles: Map<string, string[]> | undefined
+      let codexFiles: string[] | undefined
+      let aliases: Awaited<ReturnType<typeof loadClaudeDesktopAliases>> | undefined
+      for (const id of missing) {
+        const key = cacheKey(roots, id)
+        let at: number | null | undefined
+        try {
+          const { provider, native } = parseWorkSessionId(id)!
+          if (!pastDeadline() && !indexed) {
+            indexed = true
+            walks += 1
+            if (missing.some(m => parseWorkSessionId(m)!.provider === 'claude')) {
+              aliases = await loadClaudeDesktopAliases(roots.claudeCodeSessions)
+              claudeFiles = await loadClaudeTranscriptIndex(roots, pastDeadline)
+            }
+            if (!pastDeadline() && missing.some(m => parseWorkSessionId(m)!.provider === 'codex')) {
+              codexFiles = (await Promise.all(codexSessionRootsOf(roots).map(root => listCodexJsonlFiles(root)))).flat()
+            }
+          }
+          // Past the deadline (a walk it cut short is not a complete index, and resolving against it could pick the
+          // wrong file): left out this time and read again on the next call.
+          if (pastDeadline()) at = undefined
+          else {
+            const file = await findAgentSessionFile(provider as 'claude' | 'codex' | 'cursor', native, roots, new Date(), aliases, { claudeFiles, codexFiles })
+            if (!file) at = null
+            else if (provider === 'cursor') at = (await fileStat(file))?.mtimeMs ?? null
+            else at = await readLastHumanTurn(provider as 'claude' | 'codex', file, pastDeadline)
+          }
+        } catch {
+          at = null   // unreadable: its report stands, and the answer is cached like any other
+        }
+        if (at !== undefined) {
+          cache.delete(key)
+          while (cache.size >= CACHE_MAX) { const oldest = cache.keys().next().value; if (oldest === undefined) break; cache.delete(oldest) }
+          cache.set(key, { at, readAt: now() })
+        }
+        inflight.delete(key)
+        settle.get(id)!(at)
+      }
+    })()
+  }
+
+  let timer: NodeJS.Timeout | undefined
+  await Promise.race([Promise.all(waits), new Promise<void>(resolve => { timer = setTimeout(resolve, Math.max(0, deadline - now())) })])
+  clearTimeout(timer)
+  // A copy: a shared read may still land in `found` after the deadline.
+  return new Map(found)
+}
+
+/**
+ * The sessions whose report the open list would show as waiting: the ones worth reading. The stalest report first
+ * (review N7): under the 12-session cap the oldest waits are the likeliest to be stale, like the Oct 31 row.
+ */
+export function waitingSessionIds(items: ReadonlyArray<{ group: string; sessionId?: string; waitingSince?: string; updatedAt?: string }>): string[] {
+  const when = (item: { waitingSince?: string; updatedAt?: string }) => {
+    const t = Date.parse(item.waitingSince ?? item.updatedAt ?? '')
+    return Number.isFinite(t) ? t : Number.POSITIVE_INFINITY
+  }
+  const out: string[] = []
+  for (const item of items.filter(i => i.group === 'needsInput' && i.sessionId).sort((a, b) => when(a) - when(b))) {
+    if (!out.includes(item.sessionId!)) out.push(item.sessionId!)
+  }
+  return out
+}
+
+/** Test seams. */
+export function clearWorkSessionActivityCache(): void { cache.clear(); inflight.clear(); turnMemo.clear(); walks = 0 }
+export function workSessionActivityWalks(): number { return walks }

package/server/lib/your-move-count.ts

@@ -9,6 +9,7 @@
  * next poll tries again.
  */
 import { projectOpenWork, readWorkJournal, type OpenWorkGroup } from './work-activity.js'
+import { waitingSessionIds } from './work-session-activity.js'
 
 type Journal = ReturnType<typeof readWorkJournal>
 type Rows = Parameters<typeof projectOpenWork>[1]
@@ -17,6 +18,8 @@ export interface YourMoveCounterDeps {
   journal: () => Journal
   /** The board rows, or null when the board cannot be read in time. */
   rows: () => Promise<Rows | null>
+  /** 7.0.1: each linked session's newest activity, so a superseded report is not counted (the open list's own rule). */
+  sessionActivity?: (sessionIds: readonly string[]) => Promise<ReadonlyMap<string, number>>
   now?: () => number
   ttlMs?: number
 }
@@ -25,9 +28,9 @@ export const YOUR_MOVE_TTL_MS = 30_000
 const WAITING_GROUPS: readonly OpenWorkGroup[] = ['needsInput', 'attention', 'done']
 
 /** The pure count: open-work items whose group waits on you. */
-export function countYourMove(journal: Journal, rows: Rows, nowMs: number): number {
+export function countYourMove(journal: Journal, rows: Rows, nowMs: number, sessionActivityMs?: ReadonlyMap<string, number>): number {
   if (!journal.available) return 0
-  return projectOpenWork(journal, rows, nowMs).items.filter(item => WAITING_GROUPS.includes(item.group)).length
+  return projectOpenWork(journal, rows, nowMs, { sessionActivityMs }).items.filter(item => WAITING_GROUPS.includes(item.group)).length
 }
 
 export function createYourMoveCounter(deps: YourMoveCounterDeps): () => Promise<number | null> {
@@ -44,7 +47,10 @@ export function createYourMoveCounter(deps: YourMoveCounterDeps): () => Promise<
         if (!journal.available) return null
         const rows = await deps.rows()
         if (!rows) return null
-        const value = countYourMove(journal, rows, now())
+        const at = now()
+        const waiting = deps.sessionActivity && journal.available ? waitingSessionIds(projectOpenWork(journal, rows, at).items) : []
+        const activity = waiting.length ? await deps.sessionActivity!(waiting).catch(() => undefined) : undefined
+        const value = countYourMove(journal, rows, at, activity)
         cached = { at: now(), value }
         return value
       } catch {

package/server/routes/agent-session-bindings.ts

@@ -459,6 +459,13 @@ export interface AgentSessionBindingsDeps {
    */
   sessionSteer?: (provider: string, nativeThreadId: string, gateReason: string) => SessionSteerAvailability | null
 
+  /**
+   * Steer mid-turn (COS_STEER_MIDTURN): would a message parked at this busy thread go into its
+   * running turn at the next tool step? Added to a busy attachability answer as `midTurn`, so the
+   * composer says which line is true. Null (field absent) with the switch off.
+   */
+  sessionMidTurn?: (provider: string, nativeThreadId: string, gateReason: string) => SessionSteerAvailability | null
+
   ownership?: {
     record: (pid: number, startMs: number) => string
     release: (pid: number) => boolean
@@ -2164,8 +2171,14 @@ export function createAgentSessionBindingsRouter(deps: AgentSessionBindingsDeps)
     const detected = routeOccupancy(provider, threadId)
     const verdictBody = projectAttachability(detected)
     const cancelReason = detected.busyHolder === true ? 'native_thread_working' : verdictBody.reason
+    // Steer mid-turn: only on a busy answer a turn may queue behind, and only with the switch on.
+    let midTurn: SessionSteerAvailability | null = null
+    if (verdictBody.attachable === false && typeof verdictBody.reason === 'string' && queueableRefusal(verdictBody.reason) && typeof deps.sessionMidTurn === 'function') {
+      try { midTurn = deps.sessionMidTurn(provider, threadId, verdictBody.reason) } catch { midTurn = null }
+    }
     res.json({
       ...verdictBody,
+      ...(midTurn ? { midTurn } : {}),
       cancel: cancelFieldFor(provider, threadId, cancelReason),
       ...(await continueNoteFor(provider, threadId, continueNoteAcknowledged(req.headers[CONTINUE_NOTE_HEADER]))),
     })

package/server/routes/agent-session-stream.ts

@@ -59,6 +59,7 @@
 // never be mistaken for a user's explicit opt-out. Off answers 503 and the client
 // polls, which is the same code path as a server too old to have this route at all.
 
+import { redactLocalPaths } from '../lib/local-path-redact.js'
 import { Router, type Response } from 'express'
 import { stat } from 'node:fs/promises'
 import {
@@ -213,6 +214,16 @@ export async function openingState(
  */
 export const SEED_EVENTS = 7
 
+/**
+ * A stream event as it leaves for a client. 7.0.4 final QA: a `prompt` is redacted like the user turns in `?turns=`
+ * history (redactLocalPathsDeep, not a command field), so the lens's prompt match (findTurnStart) still finds its turn.
+ * Every other kind is unchanged.
+ */
+export function clientStreamEvent<T extends { kind: string }>(event: T): T {
+  const text = (event as { text?: unknown }).text
+  return event.kind === 'prompt' && typeof text === 'string' ? { ...event, text: redactLocalPaths(text) } : event
+}
+
 agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', async (req, res) => {
   res.set('Cache-Control', 'private, no-store')
 
@@ -331,6 +342,11 @@ agentSessionStreamRouter.get('/agent-sessions/:provider/:sessionId/stream', asyn
         lastStamp = stampOf(derived)
         out = { ...event, ...statusDraftWithDerived(event, derived) }
       }
+      // 7.0.4 final QA: the turn history (`?turns=`) redacts local paths in user turns, and the lens finds the turn on
+      // screen by matching this prompt's opening words against them (cos-glasses-app session-conversation.ts
+      // findTurnStart). An unredacted prompt with a Mac path never matched, so the lens refetched and showed the turn
+      // twice. The prompt leaves redacted the same way; server-side consumers keep the raw event.
+      out = clientStreamEvent(out)
       const idLine = typeof out.cursor === 'number' ? `id: ${out.epoch ?? RING_EPOCH}.${out.cursor}\n` : ''
       res.write(`${idLine}data: ${JSON.stringify({ seq: ++seq, ...out })}\n\n`)
     } catch {