@threadcrumbs/common 0.1.3 → 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,
@@ -10,6 +10,7 @@ import {
   clipBlock,
   diffHunk,
   emptyActivity,
+  emptySample,
   endCall,
   fileList,
   firstChange,
@@ -20,9 +21,11 @@ import {
   openTool,
   patchLines,
   planItems,
+  samplePoint,
   settleCalls,
   startCall,
   textList,
+  wordsFull,
   toolFile,
   toolInput,
   toolTarget,
@@ -32,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'])
@@ -40,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 : '')
@@ -70,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) {
@@ -78,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)
@@ -115,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
@@ -176,6 +196,7 @@ function emptyState(sidechain, detail, words, sizes) {
     cost: null,
     plan: null,
     prompts: 0,
+    contextSample: emptySample(),
     uuids: new Set(),
   }
 }
@@ -250,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
@@ -282,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)
@@ -316,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
 }
 
@@ -341,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
@@ -440,6 +475,7 @@ function applyAssistant(state, record, at) {
     for (const key of Object.keys(next)) state.tokens[key] += next[key] - (previous?.[key] || 0)
     state.usageById.set(message.id, next)
     state.context = next.input + next.cacheRead + next.cacheWrite + next.output
+    samplePoint(state.contextSample, state.context, { update: Boolean(previous) })
     const cost = requestCost(message.model, usage)
     let added = null
     if (cost != 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

@@ -10,6 +10,7 @@ import {
   clip,
   clipBlock,
   emptyActivity,
+  emptySample,
   endCall,
   fileList,
   joinedText,
@@ -19,6 +20,9 @@ import {
   openTool,
   planItems,
   planSummary,
+  relativePath,
+  sampleList,
+  samplePoint,
   settleCalls,
   startCall,
   text,
@@ -127,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() }
@@ -458,6 +463,7 @@ function session(context, row, turn, extra) {
     tool: turn.open && turn.tool ? toolNow(turn.tool) : null,
     tokens: turn.tokens ? { ...turn.tokens } : null,
     context: turn.context ? { used: turn.context, limit: context.byModel.get(`${turn.provider}/${turn.model}`) || 0 } : null,
+    contextHistory: sampleList(turn.contextSample, turn.context),
     costUsd: turn.cost,
     lines: extra.lines,
     plan: planSummary(extra.plan),
@@ -504,7 +510,7 @@ function legacySessions(db, tables, context) {
 }
 
 function legacyTurn(db, row, context) {
-  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, lines: null, tool: null, turnStartedAt: 0 }
+  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, contextSample: emptySample(), lines: null, tool: null, turnStartedAt: 0 }
   const typed = new Set(
     db
       .prepare(`SELECT message_id FROM part WHERE session_id = ? AND data LIKE '%"type":"text"%' AND data NOT LIKE '%"synthetic":true%'`)
@@ -513,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
@@ -527,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
@@ -537,8 +545,12 @@ function legacyTurn(db, row, context) {
     if (data.providerID) turn.provider = text(data.providerID)
     if (data.variant) turn.effort = text(data.variant)
     if (data.cost != null) turn.cost = (turn.cost || 0) + number(data.cost)
-    if (number(data.tokens?.output) > 0) turn.context = windowOf(data.tokens)
+    if (number(data.tokens?.output) > 0) {
+      turn.context = windowOf(data.tokens)
+      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
@@ -605,13 +617,35 @@ function currentSessions(db, tables, context) {
   return out
 }
 
+function currentSample(db, sessionId, before) {
+  let { contextSample: sample, contextSeq: seq = -1, contextCount: count = 0 } = before || {}
+  const kept = sample && db.prepare(`SELECT COUNT(*) AS n, MAX(seq) AS top FROM session_message WHERE session_id = ? AND type = 'assistant' AND seq <= ?`).get(sessionId, seq)
+  if (!kept || number(kept.n) !== count || (count && number(kept.top) !== seq)) {
+    sample = emptySample()
+    seq = -1
+    count = 0
+  }
+  const newer = db.prepare(`SELECT seq, data FROM session_message WHERE session_id = ? AND type = 'assistant' AND seq > ? ORDER BY seq`).all(sessionId, seq)
+  for (const [i, message] of newer.entries()) {
+    const data = parse(message.data)
+    if (i === newer.length - 1 && !data.time?.completed) break
+    if (number(data.tokens?.output) > 0) samplePoint(sample, windowOf(data.tokens))
+    seq = number(message.seq)
+    count++
+  }
+  return { contextSample: sample, contextSeq: seq, contextCount: count }
+}
+
 function currentTurn(db, row, parts, context) {
-  const turn = { busy: false, failed: false, prompts: 0, firstPrompt: '', model: '', provider: '', effort: '', tokens: null, cost: null, context: 0, tool: null, plan: null, turnStartedAt: 0 }
+  const before = context.facts.get(`v2:${row.id}`)?.value
+  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)
@@ -633,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 }) {
@@ -316,3 +320,37 @@ export function nextPlan(plan, tool, input) {
   }
   return next
 }
+
+export const CONTEXT_POINTS = 24
+
+export const emptySample = () => ({ stride: 1, seen: 0, points: [], newest: null, newestKept: false })
+
+export function samplePoint(sample, value, { update = false } = {}) {
+  const point = Math.round(number(value))
+  if (point <= 0) return
+  if (update && sample.newest != null) {
+    if (sample.newestKept) sample.points[sample.points.length - 1] = point
+    sample.newest = point
+    return
+  }
+  sample.newestKept = sample.seen % sample.stride === 0
+  if (sample.newestKept) {
+    sample.points.push(point)
+    if (sample.points.length >= CONTEXT_POINTS * 2) {
+      sample.points = sample.points.filter((_, i) => i % 2 === 0)
+      sample.stride *= 2
+      sample.newestKept = false
+    }
+  }
+  sample.seen++
+  sample.newest = point
+}
+
+export function sampleList(sample, current) {
+  if (!sample || !(current > 0)) return null
+  const now = Math.round(current)
+  const older = sample.newestKept && sample.newest === now ? sample.points.slice(0, -1) : sample.points
+  const room = CONTEXT_POINTS - 1
+  const picked = older.length <= room ? older : Array.from({ length: room }, (_, i) => older[Math.round((i * (older.length - 1)) / (room - 1))])
+  return [...picked, now]
+}