@usepowerplant/cli 0.4.18 → 0.4.19

package/dist/cli.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="7730a7ff-ca8b-5911-9406-4ee9329a7ea8")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="5ecc7184-ee4b-53d3-858b-4d0790456d70")}catch(e){}}();
 const __cliNodeMajor = Number(process.versions.node.split('.')[0]);
 if (__cliNodeMajor < 20) {
   console.error(`powerplant needs Node 20 or newer — this is Node ${process.versions.node}.`);
@@ -13562,16 +13562,16 @@ var require_connect = __commonJS({
           }
         });
       }
-      get(sessionKey) {
-        const ref = this._sessionCache.get(sessionKey);
+      get(sessionKey2) {
+        const ref = this._sessionCache.get(sessionKey2);
         return ref ? ref.deref() : null;
       }
-      set(sessionKey, session) {
+      set(sessionKey2, session) {
         if (this._maxCachedSessions === 0) {
           return;
         }
-        if (this._sessionCache.has(sessionKey)) {
-          this._sessionCache.delete(sessionKey);
+        if (this._sessionCache.has(sessionKey2)) {
+          this._sessionCache.delete(sessionKey2);
         } else if (this._sessionCache.size >= this._maxCachedSessions) {
           for (const [key, ref] of this._sessionCache) {
             if (ref.deref() === void 0) {
@@ -13584,8 +13584,8 @@ var require_connect = __commonJS({
             this._sessionCache.delete(oldest.value);
           }
         }
-        this._sessionCache.set(sessionKey, new WeakRef(session));
-        this._sessionRegistry.register(session, sessionKey);
+        this._sessionCache.set(sessionKey2, new WeakRef(session));
+        this._sessionRegistry.register(session, sessionKey2);
       }
     };
     function buildConnector({ allowH2, useH2c, maxCachedSessions, socketPath, timeout, session: customSession, ...opts }) {
@@ -13603,9 +13603,9 @@ var require_connect = __commonJS({
             tls2 = __require("node:tls");
           }
           servername = servername || options.servername || util2.getServerName(host) || null;
-          const sessionKey = servername || hostname4;
-          assert2(sessionKey);
-          const session = customSession || sessionCache.get(sessionKey) || null;
+          const sessionKey2 = servername || hostname4;
+          assert2(sessionKey2);
+          const session = customSession || sessionCache.get(sessionKey2) || null;
           port = port || 443;
           socket = tls2.connect({
             highWaterMark: 16384,
@@ -13621,7 +13621,7 @@ var require_connect = __commonJS({
             host: hostname4
           });
           socket.on("session", function(session2) {
-            sessionCache.set(sessionKey, session2);
+            sessionCache.set(sessionKey2, session2);
           });
         } else {
           assert2(!httpSocket, "httpSocket can only be sent on TLS update");
@@ -36589,11 +36589,11 @@ ${captureLines}` : capture2.stack;
 });
 
 // src/hookPreferences.ts
-import { mkdirSync as mkdirSync12, readFileSync as readFileSync12, renameSync as renameSync6, writeFileSync as writeFileSync10 } from "node:fs";
+import { mkdirSync as mkdirSync12, readFileSync as readFileSync13, renameSync as renameSync7, writeFileSync as writeFileSync9 } from "node:fs";
 import path24 from "node:path";
 
 // ../../apps/syncservice/src/credentials.ts
-import { chmodSync as chmodSync4, existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync8, unlinkSync as unlinkSync3, writeFileSync as writeFileSync8 } from "node:fs";
+import { chmodSync as chmodSync3, existsSync as existsSync8, mkdirSync as mkdirSync9, readFileSync as readFileSync9, unlinkSync as unlinkSync3, writeFileSync as writeFileSync7 } from "node:fs";
 import os12 from "node:os";
 import path14 from "node:path";
 
@@ -56395,6 +56395,35 @@ function codexPromptOrigin(keptBlockOrigins) {
   return keptBlockOrigins.every((origin) => origin === "human") ? "human" : "unknown";
 }
 
+// ../core/src/rawTranscriptBundle.ts
+var RAW_TRANSCRIPT_BUNDLE_CONTENT_TYPE = "application/vnd.powerplant.raw-transcript-bundle";
+var RAW_TRANSCRIPT_PART_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
+var MAX_RAW_TRANSCRIPT_PARTS = 500;
+var MAX_HEADER_BYTES = 128 * 1024;
+var LENGTH_PREFIX_BYTES = 4;
+var headerSchema = external_exports.object({
+  version: external_exports.literal(1),
+  mainBytes: external_exports.number().int().positive(),
+  parts: external_exports.array(external_exports.object({ part: external_exports.string().regex(RAW_TRANSCRIPT_PART_PATTERN), bytes: external_exports.number().int().positive() })).max(MAX_RAW_TRANSCRIPT_PARTS),
+  subagents: external_exports.object({ found: external_exports.number().int().nonnegative(), skipped: external_exports.number().int().nonnegative() })
+}).refine((header) => new Set(header.parts.map((entry) => entry.part)).size === header.parts.length, {
+  message: "part ids must be unique"
+}).refine((header) => header.subagents.found === header.parts.length + header.subagents.skipped, {
+  message: "subagents.found must equal the parts carried plus the files skipped"
+});
+function encodeRawTranscriptBundle(bundle) {
+  const fields = headerSchema.parse({
+    version: 1,
+    mainBytes: bundle.main.byteLength,
+    parts: bundle.parts.map((entry) => ({ part: entry.part, bytes: entry.body.byteLength })),
+    subagents: bundle.subagents
+  });
+  const header = Buffer.from(JSON.stringify(fields), "utf8");
+  const prefix = Buffer.alloc(LENGTH_PREFIX_BYTES);
+  prefix.writeUInt32BE(header.byteLength);
+  return Buffer.concat([prefix, header, bundle.main, ...bundle.parts.map((entry) => entry.body)]);
+}
+
 // ../core/src/encodedImages.ts
 var BASE64_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
 function isEncodedImage(data, mediaType) {
@@ -56766,8 +56795,90 @@ var CONFIG_LINE_SECRET_VALUE = (
   // eslint-disable-next-line security/detect-unsafe-regex
   /^([+-]?(?:(?:[^\s:]{1,256}:)?\d+[:-])?[ \t]*(?:\d+(?:\t|\u2192)[ \t]*)?(?:(?:export|-)[ \t]+)?)([A-Za-z_][\w.-]{0,63})([ \t]*[=:][ \t]*)([^\s"'\\,;()[\]{}<>]{8,})(?=[ \t]*(?:#.*)?\r?$)/gm
 );
+function jsonTokens(text) {
+  const tokens = [];
+  for (const { index } of text.matchAll(/["\r\n]/g)) {
+    if (text[index] !== '"') {
+      tokens.push({ index, level: -1 });
+      continue;
+    }
+    let backslashes = 0;
+    while (text[index - backslashes - 1] === "\\") backslashes += 1;
+    let level = 0;
+    for (let run = backslashes + 1; run % 2 === 0; run /= 2) level += 1;
+    tokens.push({ index, level });
+  }
+  return tokens;
+}
+function stringEnds(tokens) {
+  const ends = [];
+  const pending = [];
+  for (let i = tokens.length - 1; i >= 0; i -= 1) {
+    const { level } = tokens[i];
+    while (pending.length > 0 && tokens[pending.at(-1)].level > level) pending.pop();
+    ends[i] = pending.at(-1) ?? -1;
+    pending.push(i);
+  }
+  return ends;
+}
+function stringTextEnd(text, end) {
+  if (end === void 0) return text.length;
+  return end.level < 0 ? end.index : end.index - (2 ** end.level - 1);
+}
+function skipJsonSpace(text, from, level) {
+  const escapeLength = level === 0 ? 0 : 2 ** (level - 1);
+  let at = from;
+  for (; ; ) {
+    const char = text[at];
+    if (char === " " || level === 0 && (char === "	" || char === "\r" || char === "\n")) at += 1;
+    else if (char === "\\" && level > 0 && text.startsWith("\\".repeat(escapeLength), at) && /^[nrt]$/.test(text[at + escapeLength] ?? "")) {
+      at += escapeLength + 1;
+    } else return at;
+  }
+}
+function decodeJsonKey(raw, level) {
+  if (!raw.includes("\\")) return raw;
+  let key = raw;
+  for (let round = 0; round <= level; round += 1) {
+    try {
+      const decoded = JSON.parse(`"${key}"`);
+      if (typeof decoded !== "string") return key;
+      key = decoded;
+    } catch {
+      return key;
+    }
+  }
+  return key;
+}
+function redactJsonSecretValues(text) {
+  if (!text.includes('"')) return text;
+  const tokens = jsonTokens(text);
+  const ends = stringEnds(tokens);
+  let out = "";
+  let copied = 0;
+  for (const [i, { index, level }] of tokens.entries()) {
+    if (level < 0 || index < copied) continue;
+    const keyEnd = ends[i] ?? -1;
+    const keyClose = tokens[keyEnd];
+    if (keyClose?.level !== level) continue;
+    const colon = skipJsonSpace(text, keyClose.index + 1, level);
+    if (text[colon] !== ":") continue;
+    const valueOpen = skipJsonSpace(text, colon + 1, level);
+    let valueQuote = keyEnd + 1;
+    while (tokens[valueQuote]?.level === -1 && (tokens[valueQuote]?.index ?? Infinity) < valueOpen) valueQuote += 1;
+    const quote = tokens[valueQuote];
+    if (quote?.level !== level || quote.index !== valueOpen + 2 ** level - 1) continue;
+    if (!isSecretName(decodeJsonKey(text.slice(index + 1, stringTextEnd(text, keyClose)), level))) continue;
+    const valueStart = quote.index + 1;
+    const valueEnd = stringTextEnd(text, tokens[ends[valueQuote] ?? -1]);
+    if (valueEnd <= valueStart) continue;
+    out += text.slice(copied, valueStart) + REDACTED;
+    copied = valueEnd;
+  }
+  return out + text.slice(copied);
+}
 function redactSecretNamedValues(text) {
-  return text.replace(
+  return redactJsonSecretValues(text).replace(
     QUOTED_SECRET_VALUE,
     (match, name, separator, quote, value) => isSecretName(name) && isSecretValue(value) ? `${name}${separator}${quote}${REDACTED}${quote}` : match
   ).replace(
@@ -57354,6 +57465,44 @@ var TOOL_CALL_INPUT_MAX_BYTES = 65536;
 function boundedToolInput(value) {
   return boundRedactedText(JSON.stringify(value), TOOL_CALL_INPUT_MAX_BYTES);
 }
+var tokenCount = external_exports.number().nonnegative();
+var costStateSchema = external_exports.object({
+  sessionId: external_exports.string(),
+  startTime: external_exports.number().positive(),
+  hasUnknownModelCost: external_exports.boolean().optional(),
+  modelUsage: external_exports.record(
+    external_exports.string(),
+    external_exports.object({
+      costUSD: external_exports.number().nonnegative(),
+      inputTokens: tokenCount,
+      outputTokens: tokenCount,
+      cacheReadInputTokens: tokenCount,
+      cacheCreationInputTokens: tokenCount
+    })
+  )
+});
+function runCostOf(record2) {
+  const parsed = costStateSchema.safeParse(record2);
+  if (!parsed.success) return null;
+  const runStartedAt = new Date(parsed.data.startTime);
+  if (Number.isNaN(runStartedAt.getTime())) return null;
+  return {
+    sessionId: parsed.data.sessionId,
+    runStartedAt: runStartedAt.toISOString(),
+    // Claude Code's own restore reads a missing flag as false.
+    unknownModelCost: parsed.data.hasUnknownModelCost ?? false,
+    byModel: Object.entries(parsed.data.modelUsage).map(([model, usage]) => ({
+      model,
+      costUsd: usage.costUSD,
+      tokens: {
+        inputTokens: usage.inputTokens,
+        outputTokens: usage.outputTokens,
+        cacheReadTokens: usage.cacheReadInputTokens,
+        cacheWriteTokens: usage.cacheCreationInputTokens
+      }
+    })).sort((a, b2) => a.model < b2.model ? -1 : a.model > b2.model ? 1 : 0)
+  };
+}
 function createDigestTurnParser(options = {}) {
   const turns = [];
   let pendingTools = [];
@@ -57363,12 +57512,37 @@ function createDigestTurnParser(options = {}) {
   let currentCarrier = null;
   let currentBase = null;
   let currentCounted = false;
+  const countedEnvelopes = /* @__PURE__ */ new Map();
+  let currentReplay = null;
+  let transcriptStartedAt = null;
+  let transcriptSessionId = null;
+  let lastRecordAt = null;
+  let runCost = null;
+  let recordedThrough = null;
+  let laterEnvelopes = [];
+  let laterSet = /* @__PURE__ */ new Set();
+  let usageRevisedAfter = false;
   const envelopes = [];
   let pendingEnvelopes = [];
   let currentEnvelope = null;
   const evidence = new PrEvidenceCollector();
   const backgroundTasks = { started: /* @__PURE__ */ new Map(), reads: /* @__PURE__ */ new Map() };
   let line = -1;
+  const resum = (envelope) => {
+    const landed = envelope.turn === -1 ? pendingEnvelopes : envelopes.filter((e) => e.turn === envelope.turn);
+    const usage = landed.reduce((sum2, e) => mergeUsage(sum2, e.usage), null);
+    if (envelope.turn === -1) pendingUsage = usage;
+    else turns[envelope.turn].usage = usage;
+  };
+  const noteRevision = (envelope, recorded, at) => {
+    if (sameUsage(recorded, envelope.usage)) return;
+    const time3 = at === null ? Number.NaN : Date.parse(at);
+    if (Number.isNaN(time3)) envelope.revisedAt = null;
+    else if (envelope.revisedAt !== null && (envelope.revisedAt === void 0 || Date.parse(envelope.revisedAt) < time3)) {
+      envelope.revisedAt = at;
+    }
+    if (runCost !== null && !laterSet.has(envelope)) usageRevisedAfter = true;
+  };
   const landPending = (turn) => {
     for (const envelope of pendingEnvelopes) {
       envelope.turn = turn;
@@ -57389,6 +57563,18 @@ function createDigestTurnParser(options = {}) {
       } catch {
         return;
       }
+      transcriptStartedAt ??= recordTime(record2);
+      if (record2.type === "cost-state") {
+        runCost = runCostOf(record2);
+        recordedThrough = lastRecordAt;
+        laterEnvelopes = [];
+        laterSet = /* @__PURE__ */ new Set();
+        usageRevisedAfter = false;
+        return;
+      }
+      if (typeof record2.sessionId === "string") transcriptSessionId ??= record2.sessionId;
+      const recordAt = recordTime(record2);
+      if (recordAt !== null && (lastRecordAt === null || Date.parse(recordAt) > Date.parse(lastRecordAt))) lastRecordAt = recordAt;
       if (record2.type === "pr-link") {
         const ref = pullRequestRefFromUrl(typeof record2.prUrl === "string" ? record2.prUrl : "");
         if (ref !== null) evidence.linked(ref, recordTime(record2), line);
@@ -57414,32 +57600,43 @@ function createDigestTurnParser(options = {}) {
         currentId = id;
         currentCarrier = null;
         currentBase = pendingUsage;
-        currentCounted = false;
+        currentReplay = id === null ? null : countedEnvelopes.get(id) ?? null;
+        currentCounted = currentReplay !== null;
       }
       const parsedUsage = recordTurnUsage(message2);
       if (parsedUsage) {
-        if (currentCounted) {
+        if (currentReplay) {
+          const recorded = currentReplay.usage;
+          keepRecordedTierAndSplit(parsedUsage, recorded);
+          currentReplay.usage = parsedUsage;
+          noteRevision(currentReplay, recorded, at);
+          resum(currentReplay);
+        } else if (currentCounted) {
           const recorded = currentEnvelope?.usage;
-          if (parsedUsage.serviceTier === void 0 && recorded?.serviceTier !== void 0) {
-            parsedUsage.serviceTier = recorded.serviceTier;
-          }
-          if (parsedUsage.cacheWrite1hTokens === null && recorded?.cacheWriteTokens === parsedUsage.cacheWriteTokens) {
-            parsedUsage.cacheWrite1hTokens = recorded.cacheWrite1hTokens;
-          }
+          if (recorded !== void 0) keepRecordedTierAndSplit(parsedUsage, recorded);
           const updated = mergeUsage(currentBase, parsedUsage);
           if (currentCarrier) currentCarrier.usage = updated;
           else pendingUsage = updated;
-          if (currentEnvelope) currentEnvelope.usage = parsedUsage;
+          if (currentEnvelope !== null && recorded !== void 0) {
+            currentEnvelope.usage = parsedUsage;
+            noteRevision(currentEnvelope, recorded, at);
+          }
         } else if (currentCarrier) {
           currentCarrier.usage = mergeUsage(currentCarrier.usage, parsedUsage);
           currentCounted = true;
           currentEnvelope = { turn: turns.indexOf(currentCarrier), at, usage: parsedUsage, branch: recordBranch(record2) };
           envelopes.push(currentEnvelope);
+          laterEnvelopes.push(currentEnvelope);
+          laterSet.add(currentEnvelope);
+          if (id !== null) countedEnvelopes.set(id, currentEnvelope);
         } else {
           pendingUsage = mergeUsage(pendingUsage, parsedUsage);
           currentCounted = true;
           currentEnvelope = { turn: -1, at, usage: parsedUsage, branch: recordBranch(record2) };
           pendingEnvelopes.push(currentEnvelope);
+          laterEnvelopes.push(currentEnvelope);
+          laterSet.add(currentEnvelope);
+          if (id !== null) countedEnvelopes.set(id, currentEnvelope);
         }
       }
       const model = typeof message2.model === "string" ? message2.model : null;
@@ -57465,7 +57662,9 @@ function createDigestTurnParser(options = {}) {
               text: part.text,
               origin,
               toolCalls: pendingTools,
-              usage: pendingUsage,
+              // A message written again carries zero of its own: its money
+              // landed where it was first counted.
+              usage: pendingUsage ?? (currentReplay ? zeroUsage(model) : null),
               at: pendingAt
             };
             turns.push(turn);
@@ -57501,6 +57700,12 @@ function createDigestTurnParser(options = {}) {
     usageEnvelopes() {
       return envelopes;
     },
+    harnessCost() {
+      if (runCost === null || runCost.sessionId !== transcriptSessionId) return null;
+      const { runStartedAt, unknownModelCost, byModel } = runCost;
+      const laterUsage = laterEnvelopes.map((envelope) => envelope.usage);
+      return { runStartedAt, transcriptStartedAt, recordedThrough, unknownModelCost, byModel, usageRevisedAfter, laterUsage };
+    },
     prEvidence() {
       return evidence.finish();
     },
@@ -57581,6 +57786,14 @@ function messageIdOf(record2, message2) {
   if (typeof record2.uuid === "string") return record2.uuid;
   return null;
 }
+function keepRecordedTierAndSplit(later, recorded) {
+  if ((later.serviceTier === void 0 || later.serviceTier === "unknown") && recorded.serviceTier !== void 0) {
+    later.serviceTier = recorded.serviceTier;
+  }
+  if (later.cacheWrite1hTokens === null && recorded.cacheWriteTokens === later.cacheWriteTokens) {
+    later.cacheWrite1hTokens = recorded.cacheWrite1hTokens;
+  }
+}
 function recordTurnUsage(message2) {
   const usage = message2.usage;
   if (!usage || typeof usage !== "object") return null;
@@ -57608,6 +57821,9 @@ function recordTurnUsage(message2) {
 function zeroUsage(model) {
   return { inputTokens: 0, outputTokens: 0, cacheReadTokens: 0, cacheWriteTokens: 0, cacheWrite1hTokens: 0, model };
 }
+function sameUsage(a, b2) {
+  return a.inputTokens === b2.inputTokens && a.outputTokens === b2.outputTokens && a.cacheReadTokens === b2.cacheReadTokens && a.cacheWriteTokens === b2.cacheWriteTokens && a.cacheWrite1hTokens === b2.cacheWrite1hTokens && a.model === b2.model && a.serviceTier === b2.serviceTier;
+}
 function mergeUsage(a, b2) {
   if (!a) return b2;
   if (!b2) return a;
@@ -58021,7 +58237,7 @@ function createCodexUsageReader(options = {}) {
   const startPage = () => {
     recordSeenOnPage = false;
     previousTotal = null;
-    onFirstPage = false;
+    onFirstPage = onFirstPage && counted === 0;
   };
   return {
     startPage,
@@ -58655,6 +58871,141 @@ function parseCursorRunEventsDetailed(runs, options = {}) {
   return { turns, turnTokens };
 }
 
+// ../core/src/cursorRunRedaction.ts
+var REDACTED2 = "[REDACTED]";
+var SECRET_REST = /^[^\s\\"',;]+/;
+var CUT_PRIVATE_KEY_BODY = /\[REDACTED\][A-Za-z0-9+/=\s\\]*-----END [A-Z0-9 ]*PRIVATE KEY-----/g;
+function asRecord4(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : null;
+}
+function nonEmptyString(value) {
+  return typeof value === "string" && value !== "";
+}
+function streamedText(event) {
+  const data = asRecord4(event.data);
+  if (data === null) return null;
+  if (event.event === "assistant" || event.event === "thinking") {
+    if (typeof data.text !== "string") return null;
+    return {
+      stream: event.event,
+      served: true,
+      text: data.text,
+      withText: (text) => ({ ...event, data: { ...data, text } })
+    };
+  }
+  if (event.event !== "interaction_update") return null;
+  if (data.type === "text-delta" || data.type === "thinking-delta") {
+    if (typeof data.text !== "string") return null;
+    return {
+      stream: data.type,
+      served: false,
+      text: data.text,
+      withText: (text) => ({ ...event, data: { ...data, text } })
+    };
+  }
+  const update = asRecord4(data.taskUpdate);
+  if (data.type !== "tool-call-delta" || !nonEmptyString(data.callId) || update?.type !== "text-delta" && update?.type !== "thinking-delta" || typeof update.text !== "string") {
+    return null;
+  }
+  return {
+    stream: `${data.callId}/${update.type}`,
+    served: false,
+    text: update.text,
+    withText: (text) => ({ ...event, data: { ...data, taskUpdate: { ...update, text } } })
+  };
+}
+function endsTurnText(event, callIds) {
+  const data = asRecord4(event.data);
+  if (event.event === "tool_call") {
+    if (!nonEmptyString(data?.callId) || !nonEmptyString(data.name) || callIds.has(data.callId)) return false;
+    callIds.add(data.callId);
+    return true;
+  }
+  return event.event === "interaction_update" && data?.type === "user-message-appended" && nonEmptyString(asRecord4(data.userMessage)?.text);
+}
+function splitLikeParts(parts, redacted) {
+  const joined = parts.join("");
+  if (joined === redacted) return [...parts];
+  const shorter = Math.min(joined.length, redacted.length);
+  let start = 0;
+  while (start < shorter && joined[start] === redacted[start]) start += 1;
+  let same = 0;
+  while (same < shorter - start && joined.at(-1 - same) === redacted.at(-1 - same)) same += 1;
+  const changedEnd = joined.length - same;
+  const changed = redacted.slice(start, redacted.length - same);
+  let at = 0;
+  let placed = false;
+  return parts.map((part, index) => {
+    const end = at + part.length;
+    let text = joined.slice(at, Math.min(end, start));
+    if (!placed && (end > start || index === parts.length - 1)) {
+      text += changed;
+      placed = true;
+    }
+    text += joined.slice(Math.max(at, changedEnd), end);
+    at = end;
+    return text;
+  });
+}
+function removeCutSecretRests(texts) {
+  let cut = false;
+  return texts.map((text) => {
+    const part = cut ? text.replace(SECRET_REST, "") : text;
+    if (part !== "") cut = part.endsWith(REDACTED2);
+    return part;
+  });
+}
+function keepTextAfterRedactions(parts) {
+  const out = [...parts];
+  let open3 = null;
+  for (const k2 of out.keys()) {
+    if (open3 !== null) {
+      const rest = SECRET_REST.exec(out[k2])?.[0] ?? "";
+      out[open3] += rest;
+      out[k2] = out[k2].slice(rest.length);
+      if (out[k2] === "") continue;
+    }
+    open3 = out[k2].endsWith(REDACTED2) ? k2 : null;
+  }
+  return out;
+}
+function redactStreamTexts(texts) {
+  const parts = removeCutSecretRests(texts);
+  const joined = parts.join("");
+  const redacted = redactText(joined.replace(CUT_PRIVATE_KEY_BODY, REDACTED2));
+  const alone = redacted === joined ? parts : parts.map(redactText);
+  const split = alone.join("") === redacted ? alone : splitLikeParts(parts, redacted);
+  return keepTextAfterRedactions(split);
+}
+function mapStreams(events, servedOnly, map2) {
+  const out = [...events];
+  const callIds = /* @__PURE__ */ new Set();
+  let streams = /* @__PURE__ */ new Map();
+  const mapStreamsSoFar = () => {
+    for (const indices of streams.values()) {
+      const deltas = indices.map((index) => streamedText(out[index]));
+      const texts = map2(deltas.map((delta) => delta.text));
+      for (const [k2, delta] of deltas.entries()) {
+        if (texts[k2] !== delta.text) out[indices[k2]] = delta.withText(texts[k2]);
+      }
+    }
+    streams = /* @__PURE__ */ new Map();
+  };
+  for (const [index, event] of events.entries()) {
+    if (endsTurnText(event, callIds)) mapStreamsSoFar();
+    const delta = streamedText(event);
+    if (delta === null || servedOnly && !delta.served) continue;
+    const indices = streams.get(delta.stream);
+    if (indices) indices.push(index);
+    else streams.set(delta.stream, [index]);
+  }
+  mapStreamsSoFar();
+  return out;
+}
+function redactCursorRunEvents(events, { servedOnly = false } = {}) {
+  return mapStreams(events, servedOnly, redactStreamTexts);
+}
+
 // ../core/src/previewLinks.ts
 var SKILL_LINE = /^(?:[-*+]\s+)?[*`]*PREVIEW:\s+(\S+)\s+(https?:\/\/\S+)\s*$/gm;
 var MARKDOWN_LINE = (
@@ -58761,7 +59112,7 @@ function envelopeRuns(transcript) {
   for (const item of parsed.runs) {
     const run = item;
     if (typeof run?.runId !== "string" || typeof run.sse !== "string") continue;
-    runs.push({ runId: run.runId, events: parseSseEvents(run.sse) });
+    runs.push({ runId: run.runId, events: redactCursorRunEvents(parseSseEvents(run.sse), { servedOnly: true }) });
   }
   return runs;
 }
@@ -58774,7 +59125,7 @@ function safeJson(text) {
 }
 
 // ../core/src/scrubSentryEvent.ts
-var REDACTED2 = "[Filtered]";
+var REDACTED3 = "[Filtered]";
 var SECRET_KEY_PATTERN = /^(?:authorization|proxy-authorization|cookie|set-cookie|x-api-key|x-auth-token|x-csrf-token|x-supabase-auth|api[_-]?key|access[_-]?token|refresh[_-]?token|id[_-]?token|session[_-]?token|client[_-]?secret|password|passwd|secret|signature|token|jwt)$/i;
 var SECRET_QUERY_PARAM_PATTERN = /^(?:token|access_token|refresh_token|id_token|api_key|apikey|key|code|signature|password|secret|client_secret|state)$/i;
 var BEARER_TOKEN_PATTERN = /\bBearer\s+[\w\-._~+/=]+/gi;
@@ -58783,7 +59134,7 @@ var EMBEDDED_QUERY_SECRET_PATTERN = /([?&](?:token|access_token|refresh_token|id
 var URL_FIELD_NAMES = /* @__PURE__ */ new Set(["url", "to", "from", "href", "request_url"]);
 var MAX_DEPTH = 10;
 function scrubString(value) {
-  return value.replace(POWERPLANT_TOKEN_PATTERN, REDACTED2).replace(BEARER_TOKEN_PATTERN, `Bearer ${REDACTED2}`).replace(JWT_PATTERN, REDACTED2).replace(EMBEDDED_QUERY_SECRET_PATTERN, `$1${REDACTED2}`);
+  return value.replace(POWERPLANT_TOKEN_PATTERN, REDACTED3).replace(BEARER_TOKEN_PATTERN, `Bearer ${REDACTED3}`).replace(JWT_PATTERN, REDACTED3).replace(EMBEDDED_QUERY_SECRET_PATTERN, `$1${REDACTED3}`);
 }
 function scrubUrl(url2) {
   if (!url2) return url2;
@@ -58797,7 +59148,7 @@ function scrubUrl(url2) {
   let mutated = false;
   for (const key of [...parsed.searchParams.keys()]) {
     if (SECRET_QUERY_PARAM_PATTERN.test(key)) {
-      parsed.searchParams.set(key, REDACTED2);
+      parsed.searchParams.set(key, REDACTED3);
       mutated = true;
     }
   }
@@ -58813,7 +59164,7 @@ function scrubValue(value, depth = 0) {
   const out = {};
   for (const [key, child] of Object.entries(value)) {
     if (SECRET_KEY_PATTERN.test(key) || SECRET_QUERY_PARAM_PATTERN.test(key)) {
-      out[key] = REDACTED2;
+      out[key] = REDACTED3;
     } else if (URL_FIELD_NAMES.has(key.toLowerCase()) && typeof child === "string") {
       out[key] = scrubUrl(child);
     } else {
@@ -58834,7 +59185,7 @@ function scrubSentryEvent(event) {
       event.request.headers = scrubValue(event.request.headers);
     }
     if (event.request.cookies !== void 0) {
-      event.request.cookies = REDACTED2;
+      event.request.cookies = REDACTED3;
     }
     if (event.request.data !== void 0) {
       event.request.data = scrubValue(event.request.data);
@@ -58970,35 +59321,6 @@ function describeSyncSignals(member, now, noUpload = "no sessions uploaded yet")
   return `${line.charAt(0).toUpperCase()}${line.slice(1)}.`;
 }
 
-// ../core/src/rawTranscriptBundle.ts
-var RAW_TRANSCRIPT_BUNDLE_CONTENT_TYPE = "application/vnd.powerplant.raw-transcript-bundle";
-var RAW_TRANSCRIPT_PART_PATTERN = /^[A-Za-z0-9_-]{1,128}$/;
-var MAX_RAW_TRANSCRIPT_PARTS = 500;
-var MAX_HEADER_BYTES = 128 * 1024;
-var LENGTH_PREFIX_BYTES = 4;
-var headerSchema = external_exports.object({
-  version: external_exports.literal(1),
-  mainBytes: external_exports.number().int().positive(),
-  parts: external_exports.array(external_exports.object({ part: external_exports.string().regex(RAW_TRANSCRIPT_PART_PATTERN), bytes: external_exports.number().int().positive() })).max(MAX_RAW_TRANSCRIPT_PARTS),
-  subagents: external_exports.object({ found: external_exports.number().int().nonnegative(), skipped: external_exports.number().int().nonnegative() })
-}).refine((header) => new Set(header.parts.map((entry) => entry.part)).size === header.parts.length, {
-  message: "part ids must be unique"
-}).refine((header) => header.subagents.found === header.parts.length + header.subagents.skipped, {
-  message: "subagents.found must equal the parts carried plus the files skipped"
-});
-function encodeRawTranscriptBundle(bundle) {
-  const fields = headerSchema.parse({
-    version: 1,
-    mainBytes: bundle.main.byteLength,
-    parts: bundle.parts.map((entry) => ({ part: entry.part, bytes: entry.body.byteLength })),
-    subagents: bundle.subagents
-  });
-  const header = Buffer.from(JSON.stringify(fields), "utf8");
-  const prefix = Buffer.alloc(LENGTH_PREFIX_BYTES);
-  prefix.writeUInt32BE(header.byteLength);
-  return Buffer.concat([prefix, header, bundle.main, ...bundle.parts.map((entry) => entry.body)]);
-}
-
 // ../core/src/version.ts
 function parseReleaseVersion(version2) {
   const match = /^(\d+)\.(\d+)\.(\d+)$/.exec(version2);
@@ -59026,6 +59348,8 @@ var HARNESS_SESSION_FLAG_RULES = {
       evidence: external_exports.object({ thread_source: external_exports.enum(["subagent", "guardian_review"]) })
     },
     { flag: "subagent", evidence: external_exports.object({ source: external_exports.object({ subagent: external_exports.object({}) }) }) },
+    // A review run's reviewer names its kind as a string: {subagent: "review"}.
+    { flag: "subagent", evidence: external_exports.object({ source: external_exports.object({ subagent: external_exports.string().min(1) }) }) },
     {
       flag: "standaloneReview",
       evidence: external_exports.object({
@@ -59058,6 +59382,36 @@ function parseHarnessSessionFlags(source, evidence) {
   }
   return flags;
 }
+var CODEX_CHILD_THREAD_RULES = [
+  { kind: "review", evidence: external_exports.object({ source: external_exports.object({ subagent: external_exports.literal("review") }) }) },
+  {
+    kind: "spawned-agent",
+    evidence: external_exports.object({ source: external_exports.object({ subagent: external_exports.object({ thread_spawn: external_exports.object({}) }) }) })
+  },
+  { kind: "judge", evidence: external_exports.object({ thread_source: external_exports.literal("guardian_review") }) },
+  { kind: "judge", evidence: external_exports.object({ source: external_exports.object({ subagent: external_exports.object({ other: external_exports.literal("guardian") }) }) }) }
+];
+var codexThreadId = external_exports.string().regex(/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i).transform((threadId2) => threadId2.toLowerCase());
+var CODEX_PARENT_THREAD_RULES = [
+  external_exports.object({ parent_thread_id: codexThreadId }).transform((meta3) => meta3.parent_thread_id),
+  external_exports.object({ source: external_exports.object({ subagent: external_exports.object({ thread_spawn: external_exports.object({ parent_thread_id: codexThreadId }) }) }) }).transform((meta3) => meta3.source.subagent.thread_spawn.parent_thread_id)
+];
+function parseCodexChildThread(sessionMeta) {
+  if (parseHarnessSessionFlags("codex", sessionMeta).subagent !== true) return {};
+  const kind = CODEX_CHILD_THREAD_RULES.find((rule) => rule.evidence.safeParse(sessionMeta).success)?.kind;
+  let parentThreadId;
+  for (const rule of CODEX_PARENT_THREAD_RULES) {
+    const parsed = rule.safeParse(sessionMeta);
+    if (parsed.success) {
+      parentThreadId = parsed.data;
+      break;
+    }
+  }
+  return {
+    ...kind !== void 0 && { kind },
+    ...parentThreadId !== void 0 && { parentThreadId }
+  };
+}
 
 // ../core/src/recentSessionPage.ts
 var RECENT_SESSION_WINDOW_MS = 72 * 60 * 60 * 1e3;
@@ -78691,11 +79045,11 @@ function enrichInvokeAgentFromStream(callId, final, recordOutputs) {
   }
   const usage = isObjectLike(final.usage) ? final.usage : void 0;
   if (usage) {
-    const input2 = tokenCount(usage.inputTokens) ?? tokenCount(usage.promptTokens) ?? tokenCount(usage.tokens);
-    const output2 = tokenCount(usage.outputTokens) ?? tokenCount(usage.completionTokens);
+    const input2 = tokenCount2(usage.inputTokens) ?? tokenCount2(usage.promptTokens) ?? tokenCount2(usage.tokens);
+    const output2 = tokenCount2(usage.outputTokens) ?? tokenCount2(usage.completionTokens);
     addTokensToSpan(span, Ra, input2);
     addTokensToSpan(span, Pa, output2);
-    addTokensToSpan(span, Ma, tokenCount(usage.totalTokens) ?? sum(input2, output2));
+    addTokensToSpan(span, Ma, tokenCount2(usage.totalTokens) ?? sum(input2, output2));
   }
   if (recordOutputs) {
     const parts = partsFromTextAndToolCalls(final.text, final.toolCalls);
@@ -78823,9 +79177,9 @@ function enrichSpanOnEnd(span, data, channelOptions) {
   }
   const usage = isObjectLike(result.usage) ? result.usage : void 0;
   if (usage) {
-    const inputTokens = tokenCount(usage.inputTokens) ?? tokenCount(usage.promptTokens) ?? tokenCount(usage.tokens);
-    const outputTokens = tokenCount(usage.outputTokens) ?? tokenCount(usage.completionTokens);
-    const totalTokens = tokenCount(usage.totalTokens) ?? sum(inputTokens, outputTokens);
+    const inputTokens = tokenCount2(usage.inputTokens) ?? tokenCount2(usage.promptTokens) ?? tokenCount2(usage.tokens);
+    const outputTokens = tokenCount2(usage.outputTokens) ?? tokenCount2(usage.completionTokens);
+    const totalTokens = tokenCount2(usage.totalTokens) ?? sum(inputTokens, outputTokens);
     if (inputTokens !== void 0) {
       span.setAttribute(Ra, inputTokens);
     }
@@ -78874,7 +79228,7 @@ function getFinishReason(result) {
   }
   return isObjectLike(finishReason) ? asString(finishReason.unified) : void 0;
 }
-function tokenCount(value) {
+function tokenCount2(value) {
   return asNumber(value) ?? (isObjectLike(value) ? asNumber(value.total) : void 0);
 }
 function buildOutputMessages2(parts, finishReason) {
@@ -85910,9 +86264,9 @@ import {
   fsyncSync,
   mkdirSync as mkdirSync8,
   openSync as openSync6,
-  renameSync as renameSync4,
+  renameSync as renameSync5,
   unlinkSync as unlinkSync2,
-  writeFileSync as writeFileSync7
+  writeFileSync as writeFileSync6
 } from "node:fs";
 import os11 from "node:os";
 import path13 from "node:path";
@@ -86173,7 +86527,7 @@ function xmlEscape(value) {
 }
 
 // ../../apps/syncservice/src/status.ts
-import { existsSync as existsSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync7, renameSync as renameSync3, rmSync as rmSync6, writeFileSync as writeFileSync6 } from "node:fs";
+import { existsSync as existsSync7, mkdirSync as mkdirSync7, readdirSync as readdirSync5, readFileSync as readFileSync8, renameSync as renameSync4, rmSync as rmSync7, writeFileSync as writeFileSync5 } from "node:fs";
 import os10 from "node:os";
 import path12 from "node:path";
 
@@ -86270,7 +86624,7 @@ import { createHmac } from "node:crypto";
 // ../../apps/syncservice/src/http.ts
 var import_undici = __toESM(require_undici(), 1);
 var CLI_VERSION_HEADER = "x-powerplant-cli-version";
-var cliVersion = true ? "0.4.18" : "0.0.0-checkout";
+var cliVersion = true ? "0.4.19" : "0.0.0-checkout";
 function cliVersionHeaders() {
   return { [CLI_VERSION_HEADER]: cliVersion, "user-agent": `powerplant-cli/${cliVersion}` };
 }
@@ -86604,7 +86958,8 @@ function bindDiagnosticEnrollment(diagnostic, token) {
 }
 
 // ../../apps/syncservice/src/codexSessions.ts
-import { closeSync as closeSync3, mkdirSync as mkdirSync2, openSync as openSync3, renameSync, rmSync as rmSync2, utimesSync, writeSync } from "node:fs";
+import { createHash as createHash3 } from "node:crypto";
+import { closeSync as closeSync3, mkdirSync as mkdirSync2, openSync as openSync3, renameSync, rmSync as rmSync2, writeSync } from "node:fs";
 import os6 from "node:os";
 import path5 from "node:path";
 import { setImmediate as yieldToEventLoop } from "node:timers/promises";
@@ -86810,7 +87165,8 @@ function isPermissionError(cause) {
 }
 
 // ../../apps/syncservice/src/scan.ts
-import { closeSync as closeSync2, openSync as openSync2, readdirSync as readdirSync2, readSync as readSync2, statSync as statSync2 } from "node:fs";
+import { createHash as createHash2 } from "node:crypto";
+import { closeSync as closeSync2, fstatSync, openSync as openSync2, readdirSync as readdirSync2, readFileSync as readFileSync5, readSync as readSync2, statSync as statSync2 } from "node:fs";
 import { StringDecoder } from "node:string_decoder";
 var SESSION_UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
 var ACTIVE_GRACE_MS = SESSION_ACTIVE_WINDOW_MS;
@@ -86860,6 +87216,87 @@ function readFirstRecord(file2, matches) {
     closeSync2(fd);
   }
 }
+var TranscriptChangedError = class extends Error {
+};
+function sha256(bytes) {
+  return createHash2("sha256").update(bytes).digest("hex");
+}
+function readTranscriptIfExists(file2) {
+  let buffer;
+  try {
+    buffer = readFileSync5(file2);
+  } catch (error63) {
+    if (error63.code === "ENOENT") return null;
+    throw error63;
+  }
+  const records = buffer.subarray(0, wholeRecordsEnd(buffer));
+  return {
+    text: records.toString("utf8"),
+    prefix: { bytes: records.byteLength, sha256: sha256(records), fileBytes: buffer.byteLength }
+  };
+}
+function wholeRecordsEnd(buffer) {
+  const afterLastNewline = buffer.lastIndexOf(10) + 1;
+  if (afterLastNewline === buffer.byteLength) return afterLastNewline;
+  const tail = buffer.subarray(afterLastNewline).toString("utf8");
+  return parseJsonlLine(tail) === null ? afterLastNewline : buffer.byteLength;
+}
+function readTranscriptPrefix(file2, prefix, unchangedSinceRead) {
+  let fd;
+  try {
+    fd = openSync2(file2, "r");
+  } catch (error63) {
+    if (error63.code === "ENOENT") {
+      throw new TranscriptChangedError("The transcript is gone since the collector read it. The next pass reads it again.");
+    }
+    throw error63;
+  }
+  try {
+    if (unchangedSinceRead && fstatSync(fd).size !== prefix.fileBytes) {
+      throw new TranscriptChangedError("The transcript changed after the collector read it. The next pass reads it again.");
+    }
+    const buffer = Buffer.alloc(prefix.bytes);
+    let filled = 0;
+    while (filled < prefix.bytes) {
+      const read = readSync2(fd, buffer, filled, prefix.bytes - filled, filled);
+      if (read === 0) break;
+      filled += read;
+    }
+    if (filled < prefix.bytes || sha256(buffer) !== prefix.sha256) {
+      throw new TranscriptChangedError("The transcript changed after the collector read it. The next pass reads it again.");
+    }
+    return buffer.toString("utf8");
+  } finally {
+    closeSync2(fd);
+  }
+}
+var FirstLineTooLongError = class extends Error {
+};
+function readFirstLine(file2, maxBytes) {
+  let fd;
+  try {
+    fd = openSync2(file2, "r");
+  } catch (error63) {
+    if (error63.code === "ENOENT") return null;
+    throw error63;
+  }
+  const chunk = Buffer.alloc(READ_CHUNK_BYTES);
+  const read = [];
+  let total = 0;
+  try {
+    for (; ; ) {
+      const bytes = readSync2(fd, chunk, 0, chunk.length, null);
+      if (bytes === 0) return { line: Buffer.concat(read).toString("utf8"), complete: false };
+      const newline = chunk.subarray(0, bytes).indexOf(10);
+      read.push(Buffer.from(chunk.subarray(0, newline === -1 ? bytes : newline)));
+      if (newline !== -1) return { line: Buffer.concat(read).toString("utf8"), complete: true };
+      total += bytes;
+      if (total >= maxBytes) throw new FirstLineTooLongError(`the first line is longer than ${maxBytes} bytes`);
+    }
+  } finally {
+    closeSync2(fd);
+  }
+}
 function listDirs(dir) {
   return listEntries(dir).filter((e) => e.isDirectory()).map((e) => `${dir}/${e.name}`);
 }
@@ -86890,6 +87327,10 @@ function dominantKey(counts) {
   }
   return best;
 }
+function laterTimestamp(a, b2) {
+  if (a === void 0 || b2 === void 0) return a ?? b2;
+  return Date.parse(b2) > Date.parse(a) ? b2 : a;
+}
 function describeReadError(error63) {
   return error63 instanceof Error ? error63.message : String(error63);
 }
@@ -87143,33 +87584,58 @@ function rolloutIdentity(rolloutPath) {
 function codexMergedTranscriptsDir(home) {
   return path5.join(home, ".config", "powerplant", "codex");
 }
-function mergedTranscriptIsFresh(mergedTranscriptPath, mtimeMs) {
-  const existing = statIfExists(mergedTranscriptPath);
-  return existing !== null && Math.abs(existing.mtimeMs - mtimeMs) < 1;
+var MERGED_VERSION_HEX = 32;
+var MERGED_TRANSCRIPT_NAME = new RegExp(`^(?<threadId>.+)\\.[0-9a-f]{${MERGED_VERSION_HEX}}\\.jsonl$`);
+function mergedTranscriptPath(mergedTranscriptsDir, threadId2, pagesKey) {
+  const version2 = createHash3("sha256").update(pagesKey).digest("hex").slice(0, MERGED_VERSION_HEX);
+  return path5.join(mergedTranscriptsDir, `${threadId2}.${version2}.jsonl`);
+}
+function mergedThreadIds(mergedTranscriptsDir) {
+  const threadIds = /* @__PURE__ */ new Set();
+  for (const name of listFiles(mergedTranscriptsDir, ".jsonl")) {
+    threadIds.add(MERGED_TRANSCRIPT_NAME.exec(name)?.groups?.threadId ?? name.slice(0, -".jsonl".length));
+  }
+  return threadIds;
+}
+function removeOtherMergedTranscripts(keep) {
+  const dir = path5.dirname(keep);
+  const name = path5.basename(keep);
+  const threadId2 = MERGED_TRANSCRIPT_NAME.exec(name)?.groups?.threadId;
+  if (threadId2 === void 0) return;
+  for (const other of listFiles(dir, "")) {
+    if (other === name || !other.startsWith(`${threadId2}.`) || other.endsWith(".tmp")) continue;
+    rmSync2(path5.join(dir, other), { force: true });
+  }
+}
+function mergedPage(pageText2) {
+  return pageText2.endsWith("\n") ? pageText2 : `${pageText2}
+`;
 }
 var MergedTranscriptWriter = class {
-  constructor(mergedTranscriptPath) {
-    this.mergedTranscriptPath = mergedTranscriptPath;
-    mkdirSync2(path5.dirname(mergedTranscriptPath), { recursive: true, mode: 448 });
-    this.tmpPath = `${mergedTranscriptPath}.${process.pid}.tmp`;
+  constructor(mergedTranscriptPath2) {
+    this.mergedTranscriptPath = mergedTranscriptPath2;
+    mkdirSync2(path5.dirname(mergedTranscriptPath2), { recursive: true, mode: 448 });
+    this.tmpPath = `${mergedTranscriptPath2}.${process.pid}.tmp`;
     this.fd = openSync3(this.tmpPath, "w", 384);
   }
   mergedTranscriptPath;
   tmpPath;
   fd;
-  bytes = 0;
-  append(pageText2) {
+  /** Writes one page as mergedPage returned it. */
+  append(page) {
     if (this.fd === void 0) throw new Error("merged transcript already closed");
-    const text = pageText2.endsWith("\n") ? pageText2 : `${pageText2}
-`;
-    this.bytes += writeSync(this.fd, text);
-  }
-  /** Stamps the newest page's mtime and publishes the file; returns its size. */
-  finish(mtimeMs) {
+    writeSync(this.fd, page);
+  }
+  /** Publishes the file under its version's name in one rename, then
+   * removes the thread's other merged transcripts. A pass that saw older
+   * pages can publish after this one and remove this file: this version is
+   * then missing, so the next pass writes it again, and an upload from it
+   * waits for that pass (TranscriptChangedError). No pass reads another
+   * version's bytes under this name. */
+  finish() {
     this.close();
-    utimesSync(this.tmpPath, mtimeMs / 1e3, mtimeMs / 1e3);
     renameSync(this.tmpPath, this.mergedTranscriptPath);
-    return this.bytes;
+    removeOtherMergedTranscripts(this.mergedTranscriptPath);
   }
   abandon() {
     this.close();
@@ -87181,13 +87647,40 @@ var MergedTranscriptWriter = class {
     this.fd = void 0;
   }
 };
-function rolloutLocation(rolloutPath) {
-  const record2 = readFirstRecord(rolloutPath, (candidate) => candidate.type === "session_meta");
-  const meta3 = record2?.payload;
-  if (!meta3 || typeof meta3 !== "object" || Array.isArray(meta3)) return { kind: "session", codexClient: "unknown", totals: null, fastTotals: null };
+var MAX_SESSION_META_BYTES = 1024 * 1024;
+function readFirstSessionMeta(rolloutPath) {
+  let first;
+  try {
+    first = readFirstLine(rolloutPath, MAX_SESSION_META_BYTES);
+  } catch (error63) {
+    if (error63 instanceof FirstLineTooLongError) return { state: "fault", reason: error63.message };
+    throw error63;
+  }
+  if (first === null) return { state: "pending" };
+  let record2;
+  try {
+    record2 = JSON.parse(first.line);
+  } catch {
+    record2 = void 0;
+  }
+  if (!isRecord2(record2)) {
+    return first.complete ? { state: "fault", reason: "the first line is not a JSON object (expected a session_meta record)" } : { state: "pending" };
+  }
+  if (record2.type !== "session_meta" || !isRecord2(record2.payload)) {
+    return { state: "fault", reason: "the first record is not a session_meta record with a payload object" };
+  }
+  return { state: "session_meta", timestamp: record2.timestamp, meta: record2.payload };
+}
+function rolloutLocation(rolloutPath, first = readFirstSessionMeta(rolloutPath)) {
+  const unknown2 = { kind: "session", codexClient: "unknown", totals: null, fastTotals: null };
+  if (first.state === "session_meta") return locationOf(first.timestamp, first.meta);
+  if (first.state === "pending") return unknown2;
+  const record2 = readFirstRecord(rolloutPath, (candidate) => candidate.type === "session_meta" && isRecord2(candidate.payload));
+  return record2 === null ? unknown2 : locationOf(record2.timestamp, record2.payload);
+}
+function locationOf(startedAt, meta3) {
   const { cwd, id, session_id: fallbackId } = meta3;
   const sessionId = id ?? fallbackId;
-  const startedAt = record2?.timestamp;
   return {
     codexClient: classifyCodexClient(meta3),
     kind: isSidecarThread(meta3) ? "subagent" : "session",
@@ -87198,9 +87691,314 @@ function rolloutLocation(rolloutPath) {
     ...typeof cwd === "string" && cwd !== "" && { cwd }
   };
 }
+var FirstLineFormatError = class extends Error {
+};
+function readThreadLink(rolloutPath) {
+  const first = readFirstSessionMeta(rolloutPath);
+  if (first.state === "fault") throw new FirstLineFormatError(first.reason);
+  return first.state === "pending" ? void 0 : parseCodexChildThread(first.meta);
+}
 function isSidecarThread(meta3) {
   return parseHarnessSessionFlags("codex", meta3).subagent === true;
 }
+var ATTACHED_CHILD_KINDS = /* @__PURE__ */ new Set(["review"]);
+function attachedParentOf(link) {
+  return link?.kind !== void 0 && ATTACHED_CHILD_KINDS.has(link.kind) ? link.parentThreadId : void 0;
+}
+function threadIdTimeMs(threadId2) {
+  if (!SESSION_UUID.test(threadId2) || threadId2[14] !== "7") return void 0;
+  return Number.parseInt(threadId2.slice(0, 8) + threadId2.slice(9, 13), 16);
+}
+var THREAD_ID_TIME_MARGIN_MS = 24 * 60 * 60 * 1e3;
+var PARENT_BRING_IN_MARGIN_MS = 60 * 1e3;
+function mayBeParentOf(parent, childMadeMs) {
+  return (parent.madeMs === void 0 || parent.madeMs <= childMadeMs + PARENT_BRING_IN_MARGIN_MS) && parent.writtenMs >= childMadeMs;
+}
+function mayBeChildOf(threadTimeMs, parentTimeMs) {
+  return threadTimeMs === void 0 || parentTimeMs === void 0 || threadTimeMs + THREAD_ID_TIME_MARGIN_MS >= parentTimeMs;
+}
+var CodexThreadLinks = class {
+  /** `readLink` is a test seam for the first-record read. */
+  constructor(readLink = readThreadLink) {
+    this.readLink = readLink;
+  }
+  readLink;
+  byPath = /* @__PURE__ */ new Map();
+  /** Rollouts whose read failed, with the file's changed time at that
+   * failure: a failure is reported once for each changed time. */
+  failedAt = /* @__PURE__ */ new Map();
+  /** Rollouts whose first line was not whole yet, with the file's changed
+   * time and how many reads found it so. */
+  incomplete = /* @__PURE__ */ new Map();
+  /** Rollouts whose first line is a format fault. Codex writes a rollout's
+   * first line once and only appends after it, so the fault belongs to the
+   * file, not to one of its changed times: it is reported once. */
+  faulted = /* @__PURE__ */ new Set();
+  /** Unlinked rollouts counted as an unreadable child of their plausible
+   * parents, by thread id, with the time in that id. */
+  unresolved = /* @__PURE__ */ new Map();
+  /** Threads whose capture counted such a rollout that has since linked or
+   * gone: each comes into every pass until its corrected capture is
+   * uploaded, refused, or has failed CORRECTION_UPLOAD_ATTEMPTS times
+   * (settleRecoveries), with the session the last pass made of it and how
+   * many uploads of it failed. */
+  recovering = /* @__PURE__ */ new Map();
+  /** Keeps what another read of the same first record found. */
+  remember(rolloutPath, link) {
+    this.byPath.set(rolloutPath, link);
+    this.failedAt.delete(rolloutPath);
+    this.incomplete.delete(rolloutPath);
+    this.faulted.delete(rolloutPath);
+  }
+  /** What an earlier read of this rollout's first record found, if any. */
+  known(rolloutPath) {
+    return this.byPath.get(rolloutPath);
+  }
+  /** Unlinked rollouts that made their plausible parents partial: thread
+   * id to the time in that id. */
+  unresolvedRollouts() {
+    return [...this.unresolved];
+  }
+  /** The rollout linked or is gone: its plausible parents are to be sent
+   * again (recover). */
+  resolve(threadId2) {
+    this.unresolved.delete(threadId2);
+  }
+  /**
+   * Reads again the first record of each unlinked rollout still on this
+   * machine (unresolved), in a pass's window or not, and whether or not a
+   * possible parent uploads now: only a read can link it, and until it links
+   * its guessed parents stay partial. A read failure that clears with no
+   * file changing (EMFILE, EIO, a permission restored) so clears on the next
+   * pass. A read that failed earlier this pass (`unread`) is not repeated, a
+   * first line found torn is left to its rule (isTorn), and a format fault
+   * is final for the file. Returns the failures to report, once for each
+   * change to a file, and every thread whose read failed this call, so the
+   * pass does not read it again (childrenOf).
+   */
+  async readUnresolved(threads, unread) {
+    const failed2 = [];
+    const stillUnread = [];
+    for (const threadId2 of this.unresolved.keys()) {
+      const thread = threads.get(threadId2);
+      if (thread === void 0 || unread.has(threadId2)) continue;
+      const { rolloutPath, changedMs } = thread;
+      if (this.byPath.has(rolloutPath) || this.faulted.has(rolloutPath) || this.isTorn(rolloutPath, changedMs)) continue;
+      if (!await this.read(rolloutPath, changedMs, failed2)) stillUnread.push(threadId2);
+    }
+    return { failed: failed2, unread: stillUnread };
+  }
+  recover(threadId2) {
+    if (!this.recovering.has(threadId2)) this.recovering.set(threadId2, { session: null, failedUploads: 0 });
+  }
+  /** The threads owed a corrected capture. */
+  recoveringThreads() {
+    return [...this.recovering.keys()];
+  }
+  /** The session this pass made of a thread owed a corrected capture. */
+  noteCollected(threadId2, session) {
+    const owed = this.recovering.get(threadId2);
+    if (owed !== void 0) owed.session = session;
+  }
+  /** Drops a thread owed a corrected capture that has nothing to upload
+   * (gone, out of scope, not a session, or its own read failed): nothing
+   * corrects it until it changes, and a change admits it through the
+   * window. */
+  forgetRecovery(threadId2) {
+    this.recovering.delete(threadId2);
+  }
+  /**
+   * After a pass's uploads, from what became of each owed thread's session
+   * this pass: "shipped" (the server holds it) and "refused" (this machine
+   * will never ship it: no raw storage, another machine owns it, its
+   * metadata is out of policy or deferred) settle it. "failed" counts one
+   * failed upload; a thread whose uploads failed CORRECTION_UPLOAD_ATTEMPTS
+   * times is settled too, and returned so the pass can name it once. A
+   * thread the pass left out ("waiting") stays owed at no cost.
+   */
+  settleRecoveries(outcome) {
+    const givenUp = [];
+    for (const [threadId2, owed] of this.recovering) {
+      const result = owed.session === null ? "waiting" : outcome(owed.session);
+      owed.session = null;
+      if (result === "waiting") continue;
+      if (result === "failed") {
+        owed.failedUploads += 1;
+        if (owed.failedUploads < CORRECTION_UPLOAD_ATTEMPTS) continue;
+        givenUp.push(threadId2);
+      }
+      this.recovering.delete(threadId2);
+    }
+    return givenUp;
+  }
+  /** Records that a read of the rollout failed at the thread's changed time;
+   * true when the failure is new and so is to be reported: the first for
+   * the rollout, or the first since the thread changed, as a read error
+   * (EACCES, EIO) can clear when the file changes. Every reader of a Codex
+   * rollout reports through this or noteFormatFault, so a failure is named
+   * once whether the thread is in the pass's window or not. */
+  noteFailure(rolloutPath, changedMs) {
+    const known = this.failedAt.get(rolloutPath) === changedMs;
+    this.failedAt.set(rolloutPath, changedMs);
+    return !known;
+  }
+  /** Records that the rollout's first line is a format fault; true the
+   * first time for the file, whatever Codex appends to it later. */
+  noteFormatFault(rolloutPath) {
+    const known = this.faulted.has(rolloutPath);
+    this.faulted.add(rolloutPath);
+    return !known;
+  }
+  /**
+   * The child threads of each parent uploading now. `threads` maps each
+   * thread on this machine to its lead rollout, the one its first record is
+   * read from, and the thread's newest change; what is known about other
+   * paths is forgotten. Reads the first record of each thread not yet known
+   * that could be such a child: a thread whose id time is more than
+   * THREAD_ID_TIME_MARGIN_MS older than every parent's is not read.
+   * `parentsWrittenMs` gives each uploading thread's newest write, and each
+   * entry of `threads` its own (`writtenMs`). A rollout whose read fails, or
+   * that is in `unread` (its read failed earlier this pass, already
+   * reported), counts as an unreadable child of each uploading thread that
+   * may be its parent, or whose attached child, or a thread that child
+   * started, may be (mayBeParentOf), so no capture is recorded complete
+   * while one of its children may be missing. Only a Codex rollout
+   * named by a UUIDv7 thread id can be such a child: a failed read of any
+   * other file in the store is reported and counts for no parent. A failed
+   * read is tried again on every pass and returned in `failed` once for each
+   * change to the file, so one bad file never ends the pass or repeats in
+   * every pass's report.
+   */
+  async childrenOf(threads, parentsWrittenMs, unread = /* @__PURE__ */ new Set()) {
+    const leadPaths = new Set([...threads.values()].map((thread) => thread.rolloutPath));
+    for (const known of [this.byPath, this.failedAt, this.incomplete, this.faulted]) {
+      for (const rolloutPath of known.keys()) if (!leadPaths.has(rolloutPath)) known.delete(rolloutPath);
+    }
+    const children = /* @__PURE__ */ new Map();
+    const failed2 = [];
+    const parents = new Map([...parentsWrittenMs].map(([threadId2, writtenMs]) => [threadId2, { madeMs: threadIdTimeMs(threadId2), writtenMs }]));
+    if (parents.size === 0) return { children, failed: failed2 };
+    const parentTimes = [...parents];
+    const childrenOfParent = (parentThreadId) => {
+      const found = children.get(parentThreadId) ?? { attached: [], leftOut: [], unreadable: [] };
+      children.set(parentThreadId, found);
+      return found;
+    };
+    const unreadable = [];
+    for (const [threadId2, { rolloutPath, changedMs }] of threads) {
+      if (parents.has(threadId2)) continue;
+      if (!this.byPath.has(rolloutPath)) {
+        const rollout = SESSION_UUID.test(threadId2);
+        const madeMs = threadIdTimeMs(threadId2);
+        if (rollout && !parentTimes.some(([, parent]) => mayBeChildOf(madeMs, parent.madeMs))) continue;
+        if (this.isTorn(rolloutPath, changedMs)) continue;
+        if (unread.has(threadId2) || !await this.read(rolloutPath, changedMs, failed2)) {
+          if (rollout && madeMs !== void 0) unreadable.push([threadId2, madeMs]);
+          continue;
+        }
+      }
+      const link = this.byPath.get(rolloutPath);
+      if (link?.parentThreadId === void 0 || !parents.has(link.parentThreadId)) continue;
+      const found = childrenOfParent(link.parentThreadId);
+      (attachedParentOf(link) === void 0 ? found.leftOut : found.attached).push(threadId2);
+    }
+    const covered = this.addDescendantsOfAttached(threads, parents, children);
+    for (const [threadId2, madeMs] of unreadable) {
+      let counted = false;
+      for (const [rootId, root] of parentTimes) {
+        const possible = [
+          root,
+          ...(covered.get(rootId) ?? []).map((id) => ({ madeMs: threadIdTimeMs(id), writtenMs: threads.get(id).writtenMs }))
+        ];
+        if (!possible.some((parent) => mayBeParentOf(parent, madeMs))) continue;
+        childrenOfParent(rootId).unreadable.push(threadId2);
+        counted = true;
+      }
+      if (counted) this.unresolved.set(threadId2, madeMs);
+    }
+    return { children, failed: failed2 };
+  }
+  /** The threads an attached child started (a reviewer's own agents and
+   * judges), and theirs in turn, name a thread that uploads as a part, not
+   * as a session: they are left out of the root session's capture. A thread
+   * met twice is counted once, so a malformed link cycle ends. Returns, for
+   * each root, its attached children and the threads they started: the
+   * threads whose own children count under the root. */
+  addDescendantsOfAttached(threads, parents, children) {
+    const childrenByParent = /* @__PURE__ */ new Map();
+    for (const [threadId2, { rolloutPath }] of threads) {
+      const parentThreadId = this.byPath.get(rolloutPath)?.parentThreadId;
+      if (parentThreadId === void 0 || parents.has(parentThreadId)) continue;
+      childrenByParent.set(parentThreadId, [...childrenByParent.get(parentThreadId) ?? [], threadId2]);
+    }
+    const covered = /* @__PURE__ */ new Map();
+    for (const [rootId, found] of children) {
+      const seen = new Set(found.attached);
+      const pending = [...found.attached];
+      for (let threadId2 = pending.pop(); threadId2 !== void 0; threadId2 = pending.pop()) {
+        for (const descendant of childrenByParent.get(threadId2) ?? []) {
+          if (seen.has(descendant)) continue;
+          seen.add(descendant);
+          found.leftOut.push(descendant);
+          pending.push(descendant);
+        }
+      }
+      covered.set(rootId, [...seen]);
+    }
+    return covered;
+  }
+  /** Whether the rollout's first line stayed unwhole through
+   * INCOMPLETE_FIRST_LINE_READS reads and the file has not changed since:
+   * Codex left it torn, so reading it again would find the same. Such a file
+   * is part of one line and holds no turns or usage, so no capture misses
+   * anything without it: it is reported, never counted as a child. */
+  isTorn(rolloutPath, changedMs) {
+    const seen = this.incomplete.get(rolloutPath);
+    return seen?.changedMs === changedMs && seen.reads >= INCOMPLETE_FIRST_LINE_READS;
+  }
+  /** One read of a rollout's first record; false when it failed. */
+  async read(rolloutPath, changedMs, failed2) {
+    await yieldToEventLoop();
+    let link;
+    try {
+      link = this.readLink(rolloutPath);
+    } catch (error63) {
+      const fault = error63 instanceof FirstLineFormatError;
+      if (fault ? this.noteFormatFault(rolloutPath) : this.noteFailure(rolloutPath, changedMs)) failed2.push({ rolloutPath, error: error63 });
+      return false;
+    }
+    if (link !== void 0) {
+      this.remember(rolloutPath, link);
+      return true;
+    }
+    const seen = this.incomplete.get(rolloutPath);
+    const reads = seen?.changedMs === changedMs ? seen.reads + 1 : 1;
+    this.incomplete.set(rolloutPath, { changedMs, reads });
+    if (reads >= INCOMPLETE_FIRST_LINE_READS && this.noteFailure(rolloutPath, changedMs)) {
+      failed2.push({ rolloutPath, error: new Error(`the first line is still not whole after ${reads} reads of the unchanged file`) });
+    }
+    return true;
+  }
+};
+var CodexThreadReads = class {
+  byThread = /* @__PURE__ */ new Map();
+  /** What a full read found when the thread's files were `files`
+   * (threadFilesKey): its summary and prefix, null for a thread holding no
+   * session; undefined when none is kept for those files. */
+  get(threadId2, files) {
+    const kept = this.byThread.get(threadId2);
+    return kept?.files === files ? kept.read : void 0;
+  }
+  set(threadId2, files, read) {
+    this.byThread.set(threadId2, { files, read });
+  }
+  /** Forgets the threads no longer on this machine. */
+  keepOnly(threadIds) {
+    for (const threadId2 of this.byThread.keys()) if (!threadIds.has(threadId2)) this.byThread.delete(threadId2);
+  }
+};
+var CORRECTION_UPLOAD_ATTEMPTS = 3;
+var INCOMPLETE_FIRST_LINE_READS = 3;
 function repoFullNameFrom(url2) {
   const fullName = parseGithubRepo(url2);
   return fullName ? { repoFullName: fullName } : {};
@@ -87240,8 +88038,9 @@ async function collectCodexSessions(options = {}) {
   const capture2 = options.capture ?? captureEverythingUnresolved;
   const maxBytes = options.maxTranscriptBytes ?? MAX_TRANSCRIPT_FILE_BYTES;
   const mergedTranscriptsDir = options.mergedTranscriptsDir ?? codexMergedTranscriptsDir(options.homeDir ?? os6.homedir());
+  const links = options.threadLinks ?? new CodexThreadLinks();
   const items = [];
-  const candidates = [];
+  const candidates = /* @__PURE__ */ new Map();
   const unreadable = [];
   const skips = { skippedOutOfScope: 0, skippedNoRepo: 0 };
   let skippedSubagentThreads = 0;
@@ -87287,80 +88086,135 @@ async function collectCodexSessions(options = {}) {
     if (thread === void 0) byThread.set(file2.identity.threadId, [file2]);
     else thread.push(file2);
   }
-  for (const [threadId2, observed] of byThread) {
+  const threadOf = (threadId2, stored) => {
+    const named = stored.filter((file2) => {
+      if (file2.discoverySessionIds === void 0) return true;
+      const { sessionId } = rolloutLocation(file2.rolloutPath);
+      return sessionId !== void 0 && file2.discoverySessionIds.includes(sessionId);
+    });
+    if (named.length === 0) return null;
+    const threadFiles = named.length > 1 ? orderPages(named) : named;
+    return {
+      threadId: threadId2,
+      harnessSessionId: harnessSessionIdOf(threadFiles[0].rolloutPath),
+      files: threadFiles,
+      ...threadFiles.length > 1 && {
+        mergedTranscriptPath: mergedTranscriptPath(mergedTranscriptsDir, threadId2, threadFilesKey(threadFiles))
+      },
+      mtimeMs: Math.max(...threadFiles.map((file2) => file2.mtimeMs)),
+      sizeBytes: threadFiles.reduce((sum2, file2) => sum2 + file2.sizeBytes, 0),
+      archived: threadFiles.every((file2) => file2.archived)
+    };
+  };
+  const countedTooLarge = /* @__PURE__ */ new Set();
+  const tooLarge = (thread) => {
+    if (thread.sizeBytes <= maxBytes) return false;
+    if (countedTooLarge.has(thread.threadId)) return true;
+    countedTooLarge.add(thread.threadId);
+    skippedTooLarge += 1;
+    observeFileDiagnostic(options.onFileDiagnostic, {
+      path: thread.files[0].rolloutPath,
+      reason: "too_large",
+      sizeBytes: thread.sizeBytes
+    });
+    return true;
+  };
+  const mergedBefore = options.locationsOnly ? /* @__PURE__ */ new Set() : mergedThreadIds(mergedTranscriptsDir);
+  const evaluated = /* @__PURE__ */ new Set();
+  const failedThreads = /* @__PURE__ */ new Set();
+  const report = (rolloutPath, name, error63) => {
+    unreadable.push(`${name}: ${describeReadError(error63)}`);
+    observeFileDiagnostic(options.onFileDiagnostic, {
+      path: rolloutPath,
+      reason: "unreadable",
+      sizeBytes: null,
+      errorCode: diagnosticErrorCode(error63)
+    });
+  };
+  const reportOnce = (files2, name, error63) => {
+    const lead = leadRollout(files2);
+    if (links.noteFailure(lead.rolloutPath, newestChange(files2))) report(lead.rolloutPath, name, error63);
+  };
+  const namedParents = [];
+  const bringInParentOf = (link) => {
+    if (link?.parentThreadId !== void 0) namedParents.push(link.parentThreadId);
+  };
+  const parentsOfAttachedChildren = [];
+  const unlinkedInWindow = [];
+  const admit = async (threadId2, observed, admission) => {
+    const applyWindow = admission === "window";
+    const guess = admission === "possible-parent";
     const stored = dedupeStoreCopies(observed);
-    let harnessSessionId = harnessSessionIdOf((stored.find((file2) => !file2.identity.page) ?? stored[0]).rolloutPath);
+    const lead = leadRollout(stored);
+    let harnessSessionId = harnessSessionIdOf(lead.rolloutPath);
     try {
-      const mergedTranscriptPath = stored.length > 1 ? path5.join(mergedTranscriptsDir, `${threadId2}.jsonl`) : void 0;
-      const changedMs = Math.max(...stored.map((file2) => file2.changedMs));
-      if (options.sinceMs !== void 0 && changedMs < options.sinceMs) {
-        const neverMerged = mergedTranscriptPath !== void 0 && !options.locationsOnly && statIfExists(mergedTranscriptPath) === null;
-        if (!neverMerged) continue;
+      if (applyWindow && options.sinceMs !== void 0 && newestChange(stored) < options.sinceMs) {
+        const neverMerged = stored.length > 1 && !options.locationsOnly && !mergedBefore.has(threadId2);
+        if (!neverMerged) return;
       }
+      evaluated.add(threadId2);
       await yieldToEventLoop();
-      const named = stored.filter((file2) => {
-        if (file2.discoverySessionIds === void 0) return true;
-        const { sessionId } = rolloutLocation(file2.rolloutPath);
-        return sessionId !== void 0 && file2.discoverySessionIds.includes(sessionId);
-      });
-      if (named.length === 0) continue;
-      const threadFiles = named.length > 1 ? orderPages(named) : named;
-      const base = threadFiles[0];
-      harnessSessionId = harnessSessionIdOf(base.rolloutPath);
-      const mtimeMs = Math.max(...threadFiles.map((file2) => file2.mtimeMs));
-      const sizeBytes = threadFiles.reduce((sum2, file2) => sum2 + file2.sizeBytes, 0);
-      if (sizeBytes > maxBytes) {
-        skippedTooLarge += 1;
-        observeFileDiagnostic(options.onFileDiagnostic, {
-          path: base.rolloutPath,
-          reason: "too_large",
-          sizeBytes
-        });
-        continue;
-      }
-      const location = rolloutLocation(base.rolloutPath);
+      const thread = threadOf(threadId2, stored);
+      if (thread === null) return;
+      harnessSessionId = thread.harnessSessionId;
+      const base = thread.files[0];
+      const first = readFirstSessionMeta(base.rolloutPath);
+      const link = first.state === "session_meta" ? parseCodexChildThread(first.meta) : void 0;
+      if (link !== void 0) links.remember(base.rolloutPath, link);
+      if (guess && (first.state === "pending" || link?.parentThreadId !== void 0)) return;
+      bringInParentOf(link);
+      if (first.state === "fault") {
+        if (applyWindow) unlinkedInWindow.push(threadId2);
+        if (links.noteFormatFault(lead.rolloutPath)) {
+          report(lead.rolloutPath, `${harnessSessionId} (child-thread link)`, new Error(first.reason));
+        }
+      }
+      if (guess ? thread.sizeBytes > maxBytes : tooLarge(thread)) return;
+      const location = rolloutLocation(base.rolloutPath, first);
+      if (guess && location.kind === "subagent") return;
       if (location.kind === "subagent") {
-        skippedSubagentThreads += 1;
-        continue;
+        const parentThreadId = attachedParentOf(link);
+        if (!options.locationsOnly && parentThreadId !== void 0) parentsOfAttachedChildren.push(parentThreadId);
+        else skippedSubagentThreads += 1;
+        return;
       }
       const decision = captureDecision(location.cwd, capture2);
       if (!decision.capture) {
-        countCaptureSkip(skips, decision.reason);
-        continue;
+        if (!guess) countCaptureSkip(skips, decision.reason);
+        return;
       }
-      const thread = {
-        harnessSessionId,
-        files: threadFiles,
-        ...threadFiles.length > 1 && mergedTranscriptPath !== void 0 && { mergedTranscriptPath },
-        mtimeMs,
-        archived: threadFiles.every((file2) => file2.archived)
-      };
       if (options.locationsOnly) {
         items.push({
-          mtimeMs,
+          mtimeMs: thread.mtimeMs,
           transcriptPath: base.rolloutPath,
           ...location.cwd && { cwd: location.cwd },
           item: {
             harness: "codex-local",
             harnessSessionId,
-            status: now - mtimeMs < ACTIVE_GRACE_MS ? "active" : "inactive",
+            status: now - thread.mtimeMs < ACTIVE_GRACE_MS ? "active" : "inactive",
             archived: thread.archived,
             capturedVia: decision.via
           }
         });
-        continue;
+        return;
       }
-      candidates.push({ thread, ...location.cwd && { cwd: location.cwd }, decision });
-    } catch (error63) {
-      unreadable.push(`${harnessSessionId}: ${describeReadError(error63)}`);
-      observeFileDiagnostic(options.onFileDiagnostic, {
-        path: stored[0].rolloutPath,
-        reason: "unreadable",
-        sizeBytes: null,
-        errorCode: diagnosticErrorCode(error63)
+      candidates.set(threadId2, {
+        thread,
+        ...location.cwd && { cwd: location.cwd },
+        decision,
+        children: [],
+        leftOutChildren: 0,
+        unreadableChildren: 0
       });
+    } catch (error63) {
+      const known = links.known(lead.rolloutPath);
+      bringInParentOf(known);
+      if (applyWindow && known === void 0) unlinkedInWindow.push(threadId2);
+      failedThreads.add(threadId2);
+      reportOnce(stored, harnessSessionId, error63);
     }
-  }
+  };
+  for (const [threadId2, observed] of byThread) await admit(threadId2, observed, "window");
   if (options.locationsOnly) {
     return {
       sessions: items.sort((a, b2) => b2.mtimeMs - a.mtimeMs),
@@ -87373,91 +88227,259 @@ async function collectCodexSessions(options = {}) {
       largestMergedBytes: 0
     };
   }
-  candidates.sort((a, b2) => b2.thread.mtimeMs - a.thread.mtimeMs);
-  const chosen = options.maxSessions === void 0 ? candidates : candidates.slice(0, options.maxSessions);
+  for (let index = 0; index < namedParents.length; index += 1) {
+    const parentThreadId = namedParents[index];
+    const observed = byThread.get(parentThreadId);
+    if (!evaluated.has(parentThreadId) && observed !== void 0) await admit(parentThreadId, observed, "named");
+  }
+  const plausibleParentsOf = (childId, childMadeMs) => [...byThread].filter(
+    ([threadId2, observed]) => threadId2 !== childId && mayBeParentOf({ madeMs: threadIdTimeMs(threadId2), writtenMs: Math.max(...observed.map((file2) => file2.mtimeMs)) }, childMadeMs)
+  );
+  const rootThroughAttached = (threadId2) => {
+    const seen = /* @__PURE__ */ new Set();
+    let current = threadId2;
+    let lastLink;
+    while (!seen.has(current)) {
+      seen.add(current);
+      const observed = byThread.get(current);
+      if (observed === void 0) return void 0;
+      const link = links.known(leadRollout(dedupeStoreCopies(observed)).rolloutPath);
+      if (link?.parentThreadId === void 0) return lastLink === void 0 || attachedParentOf(lastLink) !== void 0 ? current : void 0;
+      lastLink = link;
+      current = link.parentThreadId;
+    }
+    return void 0;
+  };
+  for (const childId of unlinkedInWindow) {
+    const childMadeMs = threadIdTimeMs(childId);
+    if (childMadeMs === void 0 || candidates.has(childId)) continue;
+    for (const [threadId2, observed] of plausibleParentsOf(childId, childMadeMs)) {
+      if (!evaluated.has(threadId2)) await admit(threadId2, observed, "possible-parent");
+      const root = rootThroughAttached(threadId2);
+      const rootObserved = root === void 0 ? void 0 : byThread.get(root);
+      if (root !== void 0 && rootObserved !== void 0 && !evaluated.has(root)) await admit(root, rootObserved, "possible-parent");
+    }
+  }
+  const leads = /* @__PURE__ */ new Map();
+  for (const [threadId2, observed] of byThread) {
+    const vouched = dedupeStoreCopies(observed).filter((file2) => file2.discoverySessionIds === void 0);
+    if (vouched.length === 0) continue;
+    leads.set(threadId2, {
+      rolloutPath: leadRollout(vouched).rolloutPath,
+      changedMs: newestChange(vouched),
+      writtenMs: Math.max(...vouched.map((file2) => file2.mtimeMs))
+    });
+  }
+  const retried = await links.readUnresolved(leads, failedThreads);
+  for (const { rolloutPath, error: error63 } of retried.failed) report(rolloutPath, harnessSessionIdOf(rolloutPath), error63);
+  for (const threadId2 of retried.unread) failedThreads.add(threadId2);
+  for (const [childId, childMadeMs] of links.unresolvedRollouts()) {
+    const observed = byThread.get(childId);
+    if (observed !== void 0 && links.known(leadRollout(dedupeStoreCopies(observed)).rolloutPath) === void 0) continue;
+    links.resolve(childId);
+    for (const [threadId2] of plausibleParentsOf(childId, childMadeMs)) {
+      const root = rootThroughAttached(threadId2);
+      if (root !== void 0) links.recover(root);
+    }
+  }
+  for (const threadId2 of links.recoveringThreads()) {
+    const observed = byThread.get(threadId2);
+    if (observed !== void 0 && !evaluated.has(threadId2)) await admit(threadId2, observed, "possible-parent");
+    if (!candidates.has(threadId2)) links.forgetRecovery(threadId2);
+  }
+  for (const parentThreadId of parentsOfAttachedChildren) {
+    if (!candidates.has(parentThreadId)) skippedSubagentThreads += 1;
+  }
+  const countReviewersLeftBehind = (parentThreadId) => {
+    skippedSubagentThreads += parentsOfAttachedChildren.filter((threadId2) => threadId2 === parentThreadId).length;
+  };
+  const parentsWrittenMs = new Map([...candidates].map(([threadId2, candidate]) => [threadId2, candidate.thread.mtimeMs]));
+  const { children, failed: failed2 } = await links.childrenOf(leads, parentsWrittenMs, failedThreads);
+  for (const { rolloutPath, error: error63 } of failed2) report(rolloutPath, harnessSessionIdOf(rolloutPath), error63);
+  for (const [parentThreadId, found] of children) {
+    const parent = candidates.get(parentThreadId);
+    parent.children = found.attached;
+    parent.leftOutChildren = found.leftOut.length;
+    parent.unreadableChildren = found.unreadable.length;
+  }
+  options.threadReads?.keepOnly(new Set(byThread.keys()));
+  const rankOf = (candidate) => {
+    let rank = candidate.thread.mtimeMs;
+    for (const childId of candidate.children) {
+      if (failedThreads.has(childId) || !RAW_TRANSCRIPT_PART_PATTERN.test(childId)) continue;
+      const files2 = dedupeStoreCopies(byThread.get(childId));
+      if (files2.reduce((sum2, file2) => sum2 + file2.sizeBytes, 0) > maxBytes) continue;
+      rank = Math.max(rank, ...files2.map((file2) => file2.mtimeMs));
+    }
+    return rank;
+  };
+  const ranks = new Map([...candidates.values()].map((candidate) => [candidate, rankOf(candidate)]));
+  const ordered = [...candidates.values()].sort((a, b2) => ranks.get(b2) - ranks.get(a));
+  const chosen = options.maxSessions === void 0 ? ordered : ordered.slice(0, options.maxSessions);
+  for (const candidate of ordered.slice(chosen.length)) countReviewersLeftBehind(candidate.thread.threadId);
   const threadNames = chosen.length > 0 ? loadThreadNames(sessionsDir) : /* @__PURE__ */ new Map();
-  for (const candidate of chosen) {
-    await yieldToEventLoop();
-    const { thread, cwd, decision } = candidate;
+  const readThread = (thread) => {
+    const files2 = threadFilesKey(thread.files);
+    const merged = thread.mergedTranscriptPath;
+    const mergedFresh = merged === void 0 || statIfExists(merged) !== null;
+    let read = mergedFresh ? options.threadReads?.get(thread.threadId, files2) : void 0;
+    if (read === void 0) read = readThreadInFull(thread, !mergedFresh);
+    if (read !== null && read !== "vanished" && merged !== void 0 && statIfExists(merged)?.size !== read.prefix.bytes) {
+      read = readThreadInFull(thread, true);
+    }
+    if (read === "vanished") return "vanished";
+    options.threadReads?.set(thread.threadId, files2, read);
+    if (read === null) return null;
+    const { summary, prefix } = read;
+    if (merged === void 0) return { summary, prefix, mtimeMs: thread.mtimeMs, transcriptPath: thread.files[0].rolloutPath };
+    mergedThreads += 1;
+    largestMergedBytes = Math.max(largestMergedBytes, prefix.bytes);
+    return { summary, prefix, mtimeMs: thread.mtimeMs, transcriptPath: merged };
+  };
+  const readThreadInFull = (thread, rewrite) => {
     let writer;
     try {
-      const rewrite = thread.mergedTranscriptPath !== void 0 && !mergedTranscriptIsFresh(thread.mergedTranscriptPath, thread.mtimeMs);
       if (thread.mergedTranscriptPath !== void 0 && rewrite) writer = new MergedTranscriptWriter(thread.mergedTranscriptPath);
       const pages = [];
       const usage = createCodexUsageReader();
-      let vanished = false;
+      let rolloutPrefix;
+      const merged = { bytes: 0, sha256: createHash3("sha256") };
       for (const [index, file2] of thread.files.entries()) {
-        const text = readIfExists(file2.rolloutPath);
-        if (text === null) {
-          vanished = true;
-          break;
+        const rollout = readTranscriptIfExists(file2.rolloutPath);
+        if (rollout === null) {
+          writer?.abandon();
+          return "vanished";
         }
         if (index > 0) usage.startPage();
-        const page = parseCodexRollout(text, usage);
+        const page = parseCodexRollout(rollout.text, usage);
         if (page === null) continue;
         pages.push(page);
-        writer?.append(text);
+        if (thread.mergedTranscriptPath === void 0) {
+          rolloutPrefix = rollout.prefix;
+        } else {
+          const text = mergedPage(rollout.text);
+          merged.bytes += Buffer.byteLength(text);
+          merged.sha256.update(text);
+          writer?.append(text);
+        }
       }
-      if (vanished || pages.length === 0) {
+      const prefix = thread.mergedTranscriptPath === void 0 ? rolloutPrefix : { bytes: merged.bytes, sha256: merged.sha256.digest("hex"), fileBytes: merged.bytes };
+      if (pages.length === 0 || prefix === void 0) {
         writer?.abandon();
-        continue;
+        return null;
+      }
+      writer?.finish();
+      return { summary: foldRolloutPages(pages, usage.finish()), prefix };
+    } catch (error63) {
+      writer?.abandon();
+      throw error63;
+    }
+  };
+  const readChildren = (candidate) => {
+    const parent = candidate.thread;
+    const reads = [];
+    const subagents = {
+      files: [],
+      skipped: candidate.leftOutChildren + candidate.unreadableChildren,
+      skippedUnreadable: candidate.unreadableChildren
+    };
+    for (const childId of candidate.children) {
+      const stored = dedupeStoreCopies(byThread.get(childId));
+      let childName = harnessSessionIdOf(stored[0].rolloutPath);
+      try {
+        const child = threadOf(childId, stored);
+        if (child === null) {
+          subagents.skipped += 1;
+          continue;
+        }
+        childName = child.harnessSessionId;
+        if (tooLarge(child) || !RAW_TRANSCRIPT_PART_PATTERN.test(childId)) {
+          subagents.skipped += 1;
+          continue;
+        }
+        const read = readThread(child);
+        if (read === "vanished") return "vanished";
+        if (read === null) {
+          subagents.skipped += 1;
+          subagents.skippedUnreadable += 1;
+          continue;
+        }
+        reads.push(read);
+        subagents.files.push({ part: childId, path: read.transcriptPath, prefix: read.prefix });
+      } catch (error63) {
+        subagents.skipped += 1;
+        subagents.skippedUnreadable += 1;
+        reportOnce(stored, `${parent.harnessSessionId} (subagent ${childName})`, error63);
       }
-      const summary = foldRolloutPages(pages, usage.finish());
-      let transcriptUploadSourcePath = thread.files[0].rolloutPath;
-      if (thread.mergedTranscriptPath !== void 0) {
-        const mergedBytes = writer ? writer.finish(thread.mtimeMs) : statIfExists(thread.mergedTranscriptPath)?.size ?? 0;
-        writer = void 0;
-        transcriptUploadSourcePath = thread.mergedTranscriptPath;
-        mergedThreads += 1;
-        largestMergedBytes = Math.max(largestMergedBytes, mergedBytes);
+    }
+    return { reads, capture: subagents };
+  };
+  for (const candidate of chosen) {
+    await yieldToEventLoop();
+    const { thread, cwd, decision } = candidate;
+    try {
+      const children2 = readChildren(candidate);
+      if (children2 === "vanished") continue;
+      const parent = readThread(thread);
+      if (parent === "vanished") continue;
+      if (parent === null) {
+        countReviewersLeftBehind(thread.threadId);
+        links.forgetRecovery(thread.threadId);
+        continue;
       }
+      const mtimeMs = Math.max(parent.mtimeMs, ...children2.reads.map((read) => read.mtimeMs));
+      const summary = parent.summary;
+      const latestChildFirst = [...children2.reads].sort((a, b2) => b2.mtimeMs - a.mtimeMs).map((read) => read.summary);
+      const model = summary.model ?? latestChildFirst.find((child) => child.model !== void 0)?.model;
+      const speedMode = summary.speedMode ?? latestChildFirst.find((child) => child.speedMode !== void 0)?.speedMode;
+      const endedAt = latestChildFirst.reduce((latest2, child) => laterTimestamp(latest2, child.endedAt), summary.endedAt);
+      const usage = sessionUsage([summary, ...latestChildFirst]);
       const repoDir = summary.repoName ?? (cwd ? path5.basename(cwd) : void 0);
       const repoFullName = decision.repoFullName ?? summary.repoFullName;
       const title = summary.sessionId ? threadNames.get(summary.sessionId) : void 0;
-      items.push({
-        mtimeMs: thread.mtimeMs,
+      const collected = {
+        mtimeMs,
         codexClient: summary.codexClient,
         ...summary.noninteractive && { codexNoninteractive: true },
-        transcriptPath: transcriptUploadSourcePath,
+        transcriptPath: parent.transcriptPath,
+        transcriptPrefix: parent.prefix,
+        subagents: children2.capture,
         ...cwd && { cwd },
         item: {
           harness: "codex-local",
           harnessSessionId: thread.harnessSessionId,
-          status: now - thread.mtimeMs < ACTIVE_GRACE_MS ? "active" : "inactive",
+          status: now - mtimeMs < ACTIVE_GRACE_MS ? "active" : "inactive",
           archived: thread.archived,
           ...summary.standaloneReview && { automation: true },
           ...summary.startedAt && { startedAt: summary.startedAt },
-          ...summary.endedAt && { endedAt: summary.endedAt },
-          ...summary.model && { model: summary.model },
-          ...summary.speedMode && { speedMode: summary.speedMode },
+          ...endedAt && { endedAt },
+          ...model && { model },
+          ...speedMode && { speedMode },
           ...title && { title: redactText(title).slice(0, 500) },
           // input_tokens already includes the cached subset — it IS the
           // all-in input-class total. No cache-write figure exists, so
           // none is sent (unmeasured, never 0).
-          ...summary.totals && { inputTokens: summary.totals.input },
-          ...summary.totals && { outputTokens: summary.totals.output },
-          ...summary.totals && { cacheReadTokens: summary.totals.cached },
-          ...summary.fastTotals && { fastInputTokens: summary.fastTotals.input },
-          ...summary.fastTotals && { fastOutputTokens: summary.fastTotals.output },
-          ...summary.fastTotals && { fastCacheReadTokens: summary.fastTotals.cached },
+          ...usage.totals && { inputTokens: usage.totals.input },
+          ...usage.totals && { outputTokens: usage.totals.output },
+          ...usage.totals && { cacheReadTokens: usage.totals.cached },
+          ...usage.fastTotals && { fastInputTokens: usage.fastTotals.input },
+          ...usage.fastTotals && { fastOutputTokens: usage.fastTotals.output },
+          ...usage.fastTotals && { fastCacheReadTokens: usage.fastTotals.cached },
           // OpenAI prompt-cache writes have no separate price in the current
           // session cost model; zero is measured here, not an invented count.
-          ...summary.fastTotals && { fastCacheWriteTokens: 0 },
+          ...usage.fastTotals && { fastCacheWriteTokens: 0 },
           ...repoDir && { repoDir },
           ...summary.gitBranch && { gitBranch: summary.gitBranch },
           ...repoFullName && { repoFullName },
           capturedVia: decision.via
         }
-      });
+      };
+      items.push(collected);
+      links.noteCollected(thread.threadId, collected);
     } catch (error63) {
-      writer?.abandon();
-      unreadable.push(`${thread.harnessSessionId}: ${describeReadError(error63)}`);
-      observeFileDiagnostic(options.onFileDiagnostic, {
-        path: thread.files[0].rolloutPath,
-        reason: "unreadable",
-        sizeBytes: null,
-        errorCode: diagnosticErrorCode(error63)
-      });
+      countReviewersLeftBehind(thread.threadId);
+      links.forgetRecovery(thread.threadId);
+      reportOnce(thread.files, thread.harnessSessionId, error63);
     }
   }
   return {
@@ -87466,11 +88488,33 @@ async function collectCodexSessions(options = {}) {
     skippedSubagentThreads,
     skippedTooLarge,
     unreadable,
-    heldBack: candidates.length - chosen.length,
+    heldBack: ordered.length - chosen.length,
     mergedThreads,
     largestMergedBytes
   };
 }
+function sessionUsage(threads) {
+  if (threads.some((thread) => thread.model !== void 0 && thread.totals === null)) return { totals: null, fastTotals: null };
+  const measured = threads.filter((thread) => thread.totals !== null);
+  if (measured.length === 0) return { totals: null, fastTotals: null };
+  const add = (a, b2) => ({ input: a.input + b2.input, cached: a.cached + b2.cached, output: a.output + b2.output });
+  const zero = { input: 0, cached: 0, output: 0 };
+  return {
+    totals: measured.map((thread) => thread.totals).reduce(add, zero),
+    fastTotals: measured.every((thread) => thread.fastTotals !== null) ? measured.map((thread) => thread.fastTotals).reduce(add, zero) : null
+  };
+}
+function leadRollout(threadFiles) {
+  return threadFiles.find((file2) => !file2.identity.page) ?? threadFiles[0];
+}
+function newestChange(threadFiles) {
+  return Math.max(...threadFiles.map((file2) => file2.changedMs));
+}
+function threadFilesKey(threadFiles) {
+  return threadFiles.map((file2) => `${file2.rolloutPath}
+${file2.mtimeMs}
+${file2.sizeBytes}`).join("\n");
+}
 function dedupeStoreCopies(threadFiles) {
   const byName = /* @__PURE__ */ new Map();
   for (const file2 of threadFiles) {
@@ -87500,9 +88544,8 @@ function codexThreadCwd(threadId2, sessionsDir = path5.join(os6.homedir(), ".cod
 }
 
 // ../../apps/syncservice/src/cursorTranscriptFile.ts
-import { createHash as createHash3 } from "node:crypto";
+import { createHash as createHash5 } from "node:crypto";
 import {
-  chmodSync as chmodSync3,
   closeSync as closeSync4,
   existsSync as existsSync3,
   lstatSync as lstatSync2,
@@ -87510,9 +88553,7 @@ import {
   openSync as openSync4,
   readSync as readSync3,
   readdirSync as readdirSync3,
-  realpathSync as realpathSync2,
-  utimesSync as utimesSync3,
-  writeFileSync as writeFileSync3
+  realpathSync as realpathSync2
 } from "node:fs";
 import os8 from "node:os";
 import path7 from "node:path";
@@ -87569,8 +88610,8 @@ function unhandledObservations(shapes, externalId) {
 }
 
 // ../../apps/syncservice/src/cursorLocal.ts
-import { createHash as createHash2 } from "node:crypto";
-import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync as mkdirSync3, utimesSync as utimesSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import { createHash as createHash4 } from "node:crypto";
+import { chmodSync as chmodSync2, existsSync as existsSync2, mkdirSync as mkdirSync3, renameSync as renameSync2, rmSync as rmSync3, utimesSync, writeFileSync as writeFileSync2 } from "node:fs";
 import os7 from "node:os";
 import path6 from "node:path";
 import { fileURLToPath } from "node:url";
@@ -87644,9 +88685,20 @@ var cachedMetaSchema = external_exports.object({
 });
 function extractedTranscriptFileName(composerId) {
   const sanitized = composerId.replace(/[^A-Za-z0-9._-]/g, "_").slice(0, 80);
-  const hash2 = createHash2("sha256").update(composerId).digest("hex").slice(0, 8);
+  const hash2 = createHash4("sha256").update(composerId).digest("hex").slice(0, 8);
   return `${sanitized}-${hash2}.jsonl`;
 }
+function replaceExtractedTranscript(transcriptPath, body, atime, mtime) {
+  const tmpPath = `${transcriptPath}.${process.pid}.tmp`;
+  try {
+    writeFileSync2(tmpPath, body, { encoding: "utf8", mode: 384 });
+    utimesSync(tmpPath, atime, mtime);
+    renameSync2(tmpPath, transcriptPath);
+  } catch (error63) {
+    rmSync3(tmpPath, { force: true });
+    throw error63;
+  }
+}
 function workspaceFolderOf(cursorUserDir, workspaceId) {
   if (workspaceId === "" || workspaceId.includes(path6.sep) || workspaceId.includes("/") || workspaceId.includes("..")) {
     return void 0;
@@ -88143,9 +89195,7 @@ function collectFromStore(db, userDir, options, result, knownIds) {
           extractedTranscriptsDirReady = true;
         }
         const body = [JSON.stringify(meta3), ...transcript.serialized, ""].join("\n");
-        if (extractedTranscriptStat !== null) chmodSync2(transcriptUploadSourcePath, 384);
-        writeFileSync2(transcriptUploadSourcePath, body, { encoding: "utf8", mode: 384 });
-        utimesSync2(transcriptUploadSourcePath, new Date(lastUpdatedAt), new Date(lastUpdatedAt));
+        replaceExtractedTranscript(transcriptUploadSourcePath, body, new Date(lastUpdatedAt), new Date(lastUpdatedAt));
       }
       if (hasCaptureGaps(omissions)) result.partiallyInterpreted += 1;
       for (const observation of unhandledObservations(unhandled, raw.composerId)) {
@@ -88358,7 +89408,7 @@ function cursorTranscriptRecordsDir(home) {
 function cursorTranscriptRecordPath(home, sessionId) {
   return path7.join(
     cursorTranscriptRecordsDir(home),
-    `${createHash3("sha256").update(sessionId).digest("hex")}.json`
+    `${createHash5("sha256").update(sessionId).digest("hex")}.json`
   );
 }
 function collectCursorTranscriptFiles(options, isDatabaseSession, result, databaseExtractedTranscriptsDir, extractedTranscriptFileName2) {
@@ -88381,7 +89431,7 @@ function collectCursorTranscriptFiles(options, isDatabaseSession, result, databa
       if (!lstatSync2(recordPath).isFile()) continue;
       const text = readBounded(recordPath, 40 * 1024);
       const record2 = transcriptDiscoveryRecordSchema2.parse(text === null ? null : JSON.parse(text));
-      if (file2 !== `${createHash3("sha256").update(record2.sessionId).digest("hex")}.json`) continue;
+      if (file2 !== `${createHash5("sha256").update(record2.sessionId).digest("hex")}.json`) continue;
       if (isDatabaseSession(record2.sessionId) || existsSync3(path7.join(databaseExtractedTranscriptsDir, extractedTranscriptFileName2(record2.sessionId))))
         continue;
       if (record2.transcriptPath === null || record2.workspaceRoots.length !== 1) continue;
@@ -88475,9 +89525,7 @@ function collectCursorTranscriptFiles(options, isDatabaseSession, result, databa
           continue;
         }
         mkdirSync4(nativeExtractedTranscriptsDir, { recursive: true, mode: 448 });
-        if (extractedTranscriptStat !== null) chmodSync3(transcriptUploadSourcePath, 384);
-        writeFileSync3(transcriptUploadSourcePath, body, { mode: 384 });
-        utimesSync3(transcriptUploadSourcePath, stat.atime, stat.mtime);
+        replaceExtractedTranscript(transcriptUploadSourcePath, body, stat.atime, stat.mtime);
         omissions = Object.keys(written).length > 0 ? written : void 0;
         unhandled = prepared.unhandled;
       }
@@ -88504,7 +89552,7 @@ function collectCursorTranscriptFiles(options, isDatabaseSession, result, databa
 }
 
 // ../../apps/syncservice/src/hookInstall.ts
-import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync5, rmSync as rmSync3, writeFileSync as writeFileSync4 } from "node:fs";
+import { existsSync as existsSync4, mkdirSync as mkdirSync5, readFileSync as readFileSync6, rmSync as rmSync4, writeFileSync as writeFileSync3 } from "node:fs";
 import os9 from "node:os";
 import path8 from "node:path";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
@@ -88597,7 +89645,7 @@ function installCollectorHooks(homeDir = os9.homedir()) {
   const hookDir = path8.join(homeDir, ".config", "powerplant", "hooks");
   mkdirSync5(hookDir, { recursive: true });
   for (const script of HOOK_SCRIPTS) {
-    writeFileSync4(path8.join(hookDir, script), readFileSync5(hookSourcePath(script), "utf8"), {
+    writeFileSync3(path8.join(hookDir, script), readFileSync6(hookSourcePath(script), "utf8"), {
       mode: 493
     });
   }
@@ -88605,18 +89653,18 @@ function installCollectorHooks(homeDir = os9.homedir()) {
   const settingsPath = claudeSettingsPath(homeDir);
   let settingsText;
   try {
-    settingsText = readFileSync5(settingsPath, "utf8");
+    settingsText = readFileSync6(settingsPath, "utf8");
   } catch {
     settingsText = null;
   }
   const merged = mergeCollectorHooks(settingsText, (script) => `node "${path8.join(hookDir, script)}"`);
   if (merged.action === "write") {
     mkdirSync5(settingsDir, { recursive: true });
-    writeFileSync4(settingsPath, merged.text);
+    writeFileSync3(settingsPath, merged.text);
   }
   if (merged.action !== "skip") {
     for (const retired of RETIRED_HOOK_WIRINGS) {
-      rmSync3(path8.join(hookDir, retired.script), { force: true });
+      rmSync4(path8.join(hookDir, retired.script), { force: true });
     }
   }
   return {
@@ -88627,7 +89675,7 @@ function installCollectorHooks(homeDir = os9.homedir()) {
 }
 
 // ../../apps/syncservice/src/lifecycleJournal.ts
-import { closeSync as closeSync5, fstatSync, openSync as openSync5, readdirSync as readdirSync4, readSync as readSync4, rmSync as rmSync4 } from "node:fs";
+import { closeSync as closeSync5, fstatSync as fstatSync2, openSync as openSync5, readdirSync as readdirSync4, readSync as readSync4, rmSync as rmSync5 } from "node:fs";
 import path9 from "node:path";
 var LIFECYCLE_JOURNAL_DIRNAME = "lifecycle-journal";
 var LIFECYCLE_JOURNAL_RETENTION_DAYS = 7;
@@ -88694,7 +89742,7 @@ function readAppendedLines(file2, offset) {
     throw error63;
   }
   try {
-    const size = fstatSync(fd).size;
+    const size = fstatSync2(fd).size;
     const start = size < offset ? 0 : offset;
     const buffer = Buffer.alloc(size - start);
     const bytes = readSync4(fd, buffer, 0, buffer.length, start);
@@ -88752,10 +89800,10 @@ function createLifecycleJournalReader(home, harnesses = COLLECTOR_SESSION_HARNES
     deleteExpired(nowMs = Date.now()) {
       const floorMs = lifecycleJournalRetentionFloorMs(nowMs);
       for (const file2 of allDayFiles()) {
-        if (Date.parse(`${path9.basename(file2).slice(0, 10)}T00:00:00Z`) < floorMs) rmSync4(file2, { force: true });
+        if (Date.parse(`${path9.basename(file2).slice(0, 10)}T00:00:00Z`) < floorMs) rmSync5(file2, { force: true });
       }
       if (legacyFile !== null && (statIfExists(legacyFile)?.mtimeMs ?? floorMs) < floorMs) {
-        rmSync4(legacyFile, { force: true });
+        rmSync5(legacyFile, { force: true });
       }
       for (const held of [latest2, latestBoundary]) {
         for (const [key, entry] of held) {
@@ -88779,10 +89827,10 @@ import {
   existsSync as existsSync5,
   lstatSync as lstatSync3,
   mkdirSync as mkdirSync6,
-  readFileSync as readFileSync6,
-  renameSync as renameSync2,
-  rmSync as rmSync5,
-  writeFileSync as writeFileSync5
+  readFileSync as readFileSync7,
+  renameSync as renameSync3,
+  rmSync as rmSync6,
+  writeFileSync as writeFileSync4
 } from "node:fs";
 import path10 from "node:path";
 import { randomUUID } from "node:crypto";
@@ -88887,7 +89935,7 @@ function installHarnessHook(harness, home) {
       return { provider: nativeName, settings: "skip", detail: NON_REGULAR_CONFIG };
     }
     mode = stat.mode & 511;
-    original = readFileSync6(configPath, "utf8");
+    original = readFileSync7(configPath, "utf8");
   } catch (error63) {
     if (!(error63 instanceof Error && "code" in error63 && error63.code === "ENOENT")) throw error63;
   }
@@ -88903,9 +89951,9 @@ function installHarnessHook(harness, home) {
     return { provider: nativeName, settings: "skip", detail: merged.reason };
   }
   mkdirSync6(hookDir, { recursive: true });
-  writeAtomic(scriptPath, readFileSync6(hookSourcePath(script), "utf8"), 448);
+  writeAtomic(scriptPath, readFileSync7(hookSourcePath(script), "utf8"), 448);
   if (merged.action === "write") {
-    const current = existsSync5(configPath) ? readFileSync6(configPath, "utf8") : null;
+    const current = existsSync5(configPath) ? readFileSync7(configPath, "utf8") : null;
     if (current !== original)
       return {
         provider: nativeName,
@@ -88919,10 +89967,10 @@ function installHarnessHook(harness, home) {
 function writeAtomic(file2, text, mode) {
   const temporary = `${file2}.${randomUUID()}.tmp`;
   try {
-    writeFileSync5(temporary, text, { mode, flag: "wx" });
-    renameSync2(temporary, file2);
+    writeFileSync4(temporary, text, { mode, flag: "wx" });
+    renameSync3(temporary, file2);
   } finally {
-    rmSync5(temporary, { force: true });
+    rmSync6(temporary, { force: true });
   }
 }
 function installHarnessHooks(home) {
@@ -89287,8 +90335,8 @@ function controlFilePath(appEnv, homeDir) {
 function writeAtomically(file2, payload) {
   mkdirSync7(path12.dirname(file2), { recursive: true });
   const tmp = `${file2}.${process.pid}.tmp`;
-  writeFileSync6(tmp, payload);
-  renameSync3(tmp, file2);
+  writeFileSync5(tmp, payload);
+  renameSync4(tmp, file2);
 }
 function writeCollectorStatus(appEnv, status, homeDir) {
   writeAtomically(statusFilePath(appEnv, homeDir), JSON.stringify(status, null, 2));
@@ -89339,7 +90387,7 @@ function menuOpenRequestPath(appEnv, homeDir) {
 function writeRefreshRequest(menuDir) {
   const dir = path12.join(menuDir, MENU_REFRESH_DIRNAME);
   if (!existsSync7(dir)) return;
-  writeFileSync6(path12.join(dir, "request"), (/* @__PURE__ */ new Date()).toISOString(), { mode: 384 });
+  writeFileSync5(path12.join(dir, "request"), (/* @__PURE__ */ new Date()).toISOString(), { mode: 384 });
 }
 function menuShownStatus(status) {
   const passFailed = status.lastPass?.ok === false;
@@ -89408,7 +90456,7 @@ function carriedUploadClock(previous, machineId) {
 function readCollectorStatus(appEnv, homeDir) {
   let raw;
   try {
-    raw = readFileSync7(statusFilePath(appEnv, homeDir), "utf8");
+    raw = readFileSync8(statusFilePath(appEnv, homeDir), "utf8");
   } catch {
     return { file: "missing" };
   }
@@ -89424,7 +90472,7 @@ function readCollectorStatus(appEnv, homeDir) {
 function readCollectorControl(appEnv, homeDir) {
   let raw;
   try {
-    raw = readFileSync7(controlFilePath(appEnv, homeDir), "utf8");
+    raw = readFileSync8(controlFilePath(appEnv, homeDir), "utf8");
   } catch {
     return { paused: false };
   }
@@ -89441,10 +90489,10 @@ function writeCollectorControl(appEnv, control, homeDir) {
   writeAtomically(controlFilePath(appEnv, homeDir), JSON.stringify(control, null, 2));
 }
 function clearCollectorControl(appEnv, homeDir) {
-  rmSync6(controlFilePath(appEnv, homeDir), { force: true });
+  rmSync7(controlFilePath(appEnv, homeDir), { force: true });
 }
 function clearCollectorStatus(appEnv, homeDir) {
-  rmSync6(statusFilePath(appEnv, homeDir), { force: true });
+  rmSync7(statusFilePath(appEnv, homeDir), { force: true });
 }
 function describeDaemonState(read, probes = {}) {
   if (read.file === "invalid") return { state: "unreadable" };
@@ -89457,6 +90505,9 @@ function describeDaemonState(read, probes = {}) {
   }
   return { state: "running", status: read.status };
 }
+function backgroundSyncIsRunning(appEnv, homeDir) {
+  return describeDaemonState(readCollectorStatus(appEnv, homeDir)).state === "running";
+}
 function isPidAlive(pid) {
   try {
     process.kill(pid, 0);
@@ -89584,12 +90635,12 @@ var MacosCredentialStore = class {
     try {
       const fileFd = openSync6(temporary, "wx", 384);
       try {
-        writeFileSync7(fileFd, envelope);
+        writeFileSync6(fileFd, envelope);
         fsyncSync(fileFd);
       } finally {
         closeSync6(fileFd);
       }
-      renameSync4(temporary, this.file);
+      renameSync5(temporary, this.file);
       const directoryFd = openSync6(this.directory, "r");
       try {
         fsyncSync(directoryFd);
@@ -89809,8 +90860,8 @@ function saveCredentials(appEnv, credentials) {
   }
   const file2 = fallbackFile(appEnv);
   mkdirSync9(path14.dirname(file2), { recursive: true });
-  writeFileSync8(file2, payload, { mode: 384 });
-  chmodSync4(file2, 384);
+  writeFileSync7(file2, payload, { mode: 384 });
+  chmodSync3(file2, 384);
   return file2;
 }
 function loadCredentials(appEnv) {
@@ -89820,7 +90871,7 @@ function loadCredentials(appEnv) {
   }
   let raw;
   try {
-    raw = readFileSync8(fallbackFile(appEnv), "utf8");
+    raw = readFileSync9(fallbackFile(appEnv), "utf8");
   } catch (cause) {
     if (isCredentialStoreAbsent(cause)) return null;
     throw new Error(
@@ -89855,13 +90906,407 @@ function fallbackFile(appEnv) {
 
 // ../../apps/syncservice/src/enroll.ts
 import { spawn } from "node:child_process";
-import { createHash as createHash4, randomBytes as randomBytes2 } from "node:crypto";
+import { createHash as createHash6, randomBytes as randomBytes2 } from "node:crypto";
 import http5 from "node:http";
-import os13 from "node:os";
+import os14 from "node:os";
 
 // ../../apps/syncservice/src/upload.ts
-import { readFileSync as readFileSync9 } from "node:fs";
+import { readFileSync as readFileSync10 } from "node:fs";
 import { gzipSync } from "node:zlib";
+
+// ../../apps/syncservice/src/claudeCode.ts
+import { readdirSync as readdirSync6 } from "node:fs";
+import os13 from "node:os";
+import path15 from "node:path";
+import { setImmediate as yieldToEventLoop2 } from "node:timers/promises";
+function parseClaudeCodeTranscript(text) {
+  const usageByMessage = /* @__PURE__ */ new Map();
+  const modelCounts = /* @__PURE__ */ new Map();
+  const timestamps = [];
+  let title;
+  let cwd;
+  let gitBranch;
+  let entrypoint;
+  let anonCounter = 0;
+  let speedMode;
+  for (const record2 of parseJsonl(text)) {
+    if (record2.type === "custom-title" && typeof record2.customTitle === "string") {
+      title = record2.customTitle;
+      continue;
+    }
+    if (record2.type === "ai-title" && typeof record2.aiTitle === "string") {
+      title = record2.aiTitle;
+      continue;
+    }
+    if (cwd === void 0 && typeof record2.cwd === "string" && record2.cwd !== "") cwd = record2.cwd;
+    if (typeof record2.entrypoint === "string" && record2.entrypoint !== "") {
+      entrypoint ??= record2.entrypoint;
+    }
+    if (typeof record2.gitBranch === "string" && record2.gitBranch !== "") {
+      gitBranch ??= record2.gitBranch;
+    }
+    if (typeof record2.timestamp === "string") timestamps.push(record2.timestamp);
+    if (record2.type !== "assistant") continue;
+    const message2 = record2.message;
+    if (!message2 || message2.model === "<synthetic>") continue;
+    const id = message2.id ?? (typeof record2.requestId === "string" ? record2.requestId : void 0) ?? (typeof record2.uuid === "string" ? record2.uuid : void 0) ?? `anon-${anonCounter++}`;
+    const previousMessage = usageByMessage.get(id);
+    const isNewMessage = previousMessage === void 0;
+    const speedValue = message2.usage?.speed;
+    const observedSpeed = speedModeOf(speedValue);
+    const messageSpeed = observedSpeed ?? previousMessage?.speedMode;
+    if (speedValue !== void 0) speedMode = observedSpeed ?? "unknown";
+    if (message2.usage) {
+      usageByMessage.set(id, {
+        usage: toUsage(message2.usage),
+        ...messageSpeed && { speedMode: messageSpeed }
+      });
+    } else if (isNewMessage) {
+      usageByMessage.set(id, {
+        usage: { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }
+      });
+    }
+    if (isNewMessage && typeof message2.model === "string") {
+      modelCounts.set(message2.model, (modelCounts.get(message2.model) ?? 0) + 1);
+    }
+  }
+  if (usageByMessage.size === 0 && timestamps.length === 0) return null;
+  const summed = [...usageByMessage.values()].map((entry) => entry.usage).reduce(addUsage, {
+    input: 0,
+    cacheRead: 0,
+    cacheCreation: 0,
+    output: 0
+  });
+  const speedFullyMeasured = usageByMessage.size > 0 && [...usageByMessage.values()].every((entry) => entry.speedMode !== void 0);
+  const fastUsage = speedFullyMeasured ? [...usageByMessage.values()].filter((entry) => entry.speedMode === "fast").map((entry) => entry.usage).reduce(addUsage, { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }) : null;
+  return {
+    startedAt: timestamps[0],
+    endedAt: timestamps[timestamps.length - 1],
+    model: dominantKey(modelCounts),
+    usage: usageByMessage.size > 0 ? summed : null,
+    fastUsage,
+    ...speedMode && { speedMode },
+    title,
+    turnCount: usageByMessage.size,
+    cwd,
+    gitBranch,
+    entrypoint
+  };
+}
+var AGENT_SDK_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-py", "sdk-ts"]);
+function isAutomationEntrypoint(entrypoint) {
+  return entrypoint !== void 0 && AGENT_SDK_ENTRYPOINTS.has(entrypoint);
+}
+function sessionKey(identity) {
+  return JSON.stringify([identity.harness, identity.harnessSessionId]);
+}
+async function collectClaudeCodeSessions(options = {}) {
+  const claudeDir = options.claudeDir ?? path15.join(os13.homedir(), ".claude");
+  const now = options.now ?? Date.now();
+  const capture2 = options.capture ?? captureEverythingUnresolved;
+  const maxBytes = options.maxTranscriptBytes ?? MAX_TRANSCRIPT_FILE_BYTES;
+  const projectsDir = path15.join(claudeDir, "projects");
+  const items = [];
+  const skips = { skippedOutOfScope: 0, skippedNoRepo: 0 };
+  const candidates = [];
+  const unreadable = [];
+  let skippedTooLarge = 0;
+  const home = path15.dirname(claudeDir);
+  const lifecycle = options.lifecycle ?? readLifecycleJournal(home, now, ["claude-local"]);
+  for (const projectDir of listDirs(projectsDir)) {
+    for (const entry of listFiles(projectDir, ".jsonl")) {
+      await yieldToEventLoop2();
+      const transcriptPath = path15.join(projectDir, entry);
+      const stat = statIfExists(transcriptPath);
+      if (!stat) continue;
+      const sessionId = path15.basename(entry, ".jsonl");
+      const subagents = options.locationsOnly ? NO_SUBAGENTS : listSubagents(path15.join(projectDir, sessionId, "subagents"));
+      const mtimeMs = Math.max(stat.mtimeMs, subagents.workflows.mtimeMs, ...subagents.files.map((file2) => file2.mtimeMs ?? 0));
+      if (options.sinceMs !== void 0 && mtimeMs < options.sinceMs) continue;
+      if (stat.size > maxBytes) {
+        skippedTooLarge += 1;
+        observeFileDiagnostic(options.onFileDiagnostic, {
+          path: transcriptPath,
+          reason: "too_large",
+          sizeBytes: stat.size
+        });
+        continue;
+      }
+      const endObservedAt = observedSessionEnd(lifecycle.latestBoundary("claude-local", sessionId), mtimeMs);
+      const status = endObservedAt === null && now - mtimeMs < ACTIVE_GRACE_MS ? "active" : "inactive";
+      try {
+        const cwd = transcriptCwd(transcriptPath);
+        const decision = captureDecision(cwd, capture2);
+        if (!decision.capture) {
+          countCaptureSkip(skips, decision.reason);
+          continue;
+        }
+        if (options.locationsOnly) {
+          items.push({
+            mtimeMs: stat.mtimeMs,
+            transcriptPath,
+            ...cwd && { cwd },
+            item: { harness: "claude-local", harnessSessionId: sessionId, status, capturedVia: decision.via }
+          });
+          continue;
+        }
+        candidates.push({
+          transcriptPath,
+          sessionId,
+          mtimeMs,
+          subagents,
+          status,
+          endObservedAt,
+          ...cwd && { cwd },
+          decision
+        });
+      } catch (error63) {
+        unreadable.push(`${sessionId}: ${describeReadError(error63)}`);
+        observeFileDiagnostic(options.onFileDiagnostic, {
+          path: transcriptPath,
+          reason: "unreadable",
+          sizeBytes: null,
+          errorCode: diagnosticErrorCode(error63)
+        });
+      }
+    }
+  }
+  if (options.locationsOnly) {
+    return {
+      sessions: items.sort((a, b2) => b2.mtimeMs - a.mtimeMs),
+      ...skips,
+      skippedTooLarge,
+      unreadable,
+      heldBack: 0
+    };
+  }
+  candidates.sort((a, b2) => b2.mtimeMs - a.mtimeMs);
+  const chosen = options.maxSessions === void 0 ? candidates : candidates.slice(0, options.maxSessions);
+  for (const candidate of chosen) {
+    await yieldToEventLoop2();
+    const { transcriptPath, sessionId, mtimeMs, subagents, status, endObservedAt, cwd, decision } = candidate;
+    try {
+      const transcript = readTranscriptIfExists(transcriptPath);
+      if (transcript === null) continue;
+      const summary = parseClaudeCodeTranscript(transcript.text);
+      if (!summary) continue;
+      const usage = addSubagentUsage(
+        summary.usage,
+        summary.fastUsage,
+        subagents.files,
+        { maxBytes, sessionId, onFileDiagnostic: options.onFileDiagnostic }
+      );
+      skippedTooLarge += usage.skippedTooLarge;
+      unreadable.push(...usage.unreadable);
+      const endedAt = endObservedAt ?? laterTimestamp(summary.endedAt, usage.endedAt);
+      items.push({
+        mtimeMs,
+        transcriptPath,
+        transcriptPrefix: transcript.prefix,
+        subagents: {
+          files: usage.capture.files,
+          skipped: usage.capture.skipped + subagents.workflows.count,
+          skippedUnreadable: usage.capture.skippedUnreadable + subagents.workflows.unreadable
+        },
+        ...cwd && { cwd },
+        item: {
+          harness: "claude-local",
+          harnessSessionId: sessionId,
+          status,
+          ...summary.startedAt && { startedAt: summary.startedAt },
+          ...endedAt && { endedAt },
+          ...summary.model && { model: summary.model },
+          ...summary.speedMode && { speedMode: summary.speedMode },
+          // Total input-class tokens the source reported (uncached + cache
+          // reads + cache writes) — a real reported total, not an estimate.
+          // The cache breakdown rides along: pricing bills reads at 0.1×
+          // and writes at 1.25×, so collapsing it would inflate estimates.
+          ...usage.total && {
+            inputTokens: usage.total.input + usage.total.cacheRead + usage.total.cacheCreation
+          },
+          ...usage.total && { outputTokens: usage.total.output },
+          ...usage.total && { cacheReadTokens: usage.total.cacheRead },
+          ...usage.total && { cacheWriteTokens: usage.total.cacheCreation },
+          ...usage.fast && {
+            fastInputTokens: usage.fast.input + usage.fast.cacheRead + usage.fast.cacheCreation,
+            fastOutputTokens: usage.fast.output,
+            fastCacheReadTokens: usage.fast.cacheRead,
+            fastCacheWriteTokens: usage.fast.cacheCreation
+          },
+          ...summary.title && { title: redactText(summary.title).slice(0, 500) },
+          ...isAutomationEntrypoint(summary.entrypoint) && { automation: true },
+          // The PR-join coordinates: the checkout's directory name (bare
+          // repo, not the local path) and the branch the work started on.
+          ...cwd && { repoDir: path15.basename(cwd) },
+          ...summary.gitBranch && { gitBranch: summary.gitBranch },
+          ...decision.repoFullName && { repoFullName: decision.repoFullName },
+          capturedVia: decision.via
+        }
+      });
+    } catch (error63) {
+      unreadable.push(`${sessionId}: ${describeReadError(error63)}`);
+      observeFileDiagnostic(options.onFileDiagnostic, {
+        path: transcriptPath,
+        reason: "unreadable",
+        sizeBytes: null,
+        errorCode: diagnosticErrorCode(error63)
+      });
+    }
+  }
+  return {
+    sessions: items.sort((a, b2) => b2.mtimeMs - a.mtimeMs),
+    ...skips,
+    skippedTooLarge,
+    unreadable,
+    heldBack: candidates.length - chosen.length
+  };
+}
+function transcriptCwd(transcriptPath) {
+  const record2 = readFirstRecord(
+    transcriptPath,
+    (candidate) => typeof candidate.cwd === "string" && candidate.cwd !== ""
+  );
+  return typeof record2?.cwd === "string" ? record2.cwd : void 0;
+}
+function toUsage(u) {
+  const n = (value) => typeof value === "number" ? value : 0;
+  return {
+    input: n(u.input_tokens),
+    cacheRead: n(u.cache_read_input_tokens),
+    cacheCreation: n(u.cache_creation_input_tokens),
+    output: n(u.output_tokens)
+  };
+}
+function speedModeOf(value) {
+  return value === "fast" || value === "standard" ? value : void 0;
+}
+function addUsage(a, b2) {
+  return {
+    input: a.input + b2.input,
+    cacheRead: a.cacheRead + b2.cacheRead,
+    cacheCreation: a.cacheCreation + b2.cacheCreation,
+    output: a.output + b2.output
+  };
+}
+var NO_SUBAGENTS = { files: [], workflows: { count: 0, unreadable: 0, mtimeMs: 0 } };
+function listSubagents(subagentsDir) {
+  const entries = directoryEntries(subagentsDir);
+  if (!Array.isArray(entries)) {
+    return { ...NO_SUBAGENTS, files: [{ entry: "subagents/", path: subagentsDir, mtimeMs: null, size: null, statError: entries.error }] };
+  }
+  const names = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).sort();
+  const files = names.flatMap((entry) => {
+    const filePath = path15.join(subagentsDir, entry);
+    try {
+      const stat = statIfExists(filePath);
+      return stat === null ? [] : [{ entry, path: filePath, mtimeMs: stat.mtimeMs, size: stat.size, statError: null }];
+    } catch (statError) {
+      return [{ entry, path: filePath, mtimeMs: null, size: null, statError }];
+    }
+  });
+  const hasWorkflows = entries.some((entry) => entry.isDirectory() && entry.name === "workflows");
+  return { files, workflows: hasWorkflows ? listWorkflowTranscripts(path15.join(subagentsDir, "workflows")) : NO_SUBAGENTS.workflows };
+}
+function listWorkflowTranscripts(workflowsDir) {
+  const found = { count: 0, unreadable: 0, mtimeMs: 0 };
+  const failedToRead = () => {
+    found.count += 1;
+    found.unreadable += 1;
+  };
+  const list = (dir) => {
+    const entries = directoryEntries(dir);
+    if (Array.isArray(entries)) return entries;
+    failedToRead();
+    return [];
+  };
+  for (const run of list(workflowsDir)) {
+    if (!run.isDirectory()) continue;
+    const runDir = path15.join(workflowsDir, run.name);
+    for (const file2 of list(runDir)) {
+      if (!file2.isFile() || !file2.name.endsWith(".jsonl")) continue;
+      try {
+        const stat = statIfExists(path15.join(runDir, file2.name));
+        if (stat === null) continue;
+        found.count += 1;
+        found.mtimeMs = Math.max(found.mtimeMs, stat.mtimeMs);
+      } catch {
+        failedToRead();
+      }
+    }
+  }
+  return found;
+}
+function directoryEntries(dir) {
+  try {
+    return readdirSync6(dir, { withFileTypes: true });
+  } catch (error63) {
+    const code = error63.code;
+    return code === "ENOENT" || code === "ENOTDIR" ? [] : { error: error63 };
+  }
+}
+function subagentPart(entry) {
+  const match = /^agent-(.+)\.jsonl$/.exec(entry);
+  return match !== null && RAW_TRANSCRIPT_PART_PATTERN.test(match[1]) ? match[1] : null;
+}
+function addSubagentUsage(main2, mainFast, subagentFiles, bounds) {
+  let total = main2;
+  let fast = mainFast;
+  let fastCoverageComplete = main2 === null || mainFast !== null;
+  let skippedTooLarge = 0;
+  const unreadable = [];
+  const capture2 = { files: [], skipped: 0, skippedUnreadable: 0 };
+  let endedAt;
+  for (const file2 of subagentFiles) {
+    const { entry, path: sidecarPath } = file2;
+    try {
+      if (file2.size === null) throw file2.statError;
+      const { size } = file2;
+      if (size > bounds.maxBytes) {
+        skippedTooLarge += 1;
+        capture2.skipped += 1;
+        observeFileDiagnostic(bounds.onFileDiagnostic, { path: sidecarPath, reason: "too_large", sizeBytes: size });
+        continue;
+      }
+      const transcript = readTranscriptIfExists(sidecarPath);
+      if (transcript === null) {
+        continue;
+      }
+      const part = subagentPart(entry);
+      if (part === null) capture2.skipped += 1;
+      else capture2.files.push({ part, path: sidecarPath, prefix: transcript.prefix });
+      const summary = parseClaudeCodeTranscript(transcript.text);
+      endedAt = laterTimestamp(endedAt, summary?.endedAt);
+      if (summary?.usage) {
+        total = addUsage(total ?? { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }, summary.usage);
+        if (summary.fastUsage === null) fastCoverageComplete = false;
+      }
+      if (summary?.fastUsage) {
+        fast = addUsage(fast ?? { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }, summary.fastUsage);
+      }
+    } catch (error63) {
+      capture2.skipped += 1;
+      capture2.skippedUnreadable += 1;
+      unreadable.push(`${bounds.sessionId} (subagent ${entry}): ${describeReadError(error63)}`);
+      observeFileDiagnostic(bounds.onFileDiagnostic, {
+        path: sidecarPath,
+        reason: "unreadable",
+        sizeBytes: null,
+        errorCode: diagnosticErrorCode(error63)
+      });
+    }
+  }
+  return { capture: capture2, total, fast: fastCoverageComplete ? fast : null, skippedTooLarge, unreadable, endedAt };
+}
+function claudeCodeSessionCwd(sessionId, claudeDir = path15.join(os13.homedir(), ".claude")) {
+  if (!SESSION_UUID.test(sessionId)) return void 0;
+  for (const projectDir of listDirs(path15.join(claudeDir, "projects"))) {
+    const cwd = transcriptCwd(path15.join(projectDir, `${sessionId}.jsonl`));
+    if (cwd !== void 0) return cwd;
+  }
+  return void 0;
+}
+
+// ../../apps/syncservice/src/upload.ts
 function parseApiResponse(schema, body, route) {
   const parsed = schema.safeParse(body);
   if (!parsed.success) {
@@ -90048,10 +91493,16 @@ async function uploadPreviewRegistration(apiUrl, machineToken, registration) {
 function encodeRawTranscript(text) {
   return gzipSync(redactJsonl(text));
 }
+function readCollectedTranscript(file2, prefix) {
+  return prefix === void 0 ? readFileSync10(file2, "utf8") : readTranscriptPrefix(file2, prefix, false);
+}
+function readUnchangedTranscript(file2, prefix) {
+  return prefix === void 0 ? readFileSync10(file2, "utf8") : readTranscriptPrefix(file2, prefix, true);
+}
 var BUNDLE_HEADER_BYTES = 256;
 var BUNDLE_HEADER_BYTES_PER_PART = 256;
 function rawUploadBody(session, readTranscript, maxBytes = MAX_RAW_UPLOAD_BYTES) {
-  const main2 = encodeRawTranscript(readTranscript(session.transcriptPath));
+  const main2 = encodeRawTranscript(readTranscript(session.transcriptPath, session.transcriptPrefix));
   if (session.subagents === void 0) {
     return main2.byteLength > maxBytes ? "too-large" : { body: main2, main: main2, contentType: "application/gzip", skippedSubagentFiles: 0, unreadableSubagentFiles: 0 };
   }
@@ -90063,8 +91514,9 @@ function rawUploadBody(session, readTranscript, maxBytes = MAX_RAW_UPLOAD_BYTES)
   for (const file2 of session.subagents.files) {
     let body;
     try {
-      body = encodeRawTranscript(readTranscript(file2.path));
-    } catch {
+      body = encodeRawTranscript(readTranscript(file2.path, file2.prefix));
+    } catch (error63) {
+      if (error63 instanceof TranscriptChangedError) throw error63;
       skipped += 1;
       unreadable += 1;
       continue;
@@ -90090,33 +91542,61 @@ function rawUploadBody(session, readTranscript, maxBytes = MAX_RAW_UPLOAD_BYTES)
     unreadableSubagentFiles: unreadable
   };
 }
+function shippedContent(session) {
+  if (session.subagents === void 0 && session.transcriptPrefix === void 0) return void 0;
+  const prefixOf = (prefix) => [prefix.bytes, prefix.sha256];
+  const parts = session.subagents?.files.map((file2) => JSON.stringify([file2.part, ...prefixOf(file2.prefix)])).sort();
+  return JSON.stringify({
+    transcript: session.transcriptPrefix === void 0 ? null : prefixOf(session.transcriptPrefix),
+    parts: parts ?? null,
+    skipped: session.subagents?.skipped ?? null,
+    skippedUnreadable: session.subagents?.skippedUnreadable ?? null
+  });
+}
+function unchangedSince(acknowledged, session) {
+  if (acknowledged.mtimeMs !== session.mtimeMs) return false;
+  const now = shippedContent(session);
+  return now === void 0 || acknowledged.content === now;
+}
+function isRawShipped(shipped, session) {
+  const acknowledged = shipped.get(sessionKey(session.item));
+  return acknowledged !== void 0 && unchangedSince(acknowledged, session);
+}
 var UNREADABLE_SUBAGENT_RETRIES = 3;
-async function uploadRawSessions(apiUrl, machineToken, transcriptUploadSources, readTranscript = (p) => readFileSync9(p, "utf8"), shipped, progress) {
+async function uploadRawSessions(apiUrl, machineToken, transcriptUploadSources, readTranscript = readCollectedTranscript, shipped, progress) {
   const summary = {
     uploaded: 0,
     skippedTooLarge: 0,
     skippedSubagentFiles: 0,
     skippedUnchanged: 0,
     missingMetadata: 0,
+    changedSinceRead: 0,
     failed: [],
-    unconfigured: false
+    unconfigured: false,
+    outcomes: /* @__PURE__ */ new Map()
   };
   const initiallyShipped = new Map(shipped);
   let rateLimited;
   for (const session of transcriptUploadSources) {
     summary.uploaded += await progress?.beforeUpload?.() ?? 0;
-    const transcriptUploadSourcePath = session.transcriptPath;
-    const acknowledged = shipped?.get(transcriptUploadSourcePath);
-    const unchanged = acknowledged?.mtimeMs === session.mtimeMs;
-    if (unchanged && acknowledged.unreadableRetries === 0 || acknowledged !== void 0 && acknowledged !== initiallyShipped.get(transcriptUploadSourcePath)) {
+    const key = sessionKey(session.item);
+    const acknowledged = shipped?.get(key);
+    const unchanged = acknowledged !== void 0 && unchangedSince(acknowledged, session);
+    if (unchanged && acknowledged.unreadableRetries === 0 || acknowledged !== void 0 && acknowledged !== initiallyShipped.get(key)) {
       summary.skippedUnchanged += 1;
+      summary.outcomes.set(key, "unchanged");
       continue;
     }
     try {
       const encoded = rawUploadBody(session, readTranscript);
       if (encoded === "too-large") {
         summary.skippedTooLarge += 1;
-        shipped?.set(transcriptUploadSourcePath, { mtimeMs: session.mtimeMs, unreadableRetries: 0 });
+        summary.outcomes.set(key, "too-large");
+        shipped?.set(key, {
+          mtimeMs: session.mtimeMs,
+          unreadableRetries: 0,
+          content: shippedContent(session)
+        });
         continue;
       }
       const query = `harness=${session.item.harness}&harnessSessionId=${encodeURIComponent(session.item.harnessSessionId)}`;
@@ -90148,6 +91628,7 @@ async function uploadRawSessions(apiUrl, machineToken, transcriptUploadSources,
       }
       if (response.status === 404) {
         summary.missingMetadata += 1;
+        summary.outcomes.set(key, "missing-metadata");
         continue;
       }
       if (response.status === 429) {
@@ -90158,12 +91639,20 @@ async function uploadRawSessions(apiUrl, machineToken, transcriptUploadSources,
       }
       summary.uploaded += 1;
       summary.skippedSubagentFiles += skippedSubagentFiles;
+      summary.outcomes.set(key, "uploaded");
       progress?.onUploaded?.();
-      shipped?.set(transcriptUploadSourcePath, {
+      shipped?.set(key, {
         mtimeMs: session.mtimeMs,
-        unreadableRetries: unreadableSubagentFiles === 0 ? 0 : unchanged ? acknowledged.unreadableRetries - 1 : UNREADABLE_SUBAGENT_RETRIES
+        unreadableRetries: unreadableSubagentFiles === 0 ? 0 : unchanged ? acknowledged.unreadableRetries - 1 : UNREADABLE_SUBAGENT_RETRIES,
+        content: shippedContent(session)
       });
     } catch (error63) {
+      if (error63 instanceof TranscriptChangedError) {
+        summary.changedSinceRead += 1;
+        summary.outcomes.set(key, "changed-since-read");
+        continue;
+      }
+      summary.outcomes.set(key, "failed");
       if (error63 instanceof RateLimitedError) rateLimited ??= error63;
       summary.failed.push(
         `${session.item.harnessSessionId}: ${error63 instanceof Error ? error63.message : String(error63)}`
@@ -90228,7 +91717,7 @@ function gotrueAuthClient(url2, key) {
 }
 async function runEnrollment(config2, options) {
   const log3 = options.log ?? console.log;
-  const name = options.name?.trim() || os13.hostname();
+  const name = options.name?.trim() || os14.hostname();
   let scopePaths = (options.scope ?? []).map(normalizeScopePath);
   let captureMode = scopePaths.length > 0 ? "scope" : "org-repos";
   if (captureMode === "scope") {
@@ -90245,7 +91734,7 @@ async function runEnrollment(config2, options) {
   const anyWorkspaceClaims = (orgPolicy?.workspaces ?? []).some(workspaceClaimsAnyRepo);
   if (orgPolicy !== void 0 && orgPolicy.owners.length === 0 && orgPolicy.repos === null && !anyWorkspaceClaims) {
     if (config2.appEnv === "development") {
-      const home = normalizeScopePath(os13.homedir());
+      const home = normalizeScopePath(os14.homedir());
       log3(
         `No GitHub integration on org "${result.org.name}", syncing sessions under ${home} (your home folder, local DB only). Re-enroll with --scope <path> to narrow.`
       );
@@ -90319,7 +91808,7 @@ async function enroll(config2, options, createAuthClient = gotrueAuthClient, lis
     { ...listener, log: options.log, redeem: (code) => redeemApproval(config2.apiUrl, code, verifier) }
   );
 }
-var challengeFor = (verifier) => createHash4("sha256").update(verifier).digest("hex");
+var challengeFor = (verifier) => createHash6("sha256").update(verifier).digest("hex");
 function enrollApprovalUrl(webUrl, {
   name,
   state,
@@ -90557,398 +92046,6 @@ function removeFolder(config2, rawPath, enrollCommand, log3, deps = defaultDeps)
   log3(`Removed ${folder}, sessions there stay local from the next sync pass.`);
 }
 
-// ../../apps/syncservice/src/claudeCode.ts
-import { readdirSync as readdirSync6 } from "node:fs";
-import os14 from "node:os";
-import path15 from "node:path";
-import { setImmediate as yieldToEventLoop2 } from "node:timers/promises";
-function parseClaudeCodeTranscript(text) {
-  const usageByMessage = /* @__PURE__ */ new Map();
-  const modelCounts = /* @__PURE__ */ new Map();
-  const timestamps = [];
-  let title;
-  let cwd;
-  let gitBranch;
-  let entrypoint;
-  let anonCounter = 0;
-  let speedMode;
-  for (const record2 of parseJsonl(text)) {
-    if (record2.type === "custom-title" && typeof record2.customTitle === "string") {
-      title = record2.customTitle;
-      continue;
-    }
-    if (record2.type === "ai-title" && typeof record2.aiTitle === "string") {
-      title = record2.aiTitle;
-      continue;
-    }
-    if (cwd === void 0 && typeof record2.cwd === "string" && record2.cwd !== "") cwd = record2.cwd;
-    if (typeof record2.entrypoint === "string" && record2.entrypoint !== "") {
-      entrypoint ??= record2.entrypoint;
-    }
-    if (typeof record2.gitBranch === "string" && record2.gitBranch !== "") {
-      gitBranch ??= record2.gitBranch;
-    }
-    if (typeof record2.timestamp === "string") timestamps.push(record2.timestamp);
-    if (record2.type !== "assistant") continue;
-    const message2 = record2.message;
-    if (!message2 || message2.model === "<synthetic>") continue;
-    const id = message2.id ?? (typeof record2.requestId === "string" ? record2.requestId : void 0) ?? (typeof record2.uuid === "string" ? record2.uuid : void 0) ?? `anon-${anonCounter++}`;
-    const previousMessage = usageByMessage.get(id);
-    const isNewMessage = previousMessage === void 0;
-    const speedValue = message2.usage?.speed;
-    const observedSpeed = speedModeOf(speedValue);
-    const messageSpeed = observedSpeed ?? previousMessage?.speedMode;
-    if (speedValue !== void 0) speedMode = observedSpeed ?? "unknown";
-    if (message2.usage) {
-      usageByMessage.set(id, {
-        usage: toUsage(message2.usage),
-        ...messageSpeed && { speedMode: messageSpeed }
-      });
-    } else if (isNewMessage) {
-      usageByMessage.set(id, {
-        usage: { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }
-      });
-    }
-    if (isNewMessage && typeof message2.model === "string") {
-      modelCounts.set(message2.model, (modelCounts.get(message2.model) ?? 0) + 1);
-    }
-  }
-  if (usageByMessage.size === 0 && timestamps.length === 0) return null;
-  const summed = [...usageByMessage.values()].map((entry) => entry.usage).reduce(addUsage, {
-    input: 0,
-    cacheRead: 0,
-    cacheCreation: 0,
-    output: 0
-  });
-  const speedFullyMeasured = usageByMessage.size > 0 && [...usageByMessage.values()].every((entry) => entry.speedMode !== void 0);
-  const fastUsage = speedFullyMeasured ? [...usageByMessage.values()].filter((entry) => entry.speedMode === "fast").map((entry) => entry.usage).reduce(addUsage, { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }) : null;
-  return {
-    startedAt: timestamps[0],
-    endedAt: timestamps[timestamps.length - 1],
-    model: dominantKey(modelCounts),
-    usage: usageByMessage.size > 0 ? summed : null,
-    fastUsage,
-    ...speedMode && { speedMode },
-    title,
-    turnCount: usageByMessage.size,
-    cwd,
-    gitBranch,
-    entrypoint
-  };
-}
-var AGENT_SDK_ENTRYPOINTS = /* @__PURE__ */ new Set(["sdk-py", "sdk-ts"]);
-function isAutomationEntrypoint(entrypoint) {
-  return entrypoint !== void 0 && AGENT_SDK_ENTRYPOINTS.has(entrypoint);
-}
-async function collectClaudeCodeSessions(options = {}) {
-  const claudeDir = options.claudeDir ?? path15.join(os14.homedir(), ".claude");
-  const now = options.now ?? Date.now();
-  const capture2 = options.capture ?? captureEverythingUnresolved;
-  const maxBytes = options.maxTranscriptBytes ?? MAX_TRANSCRIPT_FILE_BYTES;
-  const projectsDir = path15.join(claudeDir, "projects");
-  const items = [];
-  const skips = { skippedOutOfScope: 0, skippedNoRepo: 0 };
-  const candidates = [];
-  const unreadable = [];
-  let skippedTooLarge = 0;
-  const home = path15.dirname(claudeDir);
-  const lifecycle = options.lifecycle ?? readLifecycleJournal(home, now, ["claude-local"]);
-  for (const projectDir of listDirs(projectsDir)) {
-    for (const entry of listFiles(projectDir, ".jsonl")) {
-      await yieldToEventLoop2();
-      const transcriptPath = path15.join(projectDir, entry);
-      const stat = statIfExists(transcriptPath);
-      if (!stat) continue;
-      const sessionId = path15.basename(entry, ".jsonl");
-      const subagents = options.locationsOnly ? NO_SUBAGENTS : listSubagents(path15.join(projectDir, sessionId, "subagents"));
-      const mtimeMs = Math.max(stat.mtimeMs, subagents.workflows.mtimeMs, ...subagents.files.map((file2) => file2.mtimeMs ?? 0));
-      if (options.sinceMs !== void 0 && mtimeMs < options.sinceMs) continue;
-      if (stat.size > maxBytes) {
-        skippedTooLarge += 1;
-        observeFileDiagnostic(options.onFileDiagnostic, {
-          path: transcriptPath,
-          reason: "too_large",
-          sizeBytes: stat.size
-        });
-        continue;
-      }
-      const endObservedAt = observedSessionEnd(lifecycle.latestBoundary("claude-local", sessionId), mtimeMs);
-      const status = endObservedAt === null && now - mtimeMs < ACTIVE_GRACE_MS ? "active" : "inactive";
-      try {
-        const cwd = transcriptCwd(transcriptPath);
-        const decision = captureDecision(cwd, capture2);
-        if (!decision.capture) {
-          countCaptureSkip(skips, decision.reason);
-          continue;
-        }
-        if (options.locationsOnly) {
-          items.push({
-            mtimeMs: stat.mtimeMs,
-            transcriptPath,
-            ...cwd && { cwd },
-            item: { harness: "claude-local", harnessSessionId: sessionId, status, capturedVia: decision.via }
-          });
-          continue;
-        }
-        candidates.push({
-          transcriptPath,
-          sessionId,
-          mtimeMs,
-          subagents,
-          status,
-          endObservedAt,
-          ...cwd && { cwd },
-          decision
-        });
-      } catch (error63) {
-        unreadable.push(`${sessionId}: ${describeReadError(error63)}`);
-        observeFileDiagnostic(options.onFileDiagnostic, {
-          path: transcriptPath,
-          reason: "unreadable",
-          sizeBytes: null,
-          errorCode: diagnosticErrorCode(error63)
-        });
-      }
-    }
-  }
-  if (options.locationsOnly) {
-    return {
-      sessions: items.sort((a, b2) => b2.mtimeMs - a.mtimeMs),
-      ...skips,
-      skippedTooLarge,
-      unreadable,
-      heldBack: 0
-    };
-  }
-  candidates.sort((a, b2) => b2.mtimeMs - a.mtimeMs);
-  const chosen = options.maxSessions === void 0 ? candidates : candidates.slice(0, options.maxSessions);
-  for (const candidate of chosen) {
-    await yieldToEventLoop2();
-    const { transcriptPath, sessionId, mtimeMs, subagents, status, endObservedAt, cwd, decision } = candidate;
-    try {
-      const text = readIfExists(transcriptPath);
-      if (text === null) continue;
-      const summary = parseClaudeCodeTranscript(text);
-      if (!summary) continue;
-      const usage = addSubagentUsage(
-        summary.usage,
-        summary.fastUsage,
-        subagents.files,
-        { maxBytes, sessionId, onFileDiagnostic: options.onFileDiagnostic }
-      );
-      skippedTooLarge += usage.skippedTooLarge;
-      unreadable.push(...usage.unreadable);
-      const endedAt = endObservedAt ?? laterTimestamp(summary.endedAt, usage.endedAt);
-      items.push({
-        mtimeMs,
-        transcriptPath,
-        subagents: {
-          files: usage.capture.files,
-          skipped: usage.capture.skipped + subagents.workflows.count,
-          skippedUnreadable: usage.capture.skippedUnreadable + subagents.workflows.unreadable
-        },
-        ...cwd && { cwd },
-        item: {
-          harness: "claude-local",
-          harnessSessionId: sessionId,
-          status,
-          ...summary.startedAt && { startedAt: summary.startedAt },
-          ...endedAt && { endedAt },
-          ...summary.model && { model: summary.model },
-          ...summary.speedMode && { speedMode: summary.speedMode },
-          // Total input-class tokens the source reported (uncached + cache
-          // reads + cache writes) — a real reported total, not an estimate.
-          // The cache breakdown rides along: pricing bills reads at 0.1×
-          // and writes at 1.25×, so collapsing it would inflate estimates.
-          ...usage.total && {
-            inputTokens: usage.total.input + usage.total.cacheRead + usage.total.cacheCreation
-          },
-          ...usage.total && { outputTokens: usage.total.output },
-          ...usage.total && { cacheReadTokens: usage.total.cacheRead },
-          ...usage.total && { cacheWriteTokens: usage.total.cacheCreation },
-          ...usage.fast && {
-            fastInputTokens: usage.fast.input + usage.fast.cacheRead + usage.fast.cacheCreation,
-            fastOutputTokens: usage.fast.output,
-            fastCacheReadTokens: usage.fast.cacheRead,
-            fastCacheWriteTokens: usage.fast.cacheCreation
-          },
-          ...summary.title && { title: redactText(summary.title).slice(0, 500) },
-          ...isAutomationEntrypoint(summary.entrypoint) && { automation: true },
-          // The PR-join coordinates: the checkout's directory name (bare
-          // repo, not the local path) and the branch the work started on.
-          ...cwd && { repoDir: path15.basename(cwd) },
-          ...summary.gitBranch && { gitBranch: summary.gitBranch },
-          ...decision.repoFullName && { repoFullName: decision.repoFullName },
-          capturedVia: decision.via
-        }
-      });
-    } catch (error63) {
-      unreadable.push(`${sessionId}: ${describeReadError(error63)}`);
-      observeFileDiagnostic(options.onFileDiagnostic, {
-        path: transcriptPath,
-        reason: "unreadable",
-        sizeBytes: null,
-        errorCode: diagnosticErrorCode(error63)
-      });
-    }
-  }
-  return {
-    sessions: items.sort((a, b2) => b2.mtimeMs - a.mtimeMs),
-    ...skips,
-    skippedTooLarge,
-    unreadable,
-    heldBack: candidates.length - chosen.length
-  };
-}
-function transcriptCwd(transcriptPath) {
-  const record2 = readFirstRecord(
-    transcriptPath,
-    (candidate) => typeof candidate.cwd === "string" && candidate.cwd !== ""
-  );
-  return typeof record2?.cwd === "string" ? record2.cwd : void 0;
-}
-function toUsage(u) {
-  const n = (value) => typeof value === "number" ? value : 0;
-  return {
-    input: n(u.input_tokens),
-    cacheRead: n(u.cache_read_input_tokens),
-    cacheCreation: n(u.cache_creation_input_tokens),
-    output: n(u.output_tokens)
-  };
-}
-function speedModeOf(value) {
-  return value === "fast" || value === "standard" ? value : void 0;
-}
-function addUsage(a, b2) {
-  return {
-    input: a.input + b2.input,
-    cacheRead: a.cacheRead + b2.cacheRead,
-    cacheCreation: a.cacheCreation + b2.cacheCreation,
-    output: a.output + b2.output
-  };
-}
-var NO_SUBAGENTS = { files: [], workflows: { count: 0, unreadable: 0, mtimeMs: 0 } };
-function listSubagents(subagentsDir) {
-  const entries = directoryEntries(subagentsDir);
-  if (!Array.isArray(entries)) {
-    return { ...NO_SUBAGENTS, files: [{ entry: "subagents/", path: subagentsDir, mtimeMs: null, size: null, statError: entries.error }] };
-  }
-  const names = entries.filter((entry) => entry.isFile() && entry.name.endsWith(".jsonl")).map((entry) => entry.name).sort();
-  const files = names.flatMap((entry) => {
-    const filePath = path15.join(subagentsDir, entry);
-    try {
-      const stat = statIfExists(filePath);
-      return stat === null ? [] : [{ entry, path: filePath, mtimeMs: stat.mtimeMs, size: stat.size, statError: null }];
-    } catch (statError) {
-      return [{ entry, path: filePath, mtimeMs: null, size: null, statError }];
-    }
-  });
-  const hasWorkflows = entries.some((entry) => entry.isDirectory() && entry.name === "workflows");
-  return { files, workflows: hasWorkflows ? listWorkflowTranscripts(path15.join(subagentsDir, "workflows")) : NO_SUBAGENTS.workflows };
-}
-function listWorkflowTranscripts(workflowsDir) {
-  const found = { count: 0, unreadable: 0, mtimeMs: 0 };
-  const failedToRead = () => {
-    found.count += 1;
-    found.unreadable += 1;
-  };
-  const list = (dir) => {
-    const entries = directoryEntries(dir);
-    if (Array.isArray(entries)) return entries;
-    failedToRead();
-    return [];
-  };
-  for (const run of list(workflowsDir)) {
-    if (!run.isDirectory()) continue;
-    const runDir = path15.join(workflowsDir, run.name);
-    for (const file2 of list(runDir)) {
-      if (!file2.isFile() || !file2.name.endsWith(".jsonl")) continue;
-      try {
-        const stat = statIfExists(path15.join(runDir, file2.name));
-        if (stat === null) continue;
-        found.count += 1;
-        found.mtimeMs = Math.max(found.mtimeMs, stat.mtimeMs);
-      } catch {
-        failedToRead();
-      }
-    }
-  }
-  return found;
-}
-function directoryEntries(dir) {
-  try {
-    return readdirSync6(dir, { withFileTypes: true });
-  } catch (error63) {
-    const code = error63.code;
-    return code === "ENOENT" || code === "ENOTDIR" ? [] : { error: error63 };
-  }
-}
-function subagentPart(entry) {
-  const match = /^agent-(.+)\.jsonl$/.exec(entry);
-  return match !== null && RAW_TRANSCRIPT_PART_PATTERN.test(match[1]) ? match[1] : null;
-}
-function laterTimestamp(a, b2) {
-  if (a === void 0 || b2 === void 0) return a ?? b2;
-  return Date.parse(b2) > Date.parse(a) ? b2 : a;
-}
-function addSubagentUsage(main2, mainFast, subagentFiles, bounds) {
-  let total = main2;
-  let fast = mainFast;
-  let fastCoverageComplete = main2 === null || mainFast !== null;
-  let skippedTooLarge = 0;
-  const unreadable = [];
-  const capture2 = { files: [], skipped: 0, skippedUnreadable: 0 };
-  let endedAt;
-  for (const file2 of subagentFiles) {
-    const { entry, path: sidecarPath } = file2;
-    try {
-      if (file2.size === null) throw file2.statError;
-      const { size } = file2;
-      if (size > bounds.maxBytes) {
-        skippedTooLarge += 1;
-        capture2.skipped += 1;
-        observeFileDiagnostic(bounds.onFileDiagnostic, { path: sidecarPath, reason: "too_large", sizeBytes: size });
-        continue;
-      }
-      const text = readIfExists(sidecarPath);
-      if (text === null) {
-        continue;
-      }
-      const part = subagentPart(entry);
-      if (part === null) capture2.skipped += 1;
-      else capture2.files.push({ part, path: sidecarPath });
-      const summary = parseClaudeCodeTranscript(text);
-      endedAt = laterTimestamp(endedAt, summary?.endedAt);
-      if (summary?.usage) {
-        total = addUsage(total ?? { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }, summary.usage);
-        if (summary.fastUsage === null) fastCoverageComplete = false;
-      }
-      if (summary?.fastUsage) {
-        fast = addUsage(fast ?? { input: 0, cacheRead: 0, cacheCreation: 0, output: 0 }, summary.fastUsage);
-      }
-    } catch (error63) {
-      capture2.skipped += 1;
-      capture2.skippedUnreadable += 1;
-      unreadable.push(`${bounds.sessionId} (subagent ${entry}): ${describeReadError(error63)}`);
-      observeFileDiagnostic(bounds.onFileDiagnostic, {
-        path: sidecarPath,
-        reason: "unreadable",
-        sizeBytes: null,
-        errorCode: diagnosticErrorCode(error63)
-      });
-    }
-  }
-  return { capture: capture2, total, fast: fastCoverageComplete ? fast : null, skippedTooLarge, unreadable, endedAt };
-}
-function claudeCodeSessionCwd(sessionId, claudeDir = path15.join(os14.homedir(), ".claude")) {
-  if (!SESSION_UUID.test(sessionId)) return void 0;
-  for (const projectDir of listDirs(path15.join(claudeDir, "projects"))) {
-    const cwd = transcriptCwd(path15.join(projectDir, `${sessionId}.jsonl`));
-    if (cwd !== void 0) return cwd;
-  }
-  return void 0;
-}
-
 // ../../apps/syncservice/src/protectedRepoDiscovery.ts
 import os15 from "node:os";
 import path16 from "node:path";
@@ -91379,7 +92476,9 @@ var claudeLocal = {
     const dirs = new Set(installs.map((install) => install.configDir ?? homeDir));
     return [...dirs].map((dir) => path18.join(dir, ".claude.json"));
   },
-  registration: jsonServerEntry
+  registration: jsonServerEntry,
+  // <project folder>/<session id>.jsonl
+  transcriptSession: (transcriptPath) => ({ externalId: path18.basename(transcriptPath, ".jsonl") })
 };
 var codexLocal = {
   harness: "codex-local",
@@ -91419,7 +92518,12 @@ var codexLocal = {
   registration: (content) => content,
   // The stored ID is the base rollout's file name, and hooks name the
   // thread, whose ID the file name ends with.
-  hookSessionId: (externalId) => rolloutIdentity(`${externalId}.jsonl`).threadId
+  hookSessionId: (externalId) => rolloutIdentity(`${externalId}.jsonl`).threadId,
+  // A page file continues a thread whose base rollout names the session.
+  transcriptSession(transcriptPath) {
+    const identity = rolloutIdentity(transcriptPath);
+    return identity.page ? { hookId: identity.threadId } : { externalId: path18.basename(transcriptPath, ".jsonl") };
+  }
 };
 var cursorLocal = {
   harness: "cursor-local",
@@ -91714,7 +92818,7 @@ async function checkCursor(mcpJsonPath, context2) {
 }
 
 // ../../apps/syncservice/src/harnessConnections.ts
-import { mkdirSync as mkdirSync10, readFileSync as readFileSync10, renameSync as renameSync5, watch as fsWatch, writeFileSync as writeFileSync9 } from "node:fs";
+import { mkdirSync as mkdirSync10, readFileSync as readFileSync11, renameSync as renameSync6, watch as fsWatch, writeFileSync as writeFileSync8 } from "node:fs";
 import os18 from "node:os";
 import path19 from "node:path";
 var CONNECTION_STATES = [
@@ -91873,7 +92977,7 @@ function readSavedFile(readTextFile, homeDir) {
 }
 function bestEffortRead(filePath) {
   try {
-    return readFileSync10(filePath, "utf8");
+    return readFileSync11(filePath, "utf8");
   } catch {
     return null;
   }
@@ -91882,8 +92986,8 @@ function writeSavedFile(record2, homeDir) {
   const file2 = detectedClientsPath(homeDir);
   mkdirSync10(path19.dirname(file2), { recursive: true });
   const temporary = `${file2}.${process.pid}.tmp`;
-  writeFileSync9(temporary, JSON.stringify(record2, null, 2));
-  renameSync5(temporary, file2);
+  writeFileSync8(temporary, JSON.stringify(record2, null, 2));
+  renameSync6(temporary, file2);
 }
 function loadDetectedClients(readTextFile = bestEffortRead, homeDir) {
   const parsed = detectedClientsSchema.safeParse(readSavedFile(readTextFile, homeDir));
@@ -92233,7 +93337,7 @@ function recentCatchupFloor(sinceMs, sessions) {
 function sessionsForCatchup(sessions, selection) {
   if (!selection) return sessions;
   return sessions.filter(
-    (session) => session.mtimeMs >= selection.sinceMs || selection.paths.has(session.transcriptPath)
+    (session) => session.mtimeMs >= selection.sinceMs || selection.sessions.has(sessionKey(session.item))
   );
 }
 function recentSyncOptions(shared, narrowSinceMs, selection) {
@@ -92247,7 +93351,7 @@ function recentSyncOptions(shared, narrowSinceMs, selection) {
 }
 
 // ../../apps/syncservice/src/branchFacts.ts
-import { readFileSync as readFileSync11 } from "node:fs";
+import { readFileSync as readFileSync12 } from "node:fs";
 import path20 from "node:path";
 var SHA_SHAPE = /^[0-9a-f]{40}$/;
 function observeBranch(cwd, environment = {}) {
@@ -92318,7 +93422,7 @@ function resolveRef2(commonDir, ref) {
 }
 function readIfExists2(p) {
   try {
-    return readFileSync11(p, "utf8");
+    return readFileSync12(p, "utf8");
   } catch {
     return null;
   }
@@ -92336,7 +93440,8 @@ async function registerAnnouncedPreviews(apiUrl, machineToken, collected, memo2,
   };
   for (const session of collected) {
     if (session.item.status !== "active") continue;
-    const state = memo2.get(session.transcriptPath);
+    const key = sessionKey(session.item);
+    const state = memo2.get(key);
     if (state?.foreignOwner || state?.previewsOff) continue;
     if (state?.examinedMtimeMs === session.mtimeMs) continue;
     try {
@@ -92354,7 +93459,7 @@ async function registerAnnouncedPreviews(apiUrl, machineToken, collected, memo2,
       }));
       const registeredJson = JSON.stringify(previews);
       if (previews.length === 0 || state?.registeredJson === registeredJson) {
-        memo2.set(session.transcriptPath, { ...state, examinedMtimeMs: session.mtimeMs });
+        memo2.set(key, { ...state, examinedMtimeMs: session.mtimeMs });
         continue;
       }
       const outcome = await upload(apiUrl, machineToken, {
@@ -92363,16 +93468,16 @@ async function registerAnnouncedPreviews(apiUrl, machineToken, collected, memo2,
         previews
       });
       if (outcome === "foreign-owner") {
-        memo2.set(session.transcriptPath, { examinedMtimeMs: session.mtimeMs, foreignOwner: true });
+        memo2.set(key, { examinedMtimeMs: session.mtimeMs, foreignOwner: true });
         summary.foreignOwned.push(session.item.harnessSessionId);
         continue;
       }
       if (outcome === "previews-off") {
-        memo2.set(session.transcriptPath, { examinedMtimeMs: session.mtimeMs, previewsOff: true });
+        memo2.set(key, { examinedMtimeMs: session.mtimeMs, previewsOff: true });
         summary.previewsOff.push(session.item.harnessSessionId);
         continue;
       }
-      memo2.set(session.transcriptPath, { examinedMtimeMs: session.mtimeMs, registeredJson });
+      memo2.set(key, { examinedMtimeMs: session.mtimeMs, registeredJson });
       summary.registered += 1;
     } catch (error63) {
       summary.failed.push(
@@ -92531,6 +93636,8 @@ async function runSyncPassInternal(config2, options, diagnostic) {
     sinceMs,
     capture: capture2,
     maxSessions,
+    ...options.codexThreadLinks && { threadLinks: options.codexThreadLinks },
+    ...options.codexThreadReads && { threadReads: options.codexThreadReads },
     onFileDiagnostic: files.observe("codex")
   });
   diagnostic.codex = {
@@ -92619,12 +93726,8 @@ async function runSyncPassInternal(config2, options, diagnostic) {
     credentials.token,
     items
   );
-  const foreignKeys = new Set(
-    foreignOwned.map(({ harness, harnessSessionId }) => JSON.stringify([harness, harnessSessionId]))
-  );
-  const writable = collected.filter(
-    ({ item }) => !foreignKeys.has(JSON.stringify([item.harness, item.harnessSessionId]))
-  );
+  const foreignKeys = new Set(foreignOwned.map(sessionKey));
+  const writable = collected.filter(({ item }) => !foreignKeys.has(sessionKey(item)));
   for (const { harness, harnessSessionId } of foreignOwned) {
     log3(`Skipped ${harness} session ${harnessSessionId}: already synced from another machine.`);
   }
@@ -92679,17 +93782,31 @@ async function runSyncPassInternal(config2, options, diagnostic) {
   const rawWindowSkipped = writable.length - rawEligible.length;
   diagnostic.rawWindowSkipped = rawWindowSkipped;
   diagnostic.stage = "raw";
+  const besideBackgroundSync = options.rawShipped === void 0 && (options.backgroundSyncIsRunning ?? (() => backgroundSyncIsRunning(config2.appEnv)))();
   const raw = await uploadRawSessions(
     credentials.apiUrl,
     credentials.token,
     rawEligible,
-    void 0,
+    besideBackgroundSync ? readUnchangedTranscript : readCollectedTranscript,
     options.rawShipped,
     {
       beforeUpload: options.beforeRawUpload ? () => options.beforeRawUpload(collected) : void 0,
       onUploaded: options.onRawUploaded
     }
   );
+  const givenUp = options.codexThreadLinks?.settleRecoveries((session) => {
+    const key = sessionKey(session.item);
+    if (raw.unconfigured || foreignKeys.has(key) || rawFloor !== null && session.mtimeMs < rawFloor) return "refused";
+    if (options.rawShipped !== void 0 && isRawShipped(options.rawShipped, session)) return "shipped";
+    const outcome = raw.outcomes.get(key);
+    if (outcome === void 0) return "waiting";
+    return outcome === "missing-metadata" ? "refused" : "failed";
+  }) ?? [];
+  for (const threadId2 of givenUp) {
+    log3(
+      `\u26A0 Codex thread ${threadId2} is still owed a corrected capture after ${CORRECTION_UPLOAD_ATTEMPTS} failed uploads; it is sent again when it changes.`
+    );
+  }
   diagnostic.rawUnconfigured = raw.unconfigured;
   if (!raw.unconfigured) {
     diagnostic.rawUploaded = raw.uploaded;
@@ -92706,6 +93823,11 @@ async function runSyncPassInternal(config2, options, diagnostic) {
     if (rawWindowSkipped > 0) parts.push(`${rawWindowSkipped} outside the dev raw window`);
     if (raw.skippedTooLarge > 0) parts.push(`${raw.skippedTooLarge} skipped (too large)`);
     if (raw.skippedSubagentFiles > 0) parts.push(`${raw.skippedSubagentFiles} subagent file(s) left out`);
+    if (raw.changedSinceRead > 0) {
+      parts.push(
+        besideBackgroundSync ? `${raw.changedSinceRead} changed while syncing, left for the background sync` : `${raw.changedSinceRead} changed while syncing, next pass`
+      );
+    }
     if (raw.failed.length > 0) parts.push(`${raw.failed.length} failed`);
     log3(`Raw content: ${parts.join(", ")}.`);
     for (const failure2 of raw.failed) log3(`  raw upload failed, ${failure2}`);
@@ -92714,7 +93836,7 @@ async function runSyncPassInternal(config2, options, diagnostic) {
         `${raw.missingMetadata} raw transcript(s) waiting on their session metadata, they re-send once it lands.`
       );
     }
-    const nothingElseAccountedFor = raw.skippedUnchanged === 0 && raw.skippedTooLarge === 0 && rawWindowSkipped === 0 && raw.missingMetadata === 0;
+    const nothingElseAccountedFor = raw.skippedUnchanged === 0 && raw.skippedTooLarge === 0 && rawWindowSkipped === 0 && raw.missingMetadata === 0 && raw.changedSinceRead === 0;
     if (raw.uploaded === 0 && (raw.failed.length > 1 || raw.failed.length === 1 && nothingElseAccountedFor)) {
       throw new Error(`all ${raw.failed.length} raw upload(s) failed this pass, ${raw.failed[0]}`);
     }
@@ -92850,6 +93972,9 @@ function defaultStat(file2) {
   }
 }
 
+// ../../apps/syncservice/src/sessionStatusFeed.ts
+import { statSync as statSync5 } from "node:fs";
+
 // ../../apps/syncservice/src/sessionStatusModel.ts
 function createSessionStatusModel(now = Date.now) {
   const sessions = /* @__PURE__ */ new Map();
@@ -92897,6 +94022,7 @@ function createSessionStatusModel(now = Date.now) {
 }
 
 // ../../apps/syncservice/src/sessionStatusFeed.ts
+var TRANSCRIPT_WRITE_DELAY_MS = 500;
 var HELD_HOOK_ENTRIES_MAX = 500;
 var HOOK_ID_PAIRS_MAX = 1e4;
 var MAX_TIMER_MS = 2 ** 31 - 1;
@@ -92904,7 +94030,8 @@ function createSessionStatusFeed(deps) {
   const now = deps.now ?? Date.now;
   const adapters = deps.adapters ?? HARNESS_ADAPTERS;
   const model = createSessionStatusModel(now);
-  const hookIdOf = (harness) => adapters.find((adapter) => adapter.harness === harness)?.hookSessionId;
+  const adapterOf = (harness) => adapters.find((adapter) => adapter.harness === harness);
+  const hookIdOf = (harness) => adapterOf(harness)?.hookSessionId;
   const pairKey = (harness, hookId) => `${harness}:${hookId.toLowerCase()}`;
   const storedIds = /* @__PURE__ */ new Map();
   let held = [];
@@ -92912,6 +94039,8 @@ function createSessionStatusFeed(deps) {
   let deadlineTimer = null;
   let readQueued = false;
   let readFailing = false;
+  let statFailing = false;
+  const writeTimers = /* @__PURE__ */ new Map();
   let stopped = false;
   function stored(entry) {
     if (hookIdOf(entry.harness) === void 0) return entry;
@@ -92927,6 +94056,61 @@ function createSessionStatusFeed(deps) {
     }
     if (model.applyLifecycleEntry(mapped) !== null) changedInBatch = true;
   }
+  function learnPair(harness, externalId) {
+    const hookId = hookIdOf(harness)?.(externalId);
+    if (hookId === void 0) return false;
+    const key = pairKey(harness, hookId);
+    const known = storedIds.get(key);
+    storedIds.delete(key);
+    storedIds.set(key, externalId);
+    if (storedIds.size > HOOK_ID_PAIRS_MAX) storedIds.delete(storedIds.keys().next().value);
+    return known !== externalId;
+  }
+  function releaseHeld() {
+    const waiting = held;
+    held = [];
+    for (const entry of waiting) apply(entry);
+  }
+  function applyWrite(harness, sessionId, atMs) {
+    if (model.applyTranscriptWrite({ harness, sessionId, atMs }) !== null) changedInBatch = true;
+  }
+  function applyWatchedWrite(harness, transcriptPath) {
+    const session = adapterOf(harness)?.transcriptSession?.(transcriptPath);
+    if (session === void 0) return;
+    const externalId = "externalId" in session ? session.externalId : storedIds.get(pairKey(harness, session.hookId));
+    if (externalId === void 0) return;
+    const mtimeMs = modifiedMs(transcriptPath);
+    if (mtimeMs === null) return;
+    const learned = "externalId" in session && learnPair(harness, externalId);
+    applyWrite(harness, externalId, mtimeMs);
+    if (learned) releaseHeld();
+  }
+  function modifiedMs(transcriptPath) {
+    try {
+      const mtimeMs = statSync5(transcriptPath).mtimeMs;
+      if (statFailing) deps.log("transcript files readable again");
+      statFailing = false;
+      return mtimeMs;
+    } catch (error63) {
+      if (errorCode(error63) === "ENOENT") return null;
+      if (!statFailing) {
+        deps.log(`\u26A0 transcript file not read (${errorCode(error63)}), its status waits for the next sync pass`);
+      }
+      statFailing = true;
+      return null;
+    }
+  }
+  function noteWrite(harness, transcriptPath) {
+    if (writeTimers.has(transcriptPath)) return;
+    const timer = setTimeout(() => {
+      writeTimers.delete(transcriptPath);
+      if (stopped) return;
+      applyWatchedWrite(harness, transcriptPath);
+      settle2();
+    }, TRANSCRIPT_WRITE_DELAY_MS);
+    timer.unref?.();
+    writeTimers.set(transcriptPath, timer);
+  }
   const journal = createLifecycleJournalReader(deps.home, void 0, apply);
   function settle2() {
     armDeadline();
@@ -92963,6 +94147,7 @@ function createSessionStatusFeed(deps) {
   return {
     journal,
     forwardWatchEvents: (onEvent) => (change) => {
+      if (typeof change === "object" && !stopped) noteWrite(change.harness, change.transcript);
       if (change === "lifecycle" && !stopped && !readQueued) {
         readQueued = true;
         queueMicrotask(() => {
@@ -92974,19 +94159,10 @@ function createSessionStatusFeed(deps) {
     },
     observeSessions(sessions) {
       for (const { item, mtimeMs } of sessions) {
-        const hookId = hookIdOf(item.harness)?.(item.harnessSessionId);
-        if (hookId !== void 0) {
-          const key = pairKey(item.harness, hookId);
-          storedIds.delete(key);
-          storedIds.set(key, item.harnessSessionId);
-          if (storedIds.size > HOOK_ID_PAIRS_MAX) storedIds.delete(storedIds.keys().next().value);
-        }
-        const change = model.applyTranscriptWrite({ harness: item.harness, sessionId: item.harnessSessionId, atMs: mtimeMs });
-        if (change !== null) changedInBatch = true;
-      }
-      const waiting = held;
-      held = [];
-      for (const entry of waiting) apply(entry);
+        learnPair(item.harness, item.harnessSessionId);
+        applyWrite(item.harness, item.harnessSessionId, mtimeMs);
+      }
+      releaseHeld();
       settle2();
     },
     deleteExpired() {
@@ -92999,6 +94175,8 @@ function createSessionStatusFeed(deps) {
     stop() {
       stopped = true;
       if (deadlineTimer) clearTimeout(deadlineTimer);
+      for (const timer of writeTimers.values()) clearTimeout(timer);
+      writeTimers.clear();
     }
   };
 }
@@ -93043,14 +94221,20 @@ function createWatchLoop(deps) {
   const pendingCompletions = /* @__PURE__ */ new Map();
   let lifecycleChanged = false;
   const knownTranscripts = /* @__PURE__ */ new Set();
-  const rememberTranscript = (transcript) => {
-    knownTranscripts.delete(transcript);
-    knownTranscripts.add(transcript);
-    if (knownTranscripts.size > KNOWN_TRANSCRIPTS_MAX) {
-      const [oldest] = knownTranscripts;
-      if (oldest !== void 0) knownTranscripts.delete(oldest);
+  const knownSessions = /* @__PURE__ */ new Set();
+  const remember = (known, value) => {
+    known.delete(value);
+    known.add(value);
+    if (known.size > KNOWN_TRANSCRIPTS_MAX) {
+      const [oldest] = known;
+      if (oldest !== void 0) known.delete(oldest);
     }
   };
+  const rememberTranscript = (transcript) => remember(knownTranscripts, transcript);
+  const rememberSession = (session) => {
+    rememberTranscript(session.transcriptPath);
+    remember(knownSessions, sessionKey(session.item));
+  };
   const newTranscripts = /* @__PURE__ */ new Map();
   let newSessionTimer = null;
   let newSessionPassDue = false;
@@ -93093,13 +94277,13 @@ function createWatchLoop(deps) {
     running = true;
     deps.log(`${transcripts.length} new transcript file(s), uploading new session records now`);
     const startedAt = now();
-    const known = new Set(knownTranscripts);
+    const known = new Set(knownSessions);
     try {
       const summary = await runNewSessionPass({
         sinceMs: Math.min(...transcripts.map(([, firstWriteAt]) => firstWriteAt)) - NARROW_OVERLAP_MS,
-        isNew: (transcriptPath) => !known.has(transcriptPath)
+        isNew: (session) => !known.has(sessionKey(session.item))
       });
-      for (const session of summary.sessions) rememberTranscript(session.transcriptPath);
+      for (const session of summary.sessions) rememberSession(session);
       if (summary.upserted > 0) deps.onNewSessionsUploaded?.(now());
     } catch (error63) {
       const holdMs = Math.max(FAILED_PASS_RETRY_MS, retryAfterMs(error63) ?? 0);
@@ -93179,15 +94363,15 @@ function createWatchLoop(deps) {
       if (narrowSinceMs === void 0) startupOwed = false;
       for (const [key] of due) pendingCompletions.delete(key);
       for (const session of summary.sessions) {
-        rememberTranscript(session.transcriptPath);
+        rememberSession(session);
         newTranscripts.delete(session.transcriptPath);
         if (session.item.status === "active") {
-          pendingCompletions.set(session.transcriptPath, {
+          pendingCompletions.set(sessionKey(session.item), {
             mtimeMs: session.mtimeMs,
             dueAt: session.mtimeMs + ACTIVE_GRACE_MS + COMPLETION_SLACK_MS
           });
         } else {
-          pendingCompletions.delete(session.transcriptPath);
+          pendingCompletions.delete(sessionKey(session.item));
         }
       }
       consecutiveFailures = 0;
@@ -93280,8 +94464,16 @@ function createWatchLoop(deps) {
 function sessionStoreWatchRoots(home) {
   return [
     // <project folder>/<session id>.jsonl. Subagent files are one level deeper.
-    { dir: path21.join(home, ".claude", "projects"), recursive: true, transcripts: /^[^/\\]+[/\\][^/\\]+\.jsonl$/ },
-    { dir: path21.join(home, ".codex", "sessions"), recursive: true, transcripts: /(?:^|[/\\])rollout-[^/\\]+\.jsonl$/ },
+    {
+      dir: path21.join(home, ".claude", "projects"),
+      recursive: true,
+      transcripts: { harness: "claude-local", path: /^[^/\\]+[/\\][^/\\]+\.jsonl$/ }
+    },
+    {
+      dir: path21.join(home, ".codex", "sessions"),
+      recursive: true,
+      transcripts: { harness: "codex-local", path: /(?:^|[/\\])rollout-[^/\\]+\.jsonl$/ }
+    },
     { dir: path21.join(home, ".codex", "archived_sessions"), recursive: true },
     // Cursor keeps every local session in one SQLite store here. Its WAL
     // file changes on session writes, so a non-recursive watch on the
@@ -93294,7 +94486,10 @@ function sessionStoreWatchRoots(home) {
       dir: path21.join(home, ".cursor", "projects"),
       recursive: true,
       cursorTranscripts: true,
-      transcripts: /(?:^|[/\\])agent-transcripts[/\\](?:([^/\\]+)[/\\]\1|[^/\\]+)\.jsonl$/
+      transcripts: {
+        harness: "cursor-local",
+        path: /(?:^|[/\\])agent-transcripts[/\\](?:([^/\\]+)[/\\]\1|[^/\\]+)\.jsonl$/
+      }
     }
   ];
 }
@@ -93314,7 +94509,9 @@ function lifecycleWatchRoots(home) {
 function watchEventChange(root, filename) {
   const name = filename?.toString();
   if (root.cursorTranscripts && name !== void 0 && !/(?:^|[/\\])agent-transcripts[/\\].*\.jsonl$/.test(name)) return "ignore";
-  if (name !== void 0 && root.transcripts?.test(name)) return { transcript: path21.join(root.dir, name) };
+  if (name !== void 0 && root.transcripts?.path.test(name)) {
+    return { transcript: path21.join(root.dir, name), harness: root.transcripts.harness };
+  }
   if (!root.lifecycle) return void 0;
   return name === void 0 || isLifecycleJournalFile(name) || name === SESSION_CHANGE_FILENAME ? "lifecycle" : void 0;
 }
@@ -93334,11 +94531,13 @@ function watchSessionStores(roots, onEvent, onLost) {
 function newSessionSyncOptions(shared, sinceMs, isNew) {
   return {
     lifecycleJournal: shared.lifecycleJournal,
+    codexThreadLinks: shared.codexThreadLinks,
+    codexThreadReads: shared.codexThreadReads,
     log: shared.log,
     enrollCommand: shared.enrollCommand,
     explicitSince: String(STEADY_SYNC_WINDOW_DAYS),
     narrowSinceMs: sinceMs,
-    isNewSession: (session) => isNew(session.transcriptPath)
+    isNewSession: isNew
   };
 }
 function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
@@ -93533,15 +94732,19 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
   });
   const rawShipped = /* @__PURE__ */ new Map();
   const previewRegistrations = /* @__PURE__ */ new Map();
+  const codexThreadLinks = new CodexThreadLinks();
+  const codexThreadReads = new CodexThreadReads();
   const loop = createWatchLoop({
     runPass: async (options) => {
       let uploaded = 0;
       let activeSinceMs = Infinity;
-      const activePaths = /* @__PURE__ */ new Set();
+      const activeSessions = /* @__PURE__ */ new Set();
       let lastCatchupReportAt = -Infinity;
       const shared = {
         rawShipped,
         previewRegistrations,
+        codexThreadLinks,
+        codexThreadReads,
         lifecycleJournal: journal,
         log: log3,
         enrollCommand: runtime.enrollCommand,
@@ -93558,11 +94761,11 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
         const recent = await runSyncPass(config2, recentSyncOptions(
           shared,
           Math.min(narrowSinceMs, activeSinceMs),
-          { sinceMs: narrowSinceMs, paths: activePaths }
+          { sinceMs: narrowSinceMs, sessions: activeSessions }
         ));
         activeSinceMs = recentCatchupFloor(activeSinceMs, recent.sessions);
         for (const session of recent.sessions) {
-          if (session.item.status === "active") activePaths.add(session.transcriptPath);
+          if (session.item.status === "active") activeSessions.add(sessionKey(session.item));
         }
         return recent;
       });
@@ -93572,7 +94775,7 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
         beforeRawUpload: async (sessions) => {
           activeSinceMs = recentCatchupFloor(activeSinceMs, sessions);
           for (const session of sessions) {
-            if (session.item.status === "active") activePaths.add(session.transcriptPath);
+            if (session.item.status === "active") activeSessions.add(sessionKey(session.item));
           }
           const beforeCatchup = uploaded;
           try {
@@ -93595,7 +94798,7 @@ function startWatch(config2, homeDir, runtime = { version: "checkout" }) {
       }
       return summary;
     },
-    runNewSessionPass: ({ sinceMs, isNew }) => runSyncPass(config2, newSessionSyncOptions({ lifecycleJournal: journal, log: log3, enrollCommand: runtime.enrollCommand }, sinceMs, isNew)),
+    runNewSessionPass: ({ sinceMs, isNew }) => runSyncPass(config2, newSessionSyncOptions({ lifecycleJournal: journal, codexThreadLinks, codexThreadReads, log: log3, enrollCommand: runtime.enrollCommand }, sinceMs, isNew)),
     // An upload changes what the menu shows, so this write wakes the menu,
     // and the menu reads the new session from the server.
     onNewSessionsUploaded: (at) => writeStatus({ lastUploadAt: new Date(at).toISOString() }),
@@ -93865,7 +95068,7 @@ function hookPreferencesPath(appEnv, home) {
 function readHookPreferences(appEnv, home) {
   const file2 = hookPreferencesPath(appEnv, home);
   try {
-    return preferencesSchema.parse(JSON.parse(readFileSync12(file2, "utf8")));
+    return preferencesSchema.parse(JSON.parse(readFileSync13(file2, "utf8")));
   } catch (error63) {
     if (error63 instanceof Error && "code" in error63 && error63.code === "ENOENT") {
       return { version: 1, codexNotFiringDismissed: false };
@@ -93887,12 +95090,12 @@ function dismissCodexHookWarning(appEnv, home) {
   const file2 = hookPreferencesPath(appEnv, home);
   mkdirSync12(path24.dirname(file2), { recursive: true });
   const temporary = `${file2}.${process.pid}.tmp`;
-  writeFileSync10(temporary, JSON.stringify({ ...preferences, codexNotFiringDismissed: true }, null, 2), { mode: 384 });
-  renameSync6(temporary, file2);
+  writeFileSync9(temporary, JSON.stringify({ ...preferences, codexNotFiringDismissed: true }, null, 2), { mode: 384 });
+  renameSync7(temporary, file2);
 }
 
 // src/mcpPreferences.ts
-import { mkdirSync as mkdirSync13, readFileSync as readFileSync13, renameSync as renameSync7, writeFileSync as writeFileSync11 } from "node:fs";
+import { mkdirSync as mkdirSync13, readFileSync as readFileSync14, renameSync as renameSync8, writeFileSync as writeFileSync10 } from "node:fs";
 import path25 from "node:path";
 var preferenceSchema = external_exports.object({
   optedIn: external_exports.boolean().optional(),
@@ -93913,7 +95116,7 @@ function mcpPreferencesPath(appEnv, home) {
 function readMcpPreferences(appEnv, home) {
   const file2 = mcpPreferencesPath(appEnv, home);
   try {
-    return preferencesSchema2.parse(JSON.parse(readFileSync13(file2, "utf8")));
+    return preferencesSchema2.parse(JSON.parse(readFileSync14(file2, "utf8")));
   } catch (error63) {
     if (error63 instanceof Error && "code" in error63 && error63.code === "ENOENT") return emptyMcpPreferences();
     throw new ExpectedCliError(`Cannot read MCP preferences at ${file2}. Restore or remove that file, then retry.`, { cause: error63 });
@@ -93923,8 +95126,8 @@ function writeMcpPreferences(appEnv, preferences, home) {
   const file2 = mcpPreferencesPath(appEnv, home);
   mkdirSync13(path25.dirname(file2), { recursive: true });
   const temporary = `${file2}.${process.pid}.tmp`;
-  writeFileSync11(temporary, JSON.stringify(preferencesSchema2.parse(preferences), null, 2), { mode: 384 });
-  renameSync7(temporary, file2);
+  writeFileSync10(temporary, JSON.stringify(preferencesSchema2.parse(preferences), null, 2), { mode: 384 });
+  renameSync8(temporary, file2);
 }
 function recordMcpChoices(appEnv, offered, selected, home) {
   const preferences = readMcpPreferences(appEnv, home);
@@ -94087,7 +95290,7 @@ function sessionLinks(session, webUrl, options) {
         }
       };
     case "codex": {
-      const threadId2 = codexThreadId(session.externalId);
+      const threadId2 = codexThreadId2(session.externalId);
       if (threadId2 === null || !options.localMachine) return { powerplantUrl };
       return {
         powerplantUrl,
@@ -94104,7 +95307,7 @@ function sessionLinks(session, webUrl, options) {
   }
 }
 var TRAILING_UUID = /([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})$/i;
-function codexThreadId(externalId) {
+function codexThreadId2(externalId) {
   return TRAILING_UUID.exec(externalId)?.[1] ?? null;
 }
 var CODEX_APP_BUNDLES = ["ChatGPT.app", "Codex.app"];
@@ -94254,7 +95457,7 @@ async function probeClaudeDesktopSessions(wanted, installed, reportFault, root =
 
 // src/menuModel.ts
 import { randomUUID as randomUUID5 } from "node:crypto";
-import { mkdirSync as mkdirSync17, rmSync as rmSync9, watch as fsWatch3 } from "node:fs";
+import { mkdirSync as mkdirSync17, rmSync as rmSync10, watch as fsWatch3 } from "node:fs";
 import path34 from "node:path";
 
 // src/menu.ts
@@ -94276,15 +95479,15 @@ function ago(ms) {
 }
 
 // src/update.ts
-import { mkdirSync as mkdirSync14, readFileSync as readFileSync15, rmSync as rmSync7, writeFileSync as writeFileSync12 } from "node:fs";
+import { mkdirSync as mkdirSync14, readFileSync as readFileSync16, rmSync as rmSync8, writeFileSync as writeFileSync11 } from "node:fs";
 import path29 from "node:path";
 
 // src/installOwner.ts
-import { accessSync, constants as constants2, readFileSync as readFileSync14 } from "node:fs";
+import { accessSync, constants as constants2, readFileSync as readFileSync15 } from "node:fs";
 import path28 from "node:path";
 
 // src/version.ts
-var CLI_VERSION = true ? "0.4.18" : "0.0.0-checkout";
+var CLI_VERSION = true ? "0.4.19" : "0.0.0-checkout";
 var CLI_RELEASE_BUILD = true ? true : false;
 var CLI_PACKAGE_NAME = "@usepowerplant/cli";
 
@@ -94385,7 +95588,7 @@ function realInspectEnvironment() {
     pnpmHome: process.env.PNPM_HOME,
     readTextFile: (file2) => {
       try {
-        return readFileSync14(file2, "utf8");
+        return readFileSync15(file2, "utf8");
       } catch (error63) {
         if (error63 instanceof Error && "code" in error63 && error63.code === "ENOENT") return null;
         throw error63;
@@ -94451,18 +95654,18 @@ function updateProgressFile(report, homeDir) {
   return {
     read: () => readUpdateProgress((filePath) => {
       try {
-        return readFileSync15(filePath, "utf8");
+        return readFileSync16(filePath, "utf8");
       } catch {
         return null;
       }
     }, file2),
     write: (record2) => {
       mkdirSync14(path29.dirname(file2), { recursive: true });
-      writeFileSync12(file2, JSON.stringify(record2, null, 2));
+      writeFileSync11(file2, JSON.stringify(record2, null, 2));
       wakeMenus2();
     },
     clear: () => {
-      rmSync7(file2, { force: true });
+      rmSync8(file2, { force: true });
       wakeMenus2();
     }
   };
@@ -95231,7 +96434,7 @@ function writeVersionCache(options) {
 }
 
 // src/menuSnapshot.ts
-import { chmodSync as chmodSync5, mkdirSync as mkdirSync15, readFileSync as readFileSync16, renameSync as renameSync8, rmSync as rmSync8, statSync as statSync5, writeFileSync as writeFileSync13 } from "node:fs";
+import { chmodSync as chmodSync4, mkdirSync as mkdirSync15, readFileSync as readFileSync17, renameSync as renameSync9, rmSync as rmSync9, statSync as statSync6, writeFileSync as writeFileSync12 } from "node:fs";
 import path31 from "node:path";
 var MENU_SNAPSHOT_VERSION = 1;
 var MENU_SNAPSHOT_STALE_AFTER_MS = 3 * 6e4;
@@ -95276,19 +96479,19 @@ var snapshotFileSchema = external_exports.object({
 function writeMenuSnapshot(file2, snapshot) {
   const dir = path31.dirname(file2);
   mkdirSync15(dir, { recursive: true, mode: 448 });
-  chmodSync5(dir, 448);
+  chmodSync4(dir, 448);
   const temporary = `${file2}.${process.pid}.tmp`;
   try {
-    writeFileSync13(temporary, encodeMenuPayload(snapshot), { mode: 384 });
-    renameSync8(temporary, file2);
+    writeFileSync12(temporary, encodeMenuPayload(snapshot), { mode: 384 });
+    renameSync9(temporary, file2);
   } finally {
-    rmSync8(temporary, { force: true });
+    rmSync9(temporary, { force: true });
   }
 }
 function readMenuSnapshot(options) {
   let raw;
   try {
-    raw = readFileSync16(options.file, "utf8");
+    raw = readFileSync17(options.file, "utf8");
   } catch (error63) {
     return { outcome: error63 instanceof Error && "code" in error63 && error63.code === "ENOENT" ? "missing" : "unreadable" };
   }
@@ -95328,7 +96531,7 @@ function isPidAlive2(pid) {
 }
 function requestedAfter(file2, writtenAtMs) {
   try {
-    return statSync5(file2).mtimeMs > writtenAtMs;
+    return statSync6(file2).mtimeMs > writtenAtMs;
   } catch {
     return false;
   }
@@ -95336,7 +96539,7 @@ function requestedAfter(file2, writtenAtMs) {
 
 // src/connect.ts
 import { spawnSync as spawnSync2 } from "node:child_process";
-import { mkdirSync as mkdirSync16, readFileSync as readFileSync17, statSync as statSync6, writeFileSync as writeFileSync14 } from "node:fs";
+import { mkdirSync as mkdirSync16, readFileSync as readFileSync18, statSync as statSync7, writeFileSync as writeFileSync13 } from "node:fs";
 import os23 from "node:os";
 import path32 from "node:path";
 import { emitKeypressEvents } from "node:readline";
@@ -95445,7 +96648,7 @@ function unsigned(candidate, verifySignature) {
 }
 function isExecutableFile2(filePath) {
   try {
-    const stats = statSync6(filePath);
+    const stats = statSync7(filePath);
     return stats.isFile() && (stats.mode & 73) !== 0;
   } catch {
     return false;
@@ -96132,14 +97335,14 @@ async function fetchOfficialClients(apiUrl, log3) {
 }
 function realReadTextFile(filePath) {
   try {
-    return readFileSync17(filePath, "utf8");
+    return readFileSync18(filePath, "utf8");
   } catch {
     return null;
   }
 }
 function realReadTextFileStrict(filePath) {
   try {
-    return readFileSync17(filePath, "utf8");
+    return readFileSync18(filePath, "utf8");
   } catch (error63) {
     if (error63 instanceof Error && error63.code === "ENOENT") return null;
     throw error63;
@@ -96147,7 +97350,7 @@ function realReadTextFileStrict(filePath) {
 }
 function realWriteTextFile(filePath, content) {
   mkdirSync16(path32.dirname(filePath), { recursive: true });
-  writeFileSync14(filePath, content);
+  writeFileSync13(filePath, content);
 }
 function realOpenUrl(url2) {
   const bin = process.platform === "darwin" ? "open" : process.platform === "linux" ? "xdg-open" : null;
@@ -96685,7 +97888,7 @@ function startMenuModel(sources) {
         })
       ),
       writeSnapshot: (snapshot) => writeMenuSnapshot(snapshotFile, snapshot),
-      removeSnapshot: () => rmSync9(snapshotFile, { force: true }),
+      removeSnapshot: () => rmSync10(snapshotFile, { force: true }),
       wake: () => signalMenu(appEnv, host.home),
       watchRefreshRequests: (onRequest, onLost) => {
         const dir = path34.dirname(menuRefreshRequestPath(appEnv, host.home));
@@ -96708,7 +97911,7 @@ import path37 from "node:path";
 import { parseArgs } from "node:util";
 
 // src/doctor.ts
-import { closeSync as closeSync8, fstatSync as fstatSync2, openSync as openSync8, readSync as readSync6 } from "node:fs";
+import { closeSync as closeSync8, fstatSync as fstatSync3, openSync as openSync8, readSync as readSync6 } from "node:fs";
 var DOCTOR_LOG_TAIL_LINES = 50;
 var LOG_TAIL_READ_BYTES = 256 * 1024;
 function installLine(install) {
@@ -96730,7 +97933,7 @@ function readDoctorLogTail(path38) {
     return { path: path38, lines: null, readError: error63 instanceof Error ? error63.message : String(error63) };
   }
   try {
-    const size = fstatSync2(fd).size;
+    const size = fstatSync3(fd).size;
     const offset = Math.max(0, size - LOG_TAIL_READ_BYTES);
     const buffer = Buffer.alloc(Math.min(size, LOG_TAIL_READ_BYTES));
     readSync6(fd, buffer, 0, buffer.length, offset);
@@ -97813,7 +99016,7 @@ async function tryCredentialUpgradeLock(file2) {
 }
 
 // src/menubarApp.ts
-import { existsSync as existsSync14, mkdirSync as mkdirSync19, renameSync as renameSync9, rmSync as rmSync10 } from "node:fs";
+import { existsSync as existsSync14, mkdirSync as mkdirSync19, renameSync as renameSync10, rmSync as rmSync11 } from "node:fs";
 import os25 from "node:os";
 import path36 from "node:path";
 import { spawnSync as spawnSync4 } from "node:child_process";
@@ -97883,8 +99086,8 @@ function realMenubarAppOps(input2) {
       mkdirSync19(parent, { recursive: true });
       const staging = path36.join(parent, `.${MENUBAR_APP_NAME}.swap-${process.pid}`);
       const retired = path36.join(parent, `.${MENUBAR_APP_NAME}.old-${process.pid}`);
-      rmSync10(staging, { recursive: true, force: true });
-      rmSync10(retired, { recursive: true, force: true });
+      rmSync11(staging, { recursive: true, force: true });
+      rmSync11(retired, { recursive: true, force: true });
       try {
         const extract = spawnSync4("ditto", ["-xk", zip, staging]);
         if (extract.status !== 0) {
@@ -97897,16 +99100,16 @@ function realMenubarAppOps(input2) {
           throw new Error(`${zip} does not contain ${MENUBAR_APP_NAME}`);
         }
         const hadOld = existsSync14(appPath);
-        if (hadOld) renameSync9(appPath, retired);
+        if (hadOld) renameSync10(appPath, retired);
         try {
-          renameSync9(extracted, appPath);
+          renameSync10(extracted, appPath);
         } catch (error63) {
-          if (hadOld) renameSync9(retired, appPath);
+          if (hadOld) renameSync10(retired, appPath);
           throw error63;
         }
       } finally {
-        rmSync10(staging, { recursive: true, force: true });
-        rmSync10(retired, { recursive: true, force: true });
+        rmSync11(staging, { recursive: true, force: true });
+        rmSync11(retired, { recursive: true, force: true });
       }
     },
     launch: (appPath) => {
@@ -98890,4 +100093,4 @@ undici/lib/web/websocket/frame.js:
   (*! ws. MIT License. Einar Otto Stangvik <einaros@gmail.com> *)
 */
 
-//# debugId=7730a7ff-ca8b-5911-9406-4ee9329a7ea8
+//# debugId=5ecc7184-ee4b-53d3-858b-4d0790456d70