@threadcrumbs/common 0.1.4 → 0.1.5

package/NOTICES.md

@@ -31,3 +31,99 @@ LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
 OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 ```
+
+### Fonts
+
+`ui/fonts/` includes these fonts as .woff2 files, from the @fontsource packages. Each is used under the SIL Open Font License, Version 1.1, which follows the list.
+
+- Inter and Inter Tight: Copyright 2016 and 2022 The Inter Project Authors (https://github.com/rsms/inter)
+- JetBrains Mono: Copyright 2020 The JetBrains Mono Project Authors (https://github.com/JetBrains/JetBrainsMono)
+
+```text
+SIL OPEN FONT LICENSE Version 1.1 - 26 February 2007
+-----------------------------------------------------------
+
+PREAMBLE
+The goals of the Open Font License (OFL) are to stimulate worldwide
+development of collaborative font projects, to support the font creation
+efforts of academic and linguistic communities, and to provide a free and
+open framework in which fonts may be shared and improved in partnership
+with others.
+
+The OFL allows the licensed fonts to be used, studied, modified and
+redistributed freely as long as they are not sold by themselves. The
+fonts, including any derivative works, can be bundled, embedded,
+redistributed and/or sold with any software provided that any reserved
+names are not used by derivative works. The fonts and derivatives,
+however, cannot be released under any other type of license. The
+requirement for fonts to remain under this license does not apply
+to any document created using the fonts or their derivatives.
+
+DEFINITIONS
+"Font Software" refers to the set of files released by the Copyright
+Holder(s) under this license and clearly marked as such. This may
+include source files, build scripts and documentation.
+
+"Reserved Font Name" refers to any names specified as such after the
+copyright statement(s).
+
+"Original Version" refers to the collection of Font Software components as
+distributed by the Copyright Holder(s).
+
+"Modified Version" refers to any derivative made by adding to, deleting,
+or substituting -- in part or in whole -- any of the components of the
+Original Version, by changing formats or by porting the Font Software to a
+new environment.
+
+"Author" refers to any designer, engineer, programmer, technical
+writer or other person who contributed to the Font Software.
+
+PERMISSION & CONDITIONS
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Font Software, to use, study, copy, merge, embed, modify,
+redistribute, and sell modified and unmodified copies of the Font
+Software, subject to the following conditions:
+
+1) Neither the Font Software nor any of its individual components,
+in Original or Modified Versions, may be sold by itself.
+
+2) Original or Modified Versions of the Font Software may be bundled,
+redistributed and/or sold with any software, provided that each copy
+contains the above copyright notice and this license. These can be
+included either as stand-alone text files, human-readable headers or
+in the appropriate machine-readable metadata fields within text or
+binary files as long as those fields can be easily viewed by the user.
+
+3) No Modified Version of the Font Software may use the Reserved Font
+Name(s) unless explicit written permission is granted by the corresponding
+Copyright Holder. This restriction only applies to the primary font name as
+presented to the users.
+
+4) The name(s) of the Copyright Holder(s) or the Author(s) of the Font
+Software shall not be used to promote, endorse or advertise any
+Modified Version, except to acknowledge the contribution(s) of the
+Copyright Holder(s) and the Author(s) or with their explicit written
+permission.
+
+5) The Font Software, modified or unmodified, in part or in whole,
+must be distributed entirely under this license, and must not be
+distributed under any other license. The requirement for fonts to
+remain under this license does not apply to any document created
+using the Font Software.
+
+TERMINATION
+This license becomes null and void if any of the above conditions are
+not met.
+
+DISCLAIMER
+THE FONT SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO ANY WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT
+OF COPYRIGHT, PATENT, TRADEMARK, OR OTHER RIGHT. IN NO EVENT SHALL THE
+COPYRIGHT HOLDER BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY,
+INCLUDING ANY GENERAL, SPECIAL, INDIRECT, INCIDENTAL, OR CONSEQUENTIAL
+DAMAGES, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
+FROM, OUT OF THE USE OR INABILITY TO USE THE FONT SOFTWARE OR FROM
+OTHER DEALINGS IN THE FONT SOFTWARE.
+
+```

package/README.md

@@ -19,14 +19,21 @@ need it.
 | `@threadcrumbs/common/launch` | `present(result, via)`: carries out a harness adapter's answer to "open this thread" by fronting the window of a session already running, handing a deep link to the OS, or running the harness's CLI in a new terminal. When nothing on the machine answers the link, it tries the adapter's `fallback` links, such as Claude Code's thread in VS Code, and failing those returns `{ ok: false, error, missing: { name, download, scheme, also }, terminal }`: the app to install, where to get it, other apps that would do, and whether `via: 'terminal'` would work instead. Also `launch(target)` and `resolveFolder(dir)`. Threadgauge uses it, and Threadnauts still has its own copy |
 | `@threadcrumbs/common/license` | The Threadcrumbs license both apps check offline and the key service signs: `createLicenseKeys`, `publicKeyOf`, `licenseClaims`, `signLicense`, `verifyLicense`, and the unlock rule, `paidThrough` and `unlocks`, plus `renewalDue`. Web APIs only, so the same file runs in a Cloudflare Worker. The format and rules are in [DECISIONS.md](DECISIONS.md#licenses-are-signed-by-threadcrumbs-and-checked-offline). `LICENSE_PUBLIC_KEYS` holds the production keys every app trusts, and never a sandbox key |
 | `@threadcrumbs/common/license/store` | Where the license lives on this machine, shared by every app: `licenseStore()` returns `device()`, `current()`, `save(token)`, and `clear()`, over `license.json` in `threadcrumbsDataDir()`. `current().at` is the time to test unlocks at, and `current()` writes nothing on a machine where no one has entered a key. `trustedKeys({ development })` adds a sandbox key in a development build, and `cloudUrl({ development })` is the key service's address: `https://threadcrumbs.io/api`, or the local Worker at `http://localhost:8787/api` in a development build. Node only, so the Worker never loads it |
+| `@threadcrumbs/common/ui/theme.css` | The Threadcrumbs look as CSS variables: the Quieter backgrounds, lines, and text levels, Threadcrumbs orange, the six status colors and their plates, `--warn`, added and removed, the chart and gauge colors, focus, type sizes, spacing, radii, and the default `--sans`, `--cond`, and `--mono` stacks. Every element keeps one x-height (`font-size-adjust: 0.51`) |
+| `@threadcrumbs/common/ui/fonts.css` | `@font-face` rules for Inter, Inter Tight, and JetBrains Mono, Latin and Latin Extended, upright, with their `.woff2` files in `ui/fonts/`. A bundler copies the files into the app, so they load from its own origin. `tools/ui-fonts.mjs` writes both from the `@fontsource` packages |
+| `@threadcrumbs/common/ui/status` | `STATUSES` (each status's key, name, color, and plate, in the order both apps pin), `STATUS_KEYS`, `URGENCY_ORDER` (for the status row and the waffle), `LIVE_STATUSES`, `statusOf`, the status icons as SVG in `LAMP_ICONS`, and `lampHTML(status)`. `ui/status.css` colors each `[data-st]` and animates the lamps, and reduced motion stops them |
+| `@threadcrumbs/common/ui/icons` | `ICO(name)`, the line icons (organization, folder, worktree, branch, model, key, and one per tool kind); `effortBars` and `effortName`; `harnessMark` (CC, Cx, and the others); and, for tool calls, `KINDS`, `kindOf`, `kindTip`, `kindIconHTML`, `toolKinds`, and `mcpServer` |
+| `@threadcrumbs/common/ui/where` | `whereHTML(thread)`, the organization and repo chips, `whereFullHTML(thread)` with the worktree and branch, and `repoName(name, org)`, which drops a package scope the organization repeats. `ui/where.css` styles the chips, the harness initials, the effort bars, and the tool kind icons |
+| `@threadcrumbs/common/ui/gauge` | `contextGauge({ pct, level }, size)`, the context gauge as SVG, with `levelOf(pct)` (amber from 70%, red from 90%) and `levelClass`. `ui/gauge.css` draws it and gives a picture with a tip a slightly larger hover area (`.i-wrap`) |
 
 `launch/` is the only part of this package that starts processes, and `license/store.mjs` is the
-only part that writes a file. The readers and `orgs/` import neither.
+only part that writes a file. The readers and `orgs/` import neither. `ui/` is plain functions
+that return markup, plus CSS and fonts, for a page to draw; it touches no DOM and does no I/O.
 
 These are likely to follow, each when an app first needs it from here:
 - **Suite discovery:** the `/api/about` identity format and the port search.
 - **Local-server safety:** the Host and Origin checks and the security policy.
-- **Design tokens:** the palette and status colors.
+- **More shared UI:** the list's lamps row, group heading, and thread row, then the Conversation.
 
 ## Using it from an app
 

package/lib/claude-transcript.mjs

@@ -1,6 +1,6 @@
 import fsp from 'node:fs/promises'
 import { requestCost } from './anthropic-prices.mjs'
-import { emptyFixed, emptySizes, setFixed, sizeCall, sizeCompaction, sizePrompt, sizeReply, sizeRequest, sizeResult, sizeResumed } from './context-breakdown.mjs'
+import { FIXED_PARTS, emptyFixed, emptySizes, setFixed, sizeCall, sizeCompaction, sizePrompt, sizeReply, sizeRequest, sizeResult, sizeResumed } from './context-breakdown.mjs'
 import { listFiles, parseJsonLine, readNewLines } from './fsutil.mjs'
 import {
   DETAIL_LIMITS,
@@ -25,6 +25,7 @@ import {
   settleCalls,
   startCall,
   textList,
+  wordsFull,
   toolFile,
   toolInput,
   toolTarget,
@@ -34,6 +35,7 @@ import { mcpServer } from './tool-kinds.mjs'
 const HEAD_BYTES = 192 * 1024
 const TAIL_BYTES = 64 * 1024
 const TAIL_LIMIT = 4 * 1024 * 1024
+const WORDS_TAIL_BYTES = 512 * 1024
 const NOISE = /<([a-z][\w-]*)(?:\s[^>]*)?>[\s\S]*?<\/\1>/g
 
 const AGENT_TOOLS = new Set(['Agent', 'Task'])
@@ -42,6 +44,7 @@ const AWAIT_LIMIT = 20
 const PEER_BUSY = new Set(['busy', 'waiting'])
 
 const MID_TURN = Object.freeze({ handedBack: false, failed: false })
+const INTERRUPTED = /^\[Request interrupted by user/
 
 const number = (v) => (Number.isFinite(Number(v)) ? Number(v) : 0)
 const text = (v) => (typeof v === 'string' ? v : '')
@@ -72,7 +75,7 @@ export async function readLiveSessions(dir, isAlive = pidAlive) {
   return live
 }
 
-export function transcriptReader({ skim = false, detail = false, words = false, sizes = false } = {}) {
+export function transcriptReader({ skim = false, detail = false, words = false, sizes = false, tail = false } = {}) {
   const files = new Map()
 
   async function advance(entry, file, size) {
@@ -80,7 +83,9 @@ export function transcriptReader({ skim = false, detail = false, words = false,
     const state = entry.state
     if (size === state.offset) return state
     try {
-      if (skim && state.offset === 0 && size > HEAD_BYTES + TAIL_BYTES) {
+      if (tail && state.offset === 0 && size > WORDS_TAIL_BYTES) {
+        await tailInto(state, file, size, () => emptyState(entry.sidechain, detail, words, sizes))
+      } else if (skim && state.offset === 0 && size > HEAD_BYTES + TAIL_BYTES) {
         await skimInto(state, file, size)
       } else {
         const { lines, carry } = await readNewLines(file, state.offset, size, state.carry)
@@ -117,6 +122,19 @@ export function transcriptReader({ skim = false, detail = false, words = false,
   return { read, sweep }
 }
 
+async function tailInto(state, file, size, fresh) {
+  for (let bytes = WORDS_TAIL_BYTES; ; bytes *= 4) {
+    const from = Math.max(0, size - bytes)
+    const { lines, carry } = await readNewLines(file, from, size)
+    const trial = fresh()
+    for (const line of from > 0 ? lines.slice(1) : lines) applyLine(trial, line)
+    if (from === 0 || wordsFull(trial.words)) {
+      Object.assign(state, trial, { offset: size, carry })
+      return
+    }
+  }
+}
+
 async function skimInto(state, file, size) {
   const head = await readNewLines(file, 0, HEAD_BYTES)
   const headEnd = HEAD_BYTES - head.carry.length
@@ -253,27 +271,31 @@ function applySystem(detail, record, at) {
   }
 }
 
-const emptySent = () => ({ system: 0, tools: [], deferred: new Set(), instructions: new Map(), skills: new Map(), skillsOther: 0, memory: new Map(), agents: 0 })
+const emptySent = () => ({ system: 0, tools: [], deferred: new Set(), instructions: new Map(), skills: new Map(), skillsOther: 0, memory: new Map(), agents: 0, seen: new Set() })
 
 function applySent(state, record) {
   const sent = state.sent
   const attachment = record.attachment
   if (record.type === 'system' && record.subtype === 'compact_boundary') {
     sizeCompaction(state.sizes)
-    state.sent = { ...emptySent(), system: sent.system, tools: sent.tools }
+    state.sent = { ...emptySent(), system: sent.system, tools: sent.tools, seen: sent.seen }
     return
   }
   if (record.type === 'api-request-shape') {
     const shape = record.shape || {}
+    sent.seen.add('shape')
     sent.system = (Array.isArray(shape.system) ? shape.system : []).reduce((n, part) => n + text(part?.text).length, 0)
     sent.tools = (Array.isArray(shape.tools) ? shape.tools : []).map((tool) => ({ name: text(tool?.name), chars: JSON.stringify(tool ?? null).length }))
   } else if (attachment?.type === 'deferred_tools_delta') {
+    sent.seen.add('mcpTools')
     for (const name of [...listOf(attachment.addedNames), ...listOf(attachment.readdedNames)]) sent.deferred.add(text(name))
     for (const name of listOf(attachment.removedNames)) sent.deferred.delete(text(name))
   } else if (attachment?.type === 'mcp_instructions_delta') {
+    sent.seen.add('mcpTools')
     listOf(attachment.addedNames).forEach((name, i) => sent.instructions.set(text(name), text(listOf(attachment.addedBlocks)[i]).length))
     for (const name of listOf(attachment.removedNames)) sent.instructions.delete(text(name))
   } else if (attachment?.type === 'skill_listing') {
+    sent.seen.add('skills')
     if (attachment.isInitial !== false) {
       sent.skills = new Map()
       sent.skillsOther = 0
@@ -285,6 +307,7 @@ function applySent(state, record) {
       else sent.skillsOther += line.length + 1
     }
   } else if (attachment?.type === 'instructions') {
+    sent.seen.add('memory')
     for (const file of listOf(attachment.files)) if (text(file?.path)) sent.memory.set(text(file.path), text(file.content).length)
   } else if (attachment?.type === 'agent_listing_delta') {
     sent.agents = (attachment.isInitial ? 0 : sent.agents) + listOf(attachment.addedLines).reduce((n, line) => n + text(line).length + 1, 0)
@@ -319,6 +342,8 @@ function fixedOf(sent) {
   fixed.mcp = new Map([...servers].map(([name, s]) => [name, { tools: s.names.size || null, chars: s.chars }]))
   fixed.skills = new Map(sent.skills)
   fixed.memory = new Map(sent.memory)
+  fixed.complete = sent.seen.has('shape')
+  fixed.recorded = new Set(fixed.complete ? FIXED_PARTS : ['system', ...[...sent.seen].filter((part) => part !== 'shape')])
   return fixed
 }
 
@@ -344,6 +369,13 @@ function applyUser(state, record, at) {
       if (!failed) countEdits(state, result, call)
     }
   }
+  if (INTERRUPTED.test(firstText(content).trim())) {
+    state.open.clear()
+    state.ending = { handedBack: true, failed: false }
+    state.handedBackAt = at
+    if (state.detail) settleCalls(state.detail.activity)
+    return
+  }
   if (!state.ending || state.ending.handedBack) state.turnStartedAt = at
   state.ending = MID_TURN
   const notice = record.isMeta ? IDLE_NOTICE.exec(firstText(content)) : null

package/lib/context-breakdown.mjs

@@ -4,8 +4,10 @@ const add = (map, key, n) => map.set(key, (map.get(key) || 0) + n)
 const sum = (values) => [...values].reduce((total, n) => total + n, 0)
 const noPending = () => ({ prompts: 0, replies: 0, tools: new Map() })
 
+export const FIXED_PARTS = ['system', 'builtInTools', 'mcpTools', 'skills', 'memory']
+
 export function emptyFixed() {
-  return { system: 0, builtInTools: 0, mcp: new Map(), skills: new Map(), memory: new Map() }
+  return { system: 0, builtInTools: 0, mcp: new Map(), skills: new Map(), memory: new Map(), recorded: new Set(), complete: false }
 }
 
 export function emptySizes() {
@@ -58,8 +60,8 @@ export function sizeCompaction(sizes) {
   sizes.callNames.clear()
 }
 
-const fixedChars = (fixed) =>
-  fixed.system + fixed.builtInTools + sum([...fixed.mcp.values()].map((m) => m.chars)) + sum(fixed.skills.values()) + sum(fixed.memory.values())
+const otherChars = (fixed) => fixed.builtInTools + sum([...fixed.mcp.values()].map((m) => m.chars)) + sum(fixed.skills.values()) + sum(fixed.memory.values())
+const fixedChars = (fixed) => fixed.system + otherChars(fixed)
 
 function spread(weights, pending, tokens) {
   const chars = pending.prompts + pending.replies + sum(pending.tools.values())
@@ -74,9 +76,13 @@ function spread(weights, pending, tokens) {
 
 const counted = (sizes) => (sizes.first && !sizes.resumed ? sizes.first.input - sizes.first.prompt : 0)
 
-function ratio(sizes) {
-  const fixed = counted(sizes)
-  return fixed > 0 && sizes.first.chars ? fixed / sizes.first.chars : 1 / CHARS_PER_TOKEN
+const measuredText = (sizes) => Boolean(sizes.first?.complete && sizes.first.chars && counted(sizes) > 0)
+
+const ratio = (sizes) => (measuredText(sizes) ? counted(sizes) / sizes.first.chars : 1 / CHARS_PER_TOKEN)
+
+function fixedNow(sizes) {
+  if (measuredText(sizes)) return Math.round(fixedChars(sizes.fixed) * ratio(sizes))
+  return counted(sizes) + Math.round((otherChars(sizes.fixed) - sizes.first.other) / CHARS_PER_TOKEN)
 }
 
 export function sizeRequest(sizes, input, at) {
@@ -84,11 +90,10 @@ export function sizeRequest(sizes, input, at) {
   if (at) sizes.lastAt = at
   if (sizes.lastInput == null) {
     if (!sizes.firstPrompt) sizes.resumed = true
-    sizes.first = { input, prompt: Math.round(sizes.firstPrompt / CHARS_PER_TOKEN), chars: fixedChars(sizes.fixed) }
+    sizes.first = { input, prompt: Math.round(sizes.firstPrompt / CHARS_PER_TOKEN), chars: fixedChars(sizes.fixed), other: otherChars(sizes.fixed), complete: sizes.fixed.complete }
     spread(sizes.weights, sizes.pending, Math.min(input, sizes.first.prompt))
   } else if (sizes.compacted) {
-    const fixed = sizes.first.chars ? Math.round(fixedChars(sizes.fixed) * ratio(sizes)) : counted(sizes)
-    sizes.weights = { prompts: 0, replies: 0, summary: Math.max(0, input - fixed), tools: new Map() }
+    sizes.weights = { prompts: 0, replies: 0, summary: Math.max(0, input - fixedNow(sizes)), tools: new Map() }
   } else if (input > sizes.lastInput) {
     spread(sizes.weights, sizes.pending, input - sizes.lastInput)
   }
@@ -129,21 +134,24 @@ export function contextBreakdown(sizes, { total, limit = null, reserved = null }
     const system = Math.round(fixedChars(sizes.fixed) / CHARS_PER_TOKEN)
     return system > 0 && system < total ? twoParts(base, sizes.weights, system) : null
   }
-  if (!sizes.first.chars) return twoParts(base, sizes.weights, fixed)
+  const { recorded } = sizes.fixed
+  if (!recorded.size || !sizes.first.chars) return twoParts(base, sizes.weights, fixed)
   const tokens = (n) => Math.round(n * ratio(sizes))
-  const { system, builtInTools, mcp, skills, memory } = sizes.fixed
+  const { builtInTools, mcp, skills, memory } = sizes.fixed
   const servers = [...mcp].map(([name, m]) => ({ name, tools: m.tools ?? null, tokens: tokens(m.chars) })).filter((m) => m.tokens > 0)
   const skillItems = [...skills].map(([name, n]) => ({ name, tokens: tokens(n) })).filter((s) => s.tokens > 0)
   const memoryItems = [...memory].map(([path, n]) => ({ path, tokens: tokens(n) })).filter((m) => m.tokens > 0)
-  const parts = [
-    { id: 'system', tokens: tokens(system), items: [] },
+  const others = [
     { id: 'builtInTools', tokens: tokens(builtInTools), items: [] },
     { id: 'mcpTools', tokens: sum(servers.map((m) => m.tokens)), items: servers.sort((a, b) => b.tokens - a.tokens) },
     { id: 'skills', tokens: sum(skillItems.map((s) => s.tokens)), items: skillItems.sort((a, b) => b.tokens - a.tokens) },
     { id: 'memory', tokens: sum(memoryItems.map((m) => m.tokens)), items: memoryItems },
-  ].filter((p) => p.tokens > 0)
-  const fixedNow = sum(parts.map((p) => p.tokens))
-  if (fixedNow >= total) return twoParts(base, sizes.weights, fixed)
-  const messages = total - fixedNow
+  ].filter((p) => recorded.has(p.id))
+  const system = measuredText(sizes) ? tokens(sizes.fixed.system) : fixedNow(sizes) - sum(others.map((p) => p.tokens))
+  if (system < 0) return twoParts(base, sizes.weights, fixed)
+  const parts = [{ id: 'system', tokens: system, items: [] }, ...others]
+  const fixedTotal = sum(parts.map((p) => p.tokens))
+  if (fixedTotal >= total) return twoParts(base, sizes.weights, fixed)
+  const messages = total - fixedTotal
   return { ...base, parts: [{ id: 'messages', tokens: messages, items: messageItems(sizes.weights, messages) }, ...parts] }
 }

package/lib/jsonl-follower.mjs

@@ -1,13 +1,27 @@
 import { parseJsonLine, readNewLines } from './fsutil.mjs'
 
-export function jsonlFollower({ empty, apply }) {
+export function jsonlFollower({ empty, apply, tail = null }) {
   const files = new Map()
 
+  async function readTail(file, size) {
+    for (let bytes = tail.bytes; ; bytes *= 4) {
+      const from = Math.max(0, size - bytes)
+      const { lines, carry } = await readNewLines(file, from, size)
+      const state = { ...empty(), offset: size, carry }
+      for (const line of from > 0 ? lines.slice(1) : lines) {
+        const record = parseJsonLine(line)
+        if (record) apply(state, record)
+      }
+      if (from === 0 || tail.enough(state)) return state
+    }
+  }
+
   async function advance(entry, file, size) {
     if (!entry.state || size < entry.state.offset) entry.state = { ...empty(), offset: 0, carry: Buffer.alloc(0) }
     const state = entry.state
     if (size === state.offset) return state
     try {
+      if (tail && state.offset === 0 && size > tail.bytes) return (entry.state = await readTail(file, size))
       const { lines, carry } = await readNewLines(file, state.offset, size, state.carry)
       state.offset = size
       state.carry = carry

package/lib/opencode-store.mjs

@@ -20,6 +20,7 @@ import {
   openTool,
   planItems,
   planSummary,
+  relativePath,
   sampleList,
   samplePoint,
   settleCalls,
@@ -130,9 +131,10 @@ export function opencodeStore({ id, name, dbPath, watchDirs, limitsFile, continu
     return sessions
   }
 
-  async function sessionDetail(key) {
+  async function sessionDetail(key, { filesOnly = false } = {}) {
     const prefix = `${id}:`
     const sessionId = String(key).startsWith(prefix) ? String(key).slice(prefix.length) : ''
+    if (filesOnly) return sessionId ? { id: `${id}:${sessionId}`, sessionId, files: facts.get(`v1:${sessionId}`)?.value.files ?? null } : null
     const file = sessionId ? await dbPath() : ''
     if (!file) return null
     const context = { ...options, facts, seen: new Set(), byModel: new Map(), at: now() }
@@ -517,6 +519,7 @@ function legacyTurn(db, row, context) {
   )
   let last = null
   let lastAssistant = ''
+  const changed = new Set()
   for (const message of db.prepare('SELECT id, time_created, data FROM message WHERE session_id = ? ORDER BY time_created, rowid').all(row.id)) {
     const data = parse(message.data)
     last = data
@@ -531,6 +534,7 @@ function legacyTurn(db, row, context) {
         for (const diff of data.summary.diffs) {
           turn.lines.added += number(diff?.additions)
           turn.lines.removed += number(diff?.deletions)
+          if (text(diff?.file)) changed.add(relativePath(text(diff.file), text(row.directory)))
         }
       }
       continue
@@ -546,6 +550,7 @@ function legacyTurn(db, row, context) {
       samplePoint(turn.contextSample, turn.context)
     }
   }
+  turn.files = changed.size || !context.liveSummary ? [...changed].map((file) => ({ path: file })) : null
   const usage = usageFromColumns(row)
   if (usage) {
     turn.tokens = usage.tokens
@@ -633,12 +638,14 @@ function currentSample(db, sessionId, before) {
 
 function currentTurn(db, row, parts, context) {
   const before = context.facts.get(`v2:${row.id}`)?.value
-  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, tool: null, plan: null, turnStartedAt: 0, ...currentSample(db, row.id, before) }
+  const sampled = currentSample(db, row.id, before)
+  const kept = sampled.contextSample === before?.contextSample ? before : null
+  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, tool: null, plan: null, turnStartedAt: 0, ...sampled }
   turn.prompts = number(db.prepare(`SELECT COUNT(*) AS n FROM session_message WHERE session_id = ? AND type = 'user'`).get(row.id)?.n)
   const lastUser = db.prepare(`SELECT time_created FROM session_message WHERE session_id = ? AND type = 'user' ORDER BY seq DESC LIMIT 1`).get(row.id)
   turn.turnStartedAt = number(row.time_busy) || number(lastUser?.time_created)
   turn.firstPrompt = text(parse(db.prepare(`SELECT data FROM session_message WHERE session_id = ? AND type = 'user' ORDER BY seq ASC LIMIT 1`).get(row.id)?.data).text).trim()
-  const assistant = db.prepare(`SELECT id, data FROM session_message WHERE session_id = ? AND type = 'assistant' ORDER BY seq DESC LIMIT 1`).get(row.id)
+  const assistant = db.prepare(`SELECT id, seq, data FROM session_message WHERE session_id = ? AND type = 'assistant' ORDER BY seq DESC LIMIT 1`).get(row.id)
   const latest = parse(assistant?.data)
   turn.model = text(latest.model?.id)
   turn.provider = text(latest.model?.providerID)
@@ -660,36 +667,68 @@ function currentTurn(db, row, parts, context) {
   const outcome = text(row.idle_outcome) || (last?.type === 'idle' ? text(parse(last.data).outcome) : '')
   turn.failed = !busy && outcome === 'failed'
   turn.errorText = turn.failed && last?.type === 'idle' ? text(parse(last.data).error?.message) : ''
-  const tools = currentTools(db, row.id, assistant, parts, text(row.directory))
+  const tools = currentTools(db, row.id, assistant, parts, text(row.directory), kept)
+  turn.planSeq = tools.planSeq
+  turn.olderTodos = tools.olderTodos
+  turn.planRow = tools.planRow
+  turn.rowTodos = tools.rowTodos
   if (busy) turn.tool = tools.running
   turn.plan = tools.todos
   return turn
 }
 
-function currentTools(db, sessionId, assistant, parts, cwd) {
+const completedTodos = (parts) => {
+  const found = parts.find((p) => p?.name === TODO_TOOL && p.state?.status === 'completed' && Array.isArray(p.state?.input?.todos))
+  return found ? found.state.input.todos.map((t) => ({ content: text(t?.content), status: text(t?.status) })) : null
+}
+
+function rowTodos(db, sessionId, assistant, before) {
+  const newest = text(assistant?.id)
+  const from = before?.planRow ?? -1
+  let older = before?.rowTodos ?? null
+  const rows = db
+    .prepare(`SELECT data FROM session_part WHERE session_id = ? AND type = 'tool' AND rowid > ? AND message_id != ? AND data LIKE ? ORDER BY rowid DESC`)
+    .all(sessionId, from, newest, `%"${TODO_TOOL}"%`)
+  for (const row of rows) {
+    const found = completedTodos([parse(row.data)])
+    if (found) {
+      older = found
+      break
+    }
+  }
+  const top = db.prepare('SELECT MAX(rowid) AS row FROM session_part WHERE session_id = ? AND message_id != ?').get(sessionId, newest)
+  return { rowTodos: older, planRow: top?.row == null ? from : number(top.row) }
+}
+
+function inlineTodos(db, sessionId, assistant, before) {
+  const newest = number(assistant?.seq)
+  let older = before?.olderTodos ?? null
+  const rows = db
+    .prepare(`SELECT data FROM session_message WHERE session_id = ? AND type = 'assistant' AND seq > ? AND seq < ? AND data LIKE ? ORDER BY seq DESC`)
+    .all(sessionId, before?.planSeq ?? -1, newest, `%"${TODO_TOOL}"%`)
+  for (const row of rows) {
+    const found = completedTodos(list(parse(row.data).content).filter((c) => c?.type === 'tool').reverse())
+    if (found) {
+      older = found
+      break
+    }
+  }
+  return { olderTodos: older, planSeq: assistant ? newest - 1 : before?.planSeq ?? -1 }
+}
+
+function currentTools(db, sessionId, assistant, parts, cwd, before = null) {
   const result = { running: null, todos: null }
   let latest = []
-  let recent = []
   if (parts && assistant) {
-    latest = db.prepare(`SELECT data FROM session_part WHERE session_id = ? AND message_id = ? AND type = 'tool'`).all(sessionId, assistant.id).map((p) => parse(p.data))
-  }
-  if (parts) {
-    recent = db
-      .prepare(`SELECT data FROM session_part WHERE session_id = ? AND type = 'tool' AND data LIKE ? ORDER BY rowid DESC LIMIT 20`)
-      .all(sessionId, `%"${TODO_TOOL}"%`)
-      .map((p) => parse(p.data))
+    latest = db.prepare(`SELECT data FROM session_part WHERE session_id = ? AND message_id = ? AND type = 'tool' ORDER BY rowid`).all(sessionId, assistant.id).map((p) => parse(p.data))
   }
   if (!latest.length && assistant) latest = list(parse(assistant.data).content).filter((c) => c?.type === 'tool')
-  if (!recent.length) {
-    recent = db
-      .prepare(`SELECT data FROM session_message WHERE session_id = ? AND type = 'assistant' AND data LIKE ? ORDER BY seq DESC LIMIT 20`)
-      .all(sessionId, `%"${TODO_TOOL}"%`)
-      .flatMap((m) => list(parse(m.data).content).filter((c) => c?.type === 'tool').reverse())
-  }
   for (const part of latest) {
     if (OPEN_TOOL.has(part.state?.status)) result.running = openTool(text(part.name), number(part.time?.ran) || number(part.time?.created), part.state?.input, cwd)
   }
-  const todos = recent.find((p) => p.name === TODO_TOOL && p.state?.status === 'completed' && Array.isArray(p.state?.input?.todos))
-  if (todos) result.todos = todos.state.input.todos.map((t) => ({ content: text(t?.content), status: text(t?.status) }))
+  const rows = parts ? rowTodos(db, sessionId, assistant, before) : { rowTodos: null, planRow: -1 }
+  const inline = inlineTodos(db, sessionId, assistant, before)
+  Object.assign(result, rows, inline)
+  result.todos = completedTodos([...latest].reverse()) ?? rows.rowTodos ?? inline.olderTodos
   return result
 }

package/lib/telemetry-fields.mjs

@@ -160,6 +160,8 @@ export function keepText(list, kind, { id = null, at, text: value }) {
   return keepNewest(list, { id, at, text: body }, max)
 }
 
+export const wordsFull = (words) => words.replies.length >= DETAIL_LIMITS.replies && words.thoughts.length >= DETAIL_LIMITS.thoughts
+
 export const textList = (list) => (list ? list.map(({ at, text: value }) => ({ at, text: value })) : null)
 
 export function joinedText(blocks, type, field = type) {
@@ -219,6 +221,8 @@ export function fileList(files, cwd) {
     .sort((a, b) => b.added + b.removed - (a.added + a.removed) || a.path.localeCompare(b.path))
 }
 
+export const filePaths = (files, cwd) => [...files.values()].map((f) => ({ path: relativePath(f.path, cwd) }))
+
 export const emptyActivity = () => ({ calls: [], tools: new Map() })
 
 export function startCall(activity, { id = '', name, target = '', input = null, path = null, line = null, startedAt, running = true }) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@threadcrumbs/common",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "type": "module",
   "description": "Code the Threadcrumbs apps share, starting with the readers for each coding-agent harness.",
   "license": "SEE LICENSE IN LICENSE.md",
@@ -25,7 +25,16 @@
     "./license": "./license/index.mjs",
     "./license/store": "./license/store.mjs",
     "./orgs": "./orgs/index.mjs",
-    "./lib/*": "./lib/*.mjs"
+    "./lib/*": "./lib/*.mjs",
+    "./ui/status": "./ui/status.mjs",
+    "./ui/status.css": "./ui/status.css",
+    "./ui/icons": "./ui/icons.mjs",
+    "./ui/where": "./ui/where.mjs",
+    "./ui/where.css": "./ui/where.css",
+    "./ui/gauge": "./ui/gauge.mjs",
+    "./ui/gauge.css": "./ui/gauge.css",
+    "./ui/theme.css": "./ui/theme.css",
+    "./ui/fonts.css": "./ui/fonts.css"
   },
   "files": [
     "NOTICES.md",
@@ -34,9 +43,15 @@
     "license/",
     "lib/",
     "orgs/",
-    "telemetry/"
+    "telemetry/",
+    "ui/"
   ],
   "scripts": {
     "test": "node --test \"test/**/*.test.mjs\""
+  },
+  "devDependencies": {
+    "@fontsource-variable/inter": "^5.3.0",
+    "@fontsource-variable/inter-tight": "^5.3.0",
+    "@fontsource-variable/jetbrains-mono": "^5.3.0"
   }
 }

package/telemetry/README.md

@@ -158,6 +158,15 @@ Again, a `null` field means the harness doesn't record it. The shared helpers fo
 (`startCall`, `endCall`, `toolTarget`, `keepNewest`, `fileList`, and the limits) are in
 `../lib/telemetry-fields.mjs`.
 
+`sessionDetail(id, { filesOnly: true })` returns only `{ id, sessionId, files }`, with each file
+as `{ path }`, from what the session scan already holds. It's for finding other threads that
+changed the same files, so it never opens the readers that serve an open thread.
+
+The readers that serve an open thread (thoughts and replies for Claude Code, Codex, Cursor, and
+Antigravity) are kept for the last three sessions opened. Claude Code's and Codex's read the
+transcript from its end first, in growing steps, until they have the newest 50 replies, and then
+follow it forwards.
+
 ### Context breakdown
 
 `contextBreakdown` splits the context into parts, so an app can show what fills it.
@@ -170,8 +179,8 @@ Again, a `null` field means the harness doesn't record it. The shared helpers fo
   them aren't read, so an app should call it the default. Free space is `limit - total -
   reserved`.
 - **`parts`** are `[{ id, tokens, items }]` in this order: `messages`, `system`,
-  `builtInTools`, `mcpTools`, `skills`, `memory`. A part a harness doesn't let us size is left
-  out, and its tokens stay in `system`.
+  `builtInTools`, `mcpTools`, `skills`, `memory`. A part the harness records is sent even at 0
+  tokens; one it doesn't record is left out, and its tokens stay in `system`.
   - `messages` items: `{ id: 'prompts' }`, `{ id: 'replies' }`, `{ id: 'summary' }` (from the
     last compaction), and `{ id: 'tool', name }` for each tool's calls and results.
   - `mcpTools` items: `{ name, tools }` per server, `tools` a count or `null`.
@@ -183,6 +192,11 @@ Again, a `null` field means the harness doesn't record it. The shared helpers fo
   - That gives a characters-per-token ratio for the text of each fixed part (system prompt,
     tool definitions, MCP servers, skills, memory files), so each part is its text length at
     that ratio. A part added later counts at the same ratio.
+  - The ratio is used only when the system prompt and tool definitions were recorded, as in
+    Claude Code's `api-request-shape`. Otherwise it would spread their unrecorded text over the
+    parts that were, so each recorded part is its text at 4 characters a token, and `system` is
+    the rest of the fixed count. That's always the case for Codex, whose built-in tool
+    definitions aren't written.
   - `messages` is the rest of the total. Each request's growth over the one before is split
     among the prompts, replies, and tool calls and results since then, by text length. After a
     compaction, the next request's growth over the fixed parts is the summary.
@@ -200,8 +214,8 @@ Again, a `null` field means the harness doesn't record it. The shared helpers fo
   - Codex: the rollout's base instructions and developer messages, its AGENTS.md messages, and
     its `additional_tools` items. Its built-in tool definitions aren't written, so they're in
     `system`.
-- **Read only for an open thread,** by the same second reader as thoughts and replies. It keeps
-  numbers and names, never the text.
+- **Its sizes are kept by the session scan,** which already reads every record, as numbers and
+  names only, never the text, so opening a thread doesn't read its transcript again.
 
 ### Tool kinds
 

package/telemetry/antigravity.mjs

@@ -252,9 +252,10 @@ export function antigravity({
     return sessions
   }
 
-  async function sessionDetail(key) {
+  async function sessionDetail(key, { filesOnly = false } = {}) {
     const id = String(key).replace(/^antigravity:/, '')
     if (!known.has(id)) return null
+    if (filesOnly) return { id: `antigravity:${id}`, sessionId: id, files: null }
     const sessionDir = path.join(brainDir, id)
     const found = await transcriptOf(sessionDir)
     const state = (found && (await transcripts.read(found.file, found.stat).catch(() => null))) || emptyTranscript()