cc-viewer 1.6.335 → 1.6.337

package/dist/index.html

@@ -21,7 +21,7 @@
     // 整体显示大小已弃用 CSS zoom：Electron 改用 webFrame.setZoomFactor（首屏抢占见
     // electron/tab-content-preload.js），纯浏览器交由用户用浏览器自带快捷键缩放，故此处不再设 zoom。
   </script>
-  <script type="module" crossorigin src="./assets/index-Dy14VaBK.js"></script>
+  <script type="module" crossorigin src="./assets/index-BxApW8sc.js"></script>
   <link rel="modulepreload" crossorigin href="./assets/vendor-antd-Be06DOUh.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-codemirror-C9Tqo5sR.js">
   <link rel="modulepreload" crossorigin href="./assets/vendor-mdxeditor-C927Ebjk.js">

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cc-viewer",
-  "version": "1.6.335",
+  "version": "1.6.337",
   "description": "Claude Code logging, visualization, and management toolkit — launch a web viewer alongside Claude Code with full request/response tracing, proxy, and mobile support",
   "license": "MIT",
   "main": "server.js",

package/server/interceptor.js

@@ -7,7 +7,7 @@ const _ccvSkipArgs = ['--version', '-v', '--v', '--help', '-h', 'doctor', 'insta
 const _ccvSkip = _ccvSkipArgs.includes(process.argv[2]);
 
 import './lib/proxy-env.js';
-import { appendFileSync, mkdirSync, readFileSync, writeFileSync, statSync, unlinkSync, existsSync, watchFile } from 'node:fs';
+import { appendFileSync, mkdirSync, readFileSync, writeFileSync, statSync, unlinkSync, existsSync, watchFile, openSync, readSync, closeSync } from 'node:fs';
 import { AsyncWriteQueue } from './lib/async-write-queue.js';
 import { renameSyncWithRetry } from './lib/file-api.js';
 import http from 'node:http';
@@ -16,7 +16,7 @@ import { homedir } from 'node:os';
 import { fileURLToPath, pathToFileURL } from 'node:url';
 import { dirname, join, basename } from 'node:path';
 import { LOG_DIR } from '../findcc.js';
-import { assembleStreamMessage, createStreamAssembler, cleanupTempFiles, findRecentLog, claimUntaggedLog, logFilePrefix, isAnthropicApiPath, isMainAgentRequest, rotateLogFile, fingerprintMsg, replaceTopLevelModel, injectOutputConfigEffort, resolveProfileModel } from './lib/interceptor-core.js';
+import { assembleStreamMessage, createStreamAssembler, cleanupTempFiles, findRecentLog, claimUntaggedLog, logFilePrefix, isAnthropicApiPath, isMainAgentRequest, rotateLogFile, fingerprintMsg, replaceTopLevelModel, injectOutputConfigEffort, resolveProfileModel, extractAgentSpawnPairs, parseRotationContextHead } from './lib/interceptor-core.js';
 
 
 
@@ -241,6 +241,7 @@ function resolveResumeChoice(choice) {
         unlinkSync(tempFile);
       }
       LOG_FILE = recentFile;
+      seedSpawnRegistryFromLogHead(LOG_FILE);
     } else {
       // new: 将临时文件 rename 为正式新日志文件名（空文件直接删除）
       const newPath = tempFile.replace('_temp.jsonl', '.jsonl');
@@ -387,6 +388,7 @@ const _initPromise = (async () => {
       // 仅在干净退出时才 rename，SIGKILL 下丢失）。
       if (process.env.CCV_IM_PLATFORM) {
         LOG_FILE = recentLog;
+        seedSpawnRegistryFromLogHead(LOG_FILE);
         return;
       }
       // Leader / 普通进程：走 resume 交互流程
@@ -425,6 +427,11 @@ export function initForWorkspace(projectPath, { forceNew = false } = {}) {
     _projectName = projectName;
     _logDir = dir;
     LOG_FILE = recentLog;
+    // Same lifecycle as the single-project boot paths: start this workspace's
+    // registry fresh, then re-seed from the resumed segment's head sentinel so
+    // the next rotation's carry-forward stays complete after a restart/switch.
+    _agentSpawnRegistry.clear();
+    seedSpawnRegistryFromLogHead(LOG_FILE);
     // workspace 切换后，重读该 workspace 的 active-profile.json（可能和上一个 workspace 不同）
     _loadProxyProfile();
     return { filePath: recentLog, dir, projectName, resumed: true };
@@ -446,6 +453,8 @@ export function initForWorkspace(projectPath, { forceNew = false } = {}) {
   _projectName = projectName;
   _logDir = dir;
   LOG_FILE = filePath;
+  // Fresh file for a fresh workspace context — no carried names apply.
+  _agentSpawnRegistry.clear();
   _loadProxyProfile(); // 同上
 
   return { filePath, dir, projectName, resumed: false };
@@ -456,12 +465,57 @@ export function resetWorkspace() {
   _projectName = '';
   _logDir = '';
   LOG_FILE = '';
+  // Workspace context gone: drop carried teammate names — the registry is
+  // module-global, and without this a rotation in the NEXT workspace would
+  // write a sentinel carrying THIS workspace's names (unbounded growth +
+  // cross-workspace leakage into the route's teammateNames snapshot).
+  _agentSpawnRegistry.clear();
   _loadProxyProfile(); // workspace 上下文消失，回落到 profile.json.active
 }
 
 // Windows NTFS + Defender 下大文件 I/O 代价远高于 Mac/Linux，降低分割阈值减轻压力
 const MAX_LOG_SIZE = (process.platform === 'win32' ? 150 : 300) * 1024 * 1024;
 
+// Agent-spawn registry: prompt-prefix(60) → teammate name, accumulated from
+// mainAgent responses as they are written. Carried into the next segment via
+// the rotation-context sentinel so post-split viewers can still resolve
+// teammate names whose spawn turn lives in the previous file. The pure
+// extraction/parsing lives in interceptor-core.js (unit-tested there).
+const _agentSpawnRegistry = new Map();
+
+function collectAgentSpawns(entry) {
+  try {
+    if (!entry || !entry.mainAgent) return;
+    for (const [prefix, name] of extractAgentSpawnPairs(entry.response?.body)) {
+      _agentSpawnRegistry.set(prefix, name);
+    }
+  } catch { }
+}
+
+// Boot re-seed: when resuming an existing log whose FIRST frame is a
+// rotation-context sentinel, load its carried names so a restarted leader
+// still writes a complete sentinel at the next rotation. Bounded read of the
+// file head only — never a whole-segment scan (segments reach 300MB).
+function seedSpawnRegistryFromLogHead(file) {
+  try {
+    if (!file || !existsSync(file)) return;
+    const fd = openSync(file, 'r');
+    let head;
+    try {
+      const buf = Buffer.alloc(64 * 1024);
+      const n = readSync(fd, buf, 0, buf.length, 0);
+      head = buf.toString('utf-8', 0, n);
+    } finally {
+      closeSync(fd);
+    }
+    const entry = parseRotationContextHead(head);
+    if (!entry || !Array.isArray(entry.teammateNames)) return;
+    for (const pair of entry.teammateNames) {
+      if (Array.isArray(pair) && pair[0] && pair[1]) _agentSpawnRegistry.set(pair[0], pair[1]);
+    }
+  } catch { }
+}
+
 async function checkAndRotateLogFile() {
   // Teammate 不做日志轮转，由 leader 负责
   if (_isTeammate) return;
@@ -470,7 +524,17 @@ async function checkAndRotateLogFile() {
   } catch { return; }
   await _writeQueue.flush();
   const { filePath } = generateNewLogFilePath();
-  const result = rotateLogFile(LOG_FILE, filePath, MAX_LOG_SIZE);
+  // Sentinel is baked into the new file's CREATION (rotateLogFile initial
+  // content): queueing it after the fact races the watcher's rotation-follow
+  // and can leave it undelivered. Synthetic url gives it a stable dedup key.
+  const sentinel = JSON.stringify({
+    ccvRotationContext: 1,
+    url: 'ccv://rotation-context',
+    from: basename(LOG_FILE),
+    teammateNames: [..._agentSpawnRegistry.entries()],
+    timestamp: new Date().toISOString(),
+  }) + '\n---\n';
+  const result = rotateLogFile(LOG_FILE, filePath, MAX_LOG_SIZE, sentinel);
   if (result.rotated) {
     LOG_FILE = result.newFile;
     // 重置 delta 状态，强制下一条 mainAgent 请求写完整 checkpoint
@@ -482,6 +546,12 @@ async function checkAndRotateLogFile() {
   }
 }
 
+// Exposed for the /api/prev-segment-teammates route (belt-and-braces seed
+// delivery when the in-band sentinel falls outside the client's load window).
+export function getAgentSpawnRegistrySnapshot() {
+  return [..._agentSpawnRegistry.entries()];
+}
+
 // 从环境变量 ANTHROPIC_BASE_URL 提取域名用于请求匹配
 function getBaseUrlHost() {
   try {
@@ -1014,6 +1084,8 @@ export function setupInterceptor() {
                       // 直接使用组装后的 message 对象作为 response.body
                       // 如果组装失败（例如非标准 SSE），则使用原始流内容
                       requestEntry.response.body = assembledMessage || fullContent;
+                      // Must run before the post-write `response = null` release.
+                      collectAgentSpawns(requestEntry);
 
 
                       // 移除在途请求标记，保持原始报文
@@ -1139,6 +1211,7 @@ export function setupInterceptor() {
             body: responseData
           };
 
+          collectAgentSpawns(requestEntry);
 
           delete requestEntry.inProgress;
           delete requestEntry.requestId;

package/server/lib/interceptor-core.js

@@ -15,6 +15,44 @@ const SUBAGENT_BILLING_RE = /cc_is_subagent=true\b/;
 // 两处服务端实现(本文件 + kv-cache-analyzer)由 test/interceptor-core-mainagent.test.js 互校防漂移；
 // 前端 contentFilter 那份由 test/content-filter-unit.test.js 单测覆盖。
 const TEAMMATE_SYSTEM_RE = /running as an agent in a team|Agent Teammate Communication/i;
+// Exported for server/lib/teammate-detect.js (previous-segment backfill filter).
+export { TEAMMATE_SYSTEM_RE, SUBAGENT_BILLING_RE };
+
+// Rotation carry-forward: prompt-prefix → teammate-name pairs extracted from a
+// mainAgent response body's Agent tool_use blocks. Prefix normalization MUST
+// match src/utils/contentFilter.js (trimStart BEFORE slice, length 60) —
+// pinned by test/interceptor.test.js parity cases.
+export const TEAMMATE_PROMPT_PREFIX_LEN = 60;
+
+export function extractAgentSpawnPairs(responseBody) {
+  const pairs = [];
+  // The interceptor's stream path can fall back to a raw string body.
+  if (!responseBody || typeof responseBody !== 'object') return pairs;
+  const content = responseBody.content;
+  if (!Array.isArray(content)) return pairs;
+  for (const block of content) {
+    if (!block || block.type !== 'tool_use' || block.name !== 'Agent') continue;
+    const inp = block.input;
+    if (!inp || !inp.name || typeof inp.prompt !== 'string') continue;
+    const prefix = inp.prompt.trimStart().slice(0, TEAMMATE_PROMPT_PREFIX_LEN);
+    if (prefix) pairs.push([prefix, inp.name]);
+  }
+  return pairs;
+}
+
+// Parses the first frame of a log-file head string; returns the entry when it
+// is a rotation-context sentinel, else null. Callers pass a BOUNDED head read
+// (never a whole segment).
+export function parseRotationContextHead(headString) {
+  try {
+    const frameEnd = headString.indexOf('\n---\n');
+    if (frameEnd <= 0) return null;
+    const entry = JSON.parse(headString.slice(0, frameEnd));
+    return entry && entry.ccvRotationContext ? entry : null;
+  } catch {
+    return null;
+  }
+}
 
 export function getSystemText(body) {
   const system = body?.system;
@@ -443,21 +481,29 @@ export function fingerprintMsg(m) {
 
 /**
  * Rotate log file when it exceeds maxSize.
- * Creates an empty new file (no content migration) and appends '\n' to old file
+ * Creates a new file (no content migration) and appends '\n' to old file
  * to trigger fs.watchFile callback for watcher migration.
  *
+ * initialContent (optional) is written INTO the new file at creation time —
+ * used for the rotation-context sentinel. It must be baked into creation
+ * rather than queued afterwards: the old-file trigger byte below fires the
+ * watcher's rotation-follow after a short debounce, and a late-flushing
+ * queued write can land between the new file's initial stream read and its
+ * lastByteOffset snapshot, in which case it is never delivered to clients.
+ *
  * @param {string} currentFile - current log file path
  * @param {string} newFile - new log file path to rotate to
  * @param {number} maxSize - max file size in bytes
+ * @param {string} [initialContent] - content the new file is created with
  * @returns {{ rotated: boolean, oldFile?: string, newFile?: string }}
  */
-export function rotateLogFile(currentFile, newFile, maxSize) {
+export function rotateLogFile(currentFile, newFile, maxSize, initialContent = '') {
   try {
     if (!existsSync(currentFile)) return { rotated: false };
     const size = statSync(currentFile).size;
     if (size < maxSize) return { rotated: false };
-    // 不迁移旧内容，创建空新文件（立即创建，避免 watcher 时序窗口）
-    try { writeFileSync(newFile, ''); } catch { }
+    // 不迁移旧内容，创建新文件（立即创建，避免 watcher 时序窗口）
+    try { writeFileSync(newFile, initialContent); } catch { }
     // 触发旧文件 watcher 回调，使其检测到文件变更并切换到新文件
     try { appendFileSync(currentFile, '\n'); } catch { }
     return { rotated: true, oldFile: currentFile, newFile };

package/server/lib/log-management.js

@@ -2,7 +2,7 @@ import { existsSync, realpathSync, unlinkSync, readdirSync, readFileSync, writeF
 import { readFile, writeFile, appendFile, stat, readdir } from 'node:fs/promises';
 import { randomBytes } from 'node:crypto';
 import { renameSyncWithRetry } from './file-api.js';
-import { join, sep } from 'node:path';
+import { join, sep, dirname, basename } from 'node:path';
 import { reconstructEntries } from './delta-reconstructor.js';
 import { streamReconstructedEntriesAsync } from './log-stream.js';
 import { archiveJsonl, resolveJsonlPath } from './jsonl-archive.js';
@@ -97,6 +97,39 @@ export async function listLocalLogs(logDir, currentProjectName, { instanceId = n
   return { ...grouped, _currentProject: currentProjectName || '' };
 }
 
+/**
+ * Locate the log segment immediately preceding currentFile in the same
+ * directory, for the post-rotation teammate backfill. Ownership is enforced
+ * via logFileMatcher(projectName, instanceId) — a naive "older file in the
+ * same dir" scan would cross --pid instances and return another
+ * conversation's log. Archived (.jsonl.zip) predecessors are valid results:
+ * readers resolve them transparently via resolveJsonlPath. Returns the
+ * absolute path, or null when there is no strictly-older owned segment.
+ */
+export function findPreviousSegment(currentFile, projectName, instanceId = null) {
+  try {
+    if (!currentFile || !projectName) return null;
+    const dir = dirname(currentFile);
+    const currentTs = parseLogTs(basename(currentFile));
+    if (!currentTs || !existsSync(dir)) return null;
+    const owns = logFileMatcher(projectName, instanceId);
+    let best = null;
+    let bestTs = '';
+    for (const f of readdirSync(dir)) {
+      if (!isLogFileName(f) || !owns(f)) continue;
+      const ts = parseLogTs(f);
+      if (!ts || ts >= currentTs) continue;
+      if (ts > bestTs || (ts === bestTs && best !== null && f > basename(best))) {
+        best = join(dir, f);
+        bestTs = ts;
+      }
+    }
+    return best;
+  } catch {
+    return null;
+  }
+}
+
 export async function readLocalLog(logDir, file) {
   validateLogPath(logDir, file);
   const filePath = resolveJsonlPath(join(logDir, file));
@@ -190,6 +223,9 @@ export async function mergeLogFiles(logDir, files) {
     await streamReconstructedEntriesAsync(filePath, async (segment) => {
       let chunk = '';
       for (const entry of segment) {
+        // Rotation-context sentinels describe a predecessor relationship that a
+        // merged file no longer has — drop them from the merge product.
+        if (entry.ccvRotationContext) continue;
         // 乱序/断裂条目若未被补偿回填（messages 仍是裸 delta 切片），丢弃不写：
         // 剥除 _deltaFormat 后它会伪装成旧格式全量条目，未来读取时把累积状态
         // 重置成几条切片，比丢掉这条（内容已被更新条目取代）破坏大得多

package/server/lib/log-stream.js

@@ -511,3 +511,60 @@ export async function readPagedEntries(filePath, { before, limit }) {
   const oldestTimestamp = extractTimestamp(sliced[0]) || '';
   return { entries: sliced, hasMore, oldestTimestamp, count: sliced.length };
 }
+
+/**
+ * Scan a whole segment and collect the parsed entries matching `predicate`,
+ * for the post-rotation teammate backfill (/api/prev-segment-teammates).
+ *
+ * - `rawPrefilter(rawString)`: cheap substring gate evaluated BEFORE
+ *   JSON.parse, so multi-MB MainAgent checkpoint frames are skipped without
+ *   parsing.
+ * - Last-write-wins dedup by timestamp|url (a request's inProgress and final
+ *   writes share one key; the later frame replaces the earlier).
+ * - `maxBytes` budget applied NEWEST-first over the raw sizes: when the
+ *   matches exceed the budget, the oldest are dropped and `truncated` is set.
+ *
+ * Returns { entries, truncated } with entries in chronological (file) order.
+ */
+export async function collectFilteredRawEntriesAsync(filePath, predicate, {
+  maxBytes = 64 * 1024 * 1024,
+  rawPrefilter = null,
+  yieldEvery = 50,
+} = {}) {
+  const matched = new Map(); // dedupKey -> { size, entry }, insertion order = file order
+  let nokey = 0;
+  let totalBytes = 0;
+  let truncated = false;
+  let parsedCount = 0;
+  for await (const raw of iterateRawEntriesAsync(filePath)) {
+    if (rawPrefilter && !rawPrefilter(raw)) continue;
+    // Real team logs defeat the prefilter for most BYTES (leader checkpoints
+    // embed the SendMessage tool text), so parses can total >1s on a 300MB
+    // segment — yield periodically to keep the live proxy's event loop
+    // responsive during the scan.
+    if (yieldEvery > 0 && ++parsedCount % yieldEvery === 0) {
+      await new Promise((resolve) => setImmediate(resolve));
+    }
+    let entry;
+    try { entry = JSON.parse(raw); } catch { continue; }
+    if (!entry || !predicate(entry)) continue;
+    const key = extractDedupKey(raw) || `__nokey_${nokey++}`;
+    const prev = matched.get(key);
+    if (prev) totalBytes -= prev.size;
+    matched.set(key, { size: raw.length, entry });
+    totalBytes += raw.length;
+    // Enforce the budget DURING the scan (newest wins): evicting the oldest
+    // keys keeps transient memory bounded even on teammate-heavy segments —
+    // not just the response size.
+    while (totalBytes > maxBytes && matched.size > 1) {
+      const oldestKey = matched.keys().next().value;
+      totalBytes -= matched.get(oldestKey).size;
+      matched.delete(oldestKey);
+      truncated = true;
+    }
+  }
+  return {
+    entries: [...matched.values()].map((it) => it.entry),
+    truncated,
+  };
+}

package/server/lib/log-watcher.js

@@ -115,7 +115,11 @@ export function sendChunkToClients(clients, dataJson) {
 // --- 轮转切换（抽取公共逻辑） ---
 
 async function _switchToRotatedFile(logFile, currentLogFile, clients, opts) {
-  _unwatchSingleFile(logFile);
+  // Deliberately KEEP the old file watched: external-process teammates resolve
+  // the leader log once at boot and continue appending to the previous segment
+  // after rotation. Unwatching it would make their post-rotation entries
+  // invisible live; client dedup absorbs any replayed frames. watchedFiles is
+  // a multi-file Map, so watching both segments is supported.
   const total = await countLogEntries(currentLogFile);
   sendEventToClients(clients, 'load_start', { total, incremental: false });
   await streamReconstructedEntriesAsync(currentLogFile, (segment) => {

package/server/lib/teammate-detect.js

@@ -0,0 +1,32 @@
+import { getSystemText, TEAMMATE_SYSTEM_RE } from './interceptor-core.js';
+
+/**
+ * Server-side teammate detection for the previous-segment backfill filter
+ * (/api/prev-segment-teammates). Mirrors the client's three teammate shapes:
+ *
+ *  1. External-process teammate — interceptor persisted `entry.teammate`
+ *     (--agent-name / --parent-session-id spawn).
+ *  2. Proxy-mode teammate — system prompt carries the team-communication
+ *     marker (TEAMMATE_SYSTEM_RE, shared with interceptor-core.js).
+ *  3. Native (same-process Agent-tool) teammate — SDK agent system prompt
+ *     ("You are a Claude agent", NOT "You are Claude Code") plus a
+ *     SendMessage tool; plain subagents are never granted SendMessage.
+ *
+ * KEEP IN SYNC with src/utils/teammateDetector.js (native rule) and
+ * src/utils/contentFilter.js (TEAMMATE_SYSTEM_RE). Drift is pinned by the
+ * parity cases in test/teammate-detect.test.js (pattern follows
+ * test/interceptor-core-mainagent.test.js).
+ */
+
+// Mirror of src/utils/teammateDetector.js NATIVE_TEAMMATE_RE.
+const NATIVE_TEAMMATE_RE = /You are a Claude agent/i;
+
+export function isTeammateLikeEntry(entry) {
+  if (!entry || !entry.body) return false;
+  if (entry.teammate) return true;
+  const sysText = getSystemText(entry.body);
+  if (TEAMMATE_SYSTEM_RE.test(sysText)) return true;
+  if (!NATIVE_TEAMMATE_RE.test(sysText)) return false;
+  const tools = entry.body.tools;
+  return Array.isArray(tools) && tools.some((t) => t && t.name === 'SendMessage');
+}

package/server/routes/logs.js

@@ -1,10 +1,11 @@
 // Local log management routes (moved verbatim from server.js handleRequest).
-import { existsSync, realpathSync, statSync, createReadStream } from 'node:fs';
+import { existsSync, realpathSync, statSync, createReadStream, openSync, readSync, closeSync } from 'node:fs';
 import { join, basename } from 'node:path';
 import { LOG_DIR } from '../../findcc.js';
-import { _projectName } from '../interceptor.js';
-import { listLocalLogs, deleteLogFiles, mergeLogFiles, archiveLogFiles, validateLogPath } from '../lib/log-management.js';
-import { countLogEntries, streamRawEntriesAsync, readTailEntries } from '../lib/log-stream.js';
+import { _projectName, LOG_FILE, getAgentSpawnRegistrySnapshot } from '../interceptor.js';
+import { listLocalLogs, deleteLogFiles, mergeLogFiles, archiveLogFiles, validateLogPath, findPreviousSegment } from '../lib/log-management.js';
+import { countLogEntries, streamRawEntriesAsync, readTailEntries, collectFilteredRawEntriesAsync } from '../lib/log-stream.js';
+import { isTeammateLikeEntry } from '../lib/teammate-detect.js';
 
 async function localLogs(req, res, parsedUrl, isLocal, deps) {
   try {
@@ -207,6 +208,113 @@ function archiveLogs(req, res, parsedUrl, isLocal, deps) {
   });
 }
 
+// Bounded head read: returns the parsed first frame of a live log file when it
+// is a rotation-context sentinel, else null. Never scans past the first frame.
+function readHeadRotationContext(file) {
+  try {
+    if (!file || !existsSync(file)) return null;
+    const fd = openSync(file, 'r');
+    let head;
+    try {
+      const buf = Buffer.alloc(64 * 1024);
+      const n = readSync(fd, buf, 0, buf.length, 0);
+      head = buf.toString('utf-8', 0, n);
+    } finally {
+      closeSync(fd);
+    }
+    const frameEnd = head.indexOf('\n---\n');
+    if (frameEnd <= 0) return null;
+    const entry = JSON.parse(head.slice(0, frameEnd));
+    return entry && entry.ccvRotationContext ? entry : null;
+  } catch {
+    return null;
+  }
+}
+
+// Cheap substring gate evaluated before JSON.parse: every teammate shape
+// carries at least one of these markers in its raw JSON (external tag,
+// proxy-mode system marker, native SDK prompt). Giant MainAgent checkpoint
+// frames are skipped without parsing.
+function teammateRawPrefilter(raw) {
+  return raw.includes('"teammate"')
+    || raw.includes('agent in a team')
+    || raw.includes('Agent Teammate Communication')
+    || raw.includes('You are a Claude agent');
+}
+
+// Single-flight + short-TTL cache for the previous-segment scan. A real
+// predecessor is ~300MB and the parse pass transiently costs hundreds of MB of
+// RSS; every non-incremental cold load triggers the route, so concurrent
+// viewers / rapid refreshes must share one scan. Keyed by path+size+mtime —
+// the old segment can still GROW (external teammates keep appending to it),
+// which changes the key and forces a rescan.
+const PREV_SCAN_TTL_MS = 60 * 1000;
+let _prevScanCache = null; // { key, promise, expiresAt }
+
+function collectPrevSegmentCached(prev, predicate, opts) {
+  let st = null;
+  try { st = statSync(prev); } catch { }
+  const key = `${prev}|${st ? st.size : 0}|${st ? st.mtimeMs : 0}`;
+  const now = Date.now();
+  if (_prevScanCache && _prevScanCache.key === key && _prevScanCache.expiresAt > now) {
+    return _prevScanCache.promise;
+  }
+  const promise = collectFilteredRawEntriesAsync(prev, predicate, opts);
+  _prevScanCache = { key, promise, expiresAt: now + PREV_SCAN_TTL_MS };
+  promise.catch(() => {
+    if (_prevScanCache && _prevScanCache.promise === promise) _prevScanCache = null;
+  });
+  return promise;
+}
+
+/**
+ * Post-rotation teammate backfill. Resolves the previous segment of the
+ * server's OWN live LOG_FILE (no client-supplied filenames — no traversal
+ * surface) and streams NDJSON:
+ *   line 1: { rotationContext, teammateNames }  (context; teammateNames merges
+ *           the head sentinel's carry-forward with the in-process spawn
+ *           registry — the sentinel may sit outside the client's load window)
+ *   lines:  one backfill entry per line (teammate-like, renderable only)
+ *   last:   { done: true, truncated, prevSegment }
+ */
+async function prevSegmentTeammates(req, res, parsedUrl, isLocal, deps) {
+  res.writeHead(200, { 'Content-Type': 'application/x-ndjson' });
+  try {
+    const current = LOG_FILE;
+    const sentinel = readHeadRotationContext(current);
+    const names = new Map(sentinel?.teammateNames?.filter((p) => Array.isArray(p) && p[0]) || []);
+    for (const [prefix, name] of getAgentSpawnRegistrySnapshot()) names.set(prefix, name);
+    res.write(JSON.stringify({
+      rotationContext: sentinel ? { from: sentinel.from || null } : null,
+      teammateNames: [...names.entries()],
+    }) + '\n');
+    // No live file (workspace pre-select) or resume placeholder → context only.
+    if (!current || current.endsWith('_temp.jsonl')) {
+      res.end(JSON.stringify({ done: true, truncated: false, prevSegment: null }) + '\n');
+      return;
+    }
+    const instanceId = (deps && deps.instanceId) || null;
+    const prev = findPreviousSegment(current, _projectName, instanceId);
+    if (!prev) {
+      res.end(JSON.stringify({ done: true, truncated: false, prevSegment: null }) + '\n');
+      return;
+    }
+    const { entries, truncated } = await collectPrevSegmentCached(prev, (entry) => (
+      !entry.inProgress && !entry.isHeartbeat && !entry.isCountTokens
+      && !entry.ccvRotationContext
+      && !(entry._deltaFormat && entry.mainAgent && !entry.teammate)
+      && !!entry.timestamp
+      && Array.isArray(entry.response?.body?.content) && entry.response.body.content.length > 0
+      && isTeammateLikeEntry(entry)
+    ), { rawPrefilter: teammateRawPrefilter });
+    for (const entry of entries) res.write(JSON.stringify(entry) + '\n');
+    res.end(JSON.stringify({ done: true, truncated, prevSegment: basename(prev) }) + '\n');
+  } catch (err) {
+    // Headers already sent — terminate the NDJSON stream with an error line.
+    try { res.end(JSON.stringify({ done: true, error: err?.message || 'internal error' }) + '\n'); } catch { }
+  }
+}
+
 export const logsRoutes = [
   { method: 'GET', match: 'exact', path: '/api/local-logs', handler: localLogs },
   { method: 'GET', match: 'exact', path: '/api/download-log', handler: downloadLog },
@@ -214,4 +322,5 @@ export const logsRoutes = [
   { method: 'POST', match: 'exact', path: '/api/delete-logs', handler: deleteLogs },
   { method: 'POST', match: 'exact', path: '/api/merge-logs', handler: mergeLogs },
   { method: 'POST', match: 'exact', path: '/api/archive-logs', handler: archiveLogs },
+  { method: 'GET', match: 'exact', path: '/api/prev-segment-teammates', handler: prevSegmentTeammates },
 ];