thinkpool-pair 0.7.155 → 0.7.156

package/README.md

@@ -153,5 +153,22 @@ Provider config is stored in `~/.thinkpool-pair/provider.json` (mode 0600) and
 applies to every bridge on the machine. Restart the bridge (or its launchd
 service) after changing it — the choice is read once at startup.
 
+### Context meter for non-Claude models
+
+The context-usage meter (`ctx N%` in the room) is computed by the Agent SDK from
+the model id it thinks it's talking to — for a non-Claude model bridged in over
+an Anthropic-compatible endpoint, that assumed window is wrong, so the meter can
+run past 100%. The bridge corrects it for common models automatically (GLM-4.5/4.6,
+DeepSeek V3.x, Kimi K2, Qwen3-Coder — matched by model id).
+
+For any model not in that list, set the real window explicitly per bridge:
+
+```bash
+export TP_CONTEXT_MAX=131072   # your model's context window, in tokens
+```
+
+`TP_CONTEXT_MAX` overrides the built-in map (and applies even to Claude ids if
+you set it). Unset it to fall back to the automatic correction.
+
 Public anon creds are embedded (the same ones the web app ships). Override with
 `TP_SUPABASE_URL` / `TP_SUPABASE_ANON` if needed. Set `TP_NAME` to label yourself.

package/bridge.mjs

@@ -39,7 +39,7 @@ import { randomUUID } from 'node:crypto'
 import { createClient } from '@supabase/supabase-js'
 import { createSdkMcpServer, tool } from '@anthropic-ai/claude-agent-sdk'
 import { z } from 'zod'
-import { startClaudeSession, oneShotSummary } from './claude-session.mjs'
+import { startClaudeSession } from './claude-session.mjs'
 import { FLOW_CONDUCTOR_PROMPT, FLOW_LANE_PROMPT, buildConductorEnv, assembleCrossWaveContext, buildLanePrompt } from './flow-conductor.mjs'
 import { normalizePlanOutput, laneModelFor } from './flow-task-graph.mjs'   // FL-B1 — validate the conductor's submit_flow_plan task-graph; laneModelFor — per-slice model tier (2026-07-03-flow-lane-model-tiers)
 // S1 (context-offload) — durable digest store. mark_flow_done digests a closed slice in;
@@ -84,7 +84,7 @@ const flowRedispatch = new Map()
 const flowBudgets = new Map()
 import { formatPeek, PEEK, siblingsOf, resolveSibling, crossPostDecision, CROSSPOST, spawnDecision, SPAWN, CROSSROOM, formatPairRoster, crossRoomPostDecision, formatRoomNow } from './cross-terminal.mjs'
 import { turnInFlight } from './update-gate.mjs'
-import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq, loadSummary, saveSummary } from './session-store.mjs'
+import { saveSession, flushSession, deleteSession, loadAll, canResume, loadPtyId, savePtyId, loadNames, saveNames, appendDurableEvents, seedDurableEvents, readDurablePage, readDurableOldestSeq } from './session-store.mjs'
 import { stampEvent, makeSeqCounter, maxSeq, seqable, capReplayEvents, chunkReplayEvents, boundEventForBroadcast, inlineImageBlocks, usageReportLine } from './event-id.mjs'
 import { makeThrottledTrack } from './presence.mjs'
 
@@ -2465,94 +2465,6 @@ channel
     saveNames(room, termNames)
     announce()
   })
-  // Session Info panel (2026-07-02, plain-English recap 2026-07-02) — a cheap one-shot
-  // recap on demand. Writes a plain-English "Done so far" / "Working on now" bullet
-  // summary (Markdown) of what the whole session accomplished + what's live — NOT a
-  // per-terminal technical list (Max's ask: clean, readable, no jargon/terminal names).
-  // Runs on the room's own subscription auth via oneShotSummary (cheap haiku →
-  // provider-default fallback). Never auto — only on the panel button. The web caches
-  // the result in React state (no re-charge on re-open within a page load).
-  .on('broadcast', { event: 'code-summarize' }, async ({ payload }) => {
-    const by = payload?.by || null
-    // Peek — any device opening the panel fetches the cached recap (cross-device +
-    // cross-restart persistence) WITHOUT spending a model call. No cache → silent.
-    if (payload?.peek) {
-      const cached = loadSummary(room)
-      if (cached && cached.text) bcast('code-summary', { status: 'done', ...cached })
-      return
-    }
-    bcast('code-summary', { status: 'generating', by })
-    try {
-      // Pull assistant/user text out of a transcript-event array, keep the tail.
-      const logDigest = (events, max = 1200) => {
-        const parts = []
-        for (const e of (events || [])) {
-          if (e?.kind === 'assistant') { for (const b of (e.blocks || [])) if (b?.type === 'text' && b.text) parts.push(b.text) }
-          else if (e?.kind === 'you' && e.text) parts.push(`user: ${e.text}`)
-        }
-        return parts.join('\n').replace(/\n{3,}/g, '\n\n').slice(-max)
-      }
-      // LIVE structured terminals — named, doing/done, with a recent digest.
-      const live = []
-      let env = null, cwd = null
-      for (const [id, e] of sessions) {
-        if (e.kind !== 'structured') continue
-        live.push({ name: termNames[id] || 'Terminal', status: e.session?.turnActive ? 'working' : 'done', digest: logDigest(e.log, 1100) })
-        if (!env) { env = { ...process.env }; cwd = e.cwd || process.cwd() }
-      }
-      // CLOSED terminals — named but not live. Aggregate only; cap the read to bound cost.
-      const liveIdSet = new Set(sessions.keys())
-      const closedIds = Object.keys(termNames).filter(id => !liveIdSet.has(id))
-      const closedDigests = []
-      for (const id of closedIds.slice(0, 4)) {
-        try {
-          const page = readDurablePage(room, id, Number.MAX_SAFE_INTEGER, 30)
-          const evs = Array.isArray(page) ? page : (Array.isArray(page?.events) ? page.events : [])
-          const d = logDigest(evs, 450)
-          if (d) closedDigests.push(d)
-        } catch { /* no retained detail for this closed lane */ }
-      }
-      if (!live.length && !closedIds.length) { bcast('code-summary', { status: 'error', error: 'Nothing to summarize yet.', by }); return }
-
-      const liveBlock = live.length
-        ? live.map(t => `LIVE TERMINAL "${t.name}" [${t.status}]:\n${t.digest || '(no recent activity)'}`).join('\n\n')
-        : '(no live terminals)'
-      const closedBlock = closedIds.length
-        ? `\n\nThere are also ${closedIds.length} CLOSED terminal(s). Recent excerpts (do NOT name them individually):\n${(closedDigests.join('\n---\n') || '(no retained detail)').slice(0, 1400)}`
-        : ''
-
-      const prompt = `Write a short, friendly recap of this coding session for someone non-technical who just wants to know what's going on. Plain English only — no jargon, no file names, no branch names, no terminal names or IDs, no code, no counts of terminals. Explain what the work MEANS and why it matters, not the mechanics.
-
-Output ONLY this Markdown shape, nothing else:
-
-**Done so far**
-- <one plain-English thing that got finished>
-- <another>
-
-**Working on now**
-- <what's actively being worked on, in plain English>
-
-Rules:
-- Merge ALL the finished work — live and closed terminals alike — into "Done so far". Combine similar items; do NOT organise by terminal or list them. Aim for 3–6 bullets.
-- Put only genuinely in-progress work under "Working on now". If nothing is active, write exactly: "- Nothing in progress right now — everything's wrapped up."
-- Each bullet is one clear sentence, ~16 words max, no trailing period, and no technical term a normal person wouldn't understand.
-
-Here's the raw session activity to summarize:
-
-${liveBlock}${closedBlock}
-
-Recap:`
-
-      const res = await oneShotSummary({ prompt, env: env || process.env, cwd: cwd || process.cwd() })
-      if (!res || !res.text) { bcast('code-summary', { status: 'error', error: 'Summary model unavailable on this provider.', by }); return }
-      const summary = { text: res.text, model: res.model, generatedAt: Date.now() }
-      try { saveSummary(room, summary) } catch { /* cache is best-effort */ }
-      bcast('code-summary', { status: 'done', ...summary, by })
-      process.stderr.write(`\n  ◆ session summary generated (${res.model}) for ${by || 'someone'}.\n`)
-    } catch (e) {
-      bcast('code-summary', { status: 'error', error: String(e?.message || e).slice(0, 140), by })
-    }
-  })
   .on('broadcast', { event: 'who' }, announce)
   .subscribe(status => {
     if (status === 'SUBSCRIBED') {

package/claude-session.mjs

@@ -17,6 +17,7 @@ import { query } from '@anthropic-ai/claude-agent-sdk'
 import { sanitizeSession } from './transcript-sanitize.mjs'
 import { reviewGatePreToolDecision } from './flow-review-gate.mjs'
 import { crossPostNeedsCard } from './cross-terminal.mjs'
+import { correctContext } from './context-windows.mjs'
 
 // ── risk classification — the accent/danger tier of the permission card ──
 // low (read-only) · medium (writes/runs) · network (leaves the machine) ·
@@ -145,48 +146,6 @@ const TP_ROOM_REMINDER = [
   'Verify before claiming done — show runtime evidence you produced, not "should work, go test it".',
 ].join(' ')
 
-// ── One-shot summary (2026-07-02, Session Info panel) ────────────────────────
-// A bare, cheap, cold model call — same shape as the haikuSuggest fallback: runs
-// on the room's own subscription auth (env carries the OAuth — no API key), NO
-// settingSources / MCP / tools, maxTurns 1. Used by the bridge's code-summarize
-// handler to write a session recap on demand. Model fallback (Max's ask): prefer a
-// cheap haiku-class model; if the provider (GLM / OpenRouter / custom base-url) has
-// no such model, retry with the provider default. Returns { text, model } or null.
-export async function oneShotSummary({ prompt, env, cwd, timeoutMs = 25000 }) {
-  const attempt = async (model) => {
-    const ac = new AbortController()
-    const t = setTimeout(() => { try { ac.abort() } catch { /* noop */ } }, timeoutMs)
-    try {
-      const hq = query({
-        prompt,
-        options: {
-          ...(model ? { model } : {}),
-          ...(cwd ? { cwd } : {}),
-          env,
-          maxTurns: 1,
-          permissionMode: 'bypassPermissions',
-          settingSources: [],
-          strictMcpConfig: true,
-          mcpServers: {},
-          abortController: ac,
-        },
-      })
-      let out = ''
-      for await (const mm of hq) {
-        if (mm.type === 'assistant') for (const b of (mm.message?.content || [])) if (b.type === 'text') out += b.text
-        if (mm.type === 'result') break
-      }
-      return out.trim()
-    } finally { clearTimeout(t) }
-  }
-  // Prefer cheap haiku; fall back to the provider's default model if it's absent.
-  try { const out = await attempt('claude-haiku-4-5'); if (out) return { text: out, model: 'claude-haiku-4-5' } }
-  catch { /* provider has no haiku — fall through to default */ }
-  try { const out = await attempt(undefined); if (out) return { text: out, model: 'default' } }
-  catch { /* provider default also failed */ }
-  return null
-}
-
 export function startClaudeSession({ cwd, model, resume, env, mode: initialMode = 'default', onEvent, requestPermission, mcpServers, crossPostGate, crossRoomPostGate, didSpawnTarget = null, rolePrompt, blockSubagents = false, onSubmitPlan = null, onLaneDone = null, onReviewVerdict = null, reviewGate = null, lazy = false, roomContext = null }) {
   // Per-turn reminder + live ROOM NOW tail. roomContext (bridge-supplied) returns the
   // room's CURRENT state — sibling lanes, active git worktrees — or null. The static
@@ -788,7 +747,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
               ;(async () => {
                 try {
                   const c = await q?.getContextUsage?.()
-                  if (c) { emit({ kind: 'usage', ctx: { used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model } }); if (c.model) curModel = c.model }
+                  if (c) { emit({ kind: 'usage', ctx: correctContext({ used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model }) }); if (c.model) curModel = c.model }
                 } catch { /* control req may be unavailable */ }
               })()
               break
@@ -932,7 +891,7 @@ export function startClaudeSession({ cwd, model, resume, env, mode: initialMode
               let ctx = null
               try {
                 const c = await q?.getContextUsage?.()
-                if (c) { ctx = { used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model }; if (c.model) curModel = c.model }
+                if (c) { ctx = correctContext({ used: c.totalTokens, max: c.maxTokens, pct: Math.round(c.percentage), model: c.model }); if (c.model) curModel = c.model }
               } catch { /* control req may be unavailable */ }
               const u = m.usage || {}
               emit({ kind: 'usage', costUsd: m.total_cost_usd ?? null, tokens: (u.input_tokens || 0) + (u.output_tokens || 0), ctx })

package/context-windows.mjs

@@ -0,0 +1,101 @@
+/* ─────────────────────────────────────────────────────────────
+   context-windows — correct the /code context meter for non-Claude BYOK models.
+
+   The Claude Agent SDK computes its context-usage meter
+   (getContextUsage → { totalTokens, maxTokens, percentage }) from the model
+   STRING it believes it is talking to. When a user bridges a NON-Claude model
+   in over an Anthropic-compatible endpoint (ANTHROPIC_BASE_URL — GLM, DeepSeek,
+   Kimi, Qwen, … via OpenRouter or a provider's own compat endpoint), the SDK's
+   maxTokens is for the WRONG model, so the meter fills at the wrong rate and can
+   shoot past 100% (Max, 2026-07-04: GLM-4.6 "runs up to 100 and goes past pretty
+   fast").
+
+   This is a DISPLAY-ONLY correction applied on the bridge's EMIT path: we
+   override the emitted { max, pct, over } using the real window for the reported
+   model id. The SDK's own context management is untouched — no behavior change,
+   no racy control request (H42-safe by construction).
+
+   Numbers are the provider-HEADLINED context windows (verified per row below).
+   The meter is inherently approximate, so we match what each provider's own docs
+   advertise rather than power-of-two token counts.
+   ───────────────────────────────────────────────────────────── */
+
+// id substring (case-insensitive) → context window in tokens.
+// Ordered MOST-SPECIFIC first (glm-4.6 before glm-4.5) — first hit wins.
+// Sources verified 2026-07-04:
+//   glm-4.6      200K — https://openrouter.ai/z-ai/glm-4.6  ·  https://docs.z.ai
+//   glm-4.5      128K — https://github.com/zai-org/GLM-4.5 (README)
+//   deepseek v3.x 128K — https://api-docs.deepseek.com (deepseek-chat/-reasoner, V3.1)
+//   kimi-k2      256K — https://huggingface.co/moonshotai/Kimi-K2-Instruct-0905
+//   qwen3-coder  256K — https://huggingface.co/Qwen/Qwen3-Coder-Next (native)
+const KNOWN_WINDOWS = [
+  { match: 'glm-4.6',     max: 200_000 },
+  { match: 'glm-4.5',     max: 128_000 },
+  { match: 'deepseek',    max: 128_000 },
+  { match: 'kimi-k2',     max: 256_000 },
+  { match: 'qwen3-coder', max: 256_000 },
+]
+
+// A Claude model id — the ONLY ids whose SDK-reported window we trust verbatim.
+// Everything else is a candidate for correction. (Kept broad on purpose: any
+// real Claude id matches, so the 1M/200k Claude paths never regress.)
+export function isClaudeModel(id) {
+  return /claude|anthropic|opus|sonnet|haiku/i.test(String(id || ''))
+}
+
+// Look up a corrected window (tokens) for a model id. Returns null if unknown.
+export function windowForModel(modelId) {
+  const id = String(modelId || '').toLowerCase()
+  if (!id) return null
+  for (const w of KNOWN_WINDOWS) {
+    if (id.includes(w.match)) return w.max
+  }
+  return null
+}
+
+// Parse TP_CONTEXT_MAX (a positive integer token count) from the environment.
+// Per-bridge override for models not in the map. null if unset/non-numeric/<=0.
+export function envContextMax(env = process.env) {
+  const raw = env?.TP_CONTEXT_MAX
+  if (raw == null || raw === '') return null
+  const n = Number(raw)
+  return Number.isFinite(n) && n > 0 ? Math.floor(n) : null
+}
+
+// Correct a raw ctx object from the SDK's getContextUsage().
+//
+//   raw: { used, max, pct, model }   (any field may be missing)
+//   env: process.env-like            (for the TP_CONTEXT_MAX override)
+//
+// Returns a NEW ctx object. Precedence:
+//   1. TP_CONTEXT_MAX override — wins for ANY model (incl. ids not in the map).
+//   2. A known non-Claude window from the map.
+//   3. Otherwise passthrough — Claude models and unknown ids keep the SDK's max.
+// When a correction applies, max is replaced, pct is recomputed and clamped to
+// 0..100, and `over: true` is set when used exceeds the corrected window.
+// In every case pct is clamped so a lying >100% never reaches the UI.
+export function correctContext(raw, env = process.env) {
+  if (!raw || typeof raw !== 'object') return raw
+  const used = Number(raw.used)
+  const override = envContextMax(env)
+  // The map fires only for non-Claude ids (point 4: Claude untouched); the
+  // env override is explicit and deliberate, so it applies even to Claude.
+  const mapped = override == null && !isClaudeModel(raw.model)
+    ? windowForModel(raw.model)
+    : null
+  const correctedMax = override ?? mapped
+
+  if (correctedMax == null) {
+    // No correction available — but never ship a >100% pct.
+    const pct = Number(raw.pct)
+    if (Number.isFinite(pct) && pct > 100) return { ...raw, pct: 100, over: true }
+    return raw
+  }
+
+  const max = correctedMax
+  const pct = Number.isFinite(used) && max > 0
+    ? Math.min(100, Math.max(0, Math.round((used / max) * 100)))
+    : raw.pct
+  const over = Number.isFinite(used) && used > max
+  return { ...raw, max, pct, over }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "thinkpool-pair",
-  "version": "0.7.155",
+  "version": "0.7.156",
   "description": "Share a local coding-agent CLI (Claude Code, Codex, Gemini, Aider, …) into a ThinkPool Code room, live.",
   "type": "module",
   "bin": {
@@ -11,6 +11,7 @@
     "sdk-smoke.mjs",
     "launcher.mjs",
     "byok-detect.mjs",
+    "context-windows.mjs",
     "claude-session.mjs",
     "update-gate.mjs",
     "event-id.mjs",

package/session-store.mjs

@@ -215,14 +215,3 @@ export function loadNames(room) {
 export function saveNames(room, names) {
   try { ensureDir(room); fs.writeFileSync(namesFile(room), JSON.stringify(names || {})) } catch { /* noop */ }
 }
-
-// Session recap cache (2026-07-02, Session Info panel). The last on-demand summary,
-// stored as a dotfile (NOT *.json → never in loadAll) so it survives a bridge restart
-// and any device that opens the panel can fetch it (persists across devices). One per room.
-const summaryFile = (room) => path.join(dir(room), '.summary')
-export function loadSummary(room) {
-  try { return JSON.parse(fs.readFileSync(summaryFile(room), 'utf8')) || null } catch { return null }
-}
-export function saveSummary(room, summary) {
-  try { ensureDir(room); fs.writeFileSync(summaryFile(room), JSON.stringify(summary || null)) } catch { /* noop */ }
-}