transcript-viewer 0.11.0__tar.gz → 0.11.2__tar.gz

{transcript_viewer-0.11.0 → transcript_viewer-0.11.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: transcript-viewer
-Version: 0.11.0
+Version: 0.11.2
 Summary: Browse agent transcripts in a local, dependency-free web viewer.
 License: MIT
 Requires-Python: >=3.12
@@ -182,8 +182,14 @@ so. Nothing is left behind and nothing is copied twice.
 A run that delegated shows a **timeline** above its steps: one lane per
 subagent, laid out on the clock. It exists for the one thing a nested box
 cannot say — that two subagents were running at the same moment, which 25 pairs
-in the corpus this was built against were. Clicking a lane opens the box the
-transcript already has for it rather than showing the same thing twice.
+in the corpus this was built against were. Two bars in the same column of the
+chart is what says it; overlap gets no colour of its own, since a second
+encoding of the same fact is noise.
+
+Clicking a lane opens the box the transcript already has for it rather than
+showing the same thing twice, drawing the run out far enough to reach it first:
+a long run paints 250 steps at a time, and in one real session every delegation
+happens after step 1,231.
 
 Where a session spans days but holds hours of work — one runs 10.3 days and
 contains 5.3 hours, with 31 gaps over an hour — the quiet stretches are skipped

{transcript_viewer-0.11.0 → transcript_viewer-0.11.2}/README.md

@@ -169,8 +169,14 @@ so. Nothing is left behind and nothing is copied twice.
 A run that delegated shows a **timeline** above its steps: one lane per
 subagent, laid out on the clock. It exists for the one thing a nested box
 cannot say — that two subagents were running at the same moment, which 25 pairs
-in the corpus this was built against were. Clicking a lane opens the box the
-transcript already has for it rather than showing the same thing twice.
+in the corpus this was built against were. Two bars in the same column of the
+chart is what says it; overlap gets no colour of its own, since a second
+encoding of the same fact is noise.
+
+Clicking a lane opens the box the transcript already has for it rather than
+showing the same thing twice, drawing the run out far enough to reach it first:
+a long run paints 250 steps at a time, and in one real session every delegation
+happens after step 1,231.
 
 Where a session spans days but holds hours of work — one runs 10.3 days and
 contains 5.3 hours, with 31 gaps over an hour — the quiet stretches are skipped

{transcript_viewer-0.11.0 → transcript_viewer-0.11.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "transcript-viewer"
-version = "0.11.0"
+version = "0.11.2"
 description = "Browse agent transcripts in a local, dependency-free web viewer."
 readme = "README.md"
 requires-python = ">=3.12"

{transcript_viewer-0.11.0 → transcript_viewer-0.11.2}/src/transcript_viewer/page.html

@@ -371,6 +371,8 @@ pre{background:var(--sunk);border-radius:7px;padding:10px;overflow:auto;font-siz
 .branch .inner{padding:6px 14px 4px 22px;border-top:1px solid var(--line);background:var(--sunk)}
 .branch .inner .step{border-left-color:var(--line)}
 .miss{padding:9px 12px;color:var(--dim);font-size:12.5px}
+/* Where a lane just sent you. Long enough to notice, short enough to forget. */
+.branch.found{box-shadow:0 0 0 2px var(--accent)}
 
 /* ---- delegation timeline ----
    Nested boxes cannot show that two subagents ran at once, and 25 pairs in the
@@ -396,7 +398,6 @@ pre{background:var(--sunk);border-radius:7px;padding:10px;overflow:auto;font-siz
 .lane.tight .track{height:13px}
 .track .rule{position:absolute;left:0;right:0;top:50%;height:1px;background:var(--line)}
 .track .tick{position:absolute;top:0;bottom:0;width:1px;background:var(--line);opacity:.45}
-.track .band{position:absolute;top:0;bottom:0;background:var(--hl)}
 /* A floor, so a four-minute subagent in a thirty-hour run is still a target.
    Where a bar is at the floor its width is not its duration — the card and
    the tooltip carry the real one. */
@@ -420,6 +421,9 @@ pre{background:var(--sunk);border-radius:7px;padding:10px;overflow:auto;font-siz
 .gapmark:after{content:"";position:absolute;left:-2px;top:0;bottom:0;width:5px;
   background:var(--bg);opacity:.9;border-left:1px dashed var(--muted);
   border-right:1px dashed var(--muted);opacity:.35}
+/* Conversations that belong to the record rather than to any step. */
+.loose{margin-top:18px;padding-top:12px;border-top:1px solid var(--line)}
+.loose-head{font:11px var(--font-mono);color:var(--muted);margin-bottom:8px}
 .lanes-legend{display:flex;align-items:center;gap:14px;margin-top:10px;padding-top:9px;
   border-top:1px solid var(--line);font-size:11px;color:var(--muted);flex-wrap:wrap}
 .lanes-legend i{display:inline-block;width:16px;height:8px;border-radius:2px;
@@ -2366,6 +2370,9 @@ function haystack(s){
    Where they do not, the same lanes are laid out by step position and the axis
    says so, rather than inventing a duration. */
 
+/* "1 subagent" and "2 subagents", said once rather than at each call site. */
+const many = (n, one, more) => `${num(n)} ${n === 1 ? one : more || one + "s"}`;
+
 const at = (s) => {
   const t = s && s.timestamp;
   if (!t) return null;
@@ -2419,6 +2426,36 @@ function laneIndex(t) {
     });
   };
   walk(t, 0);
+
+  // A subagent that no call refers to. ATIF links delegation from the result of
+  // the call that spawned it, but not every format has a call to link from:
+  // MALT's records carry an advisor, an agent and its raters as trajectories in
+  // their own right, spawned by nothing. Walking only the references missed all
+  // of them, and a record with ten subagents drew no timeline at all.
+  const linked = new Set(lanes.map((l) => l.id));
+  const loose = (parent, depth) => {
+    for (const sub of parent.subagent_trajectories || []) {
+      if (!linked.has(sub.trajectory_id)) {
+        const x = sub.extra || {};
+        lanes.push({
+          id: sub.trajectory_id,
+          kind: x.agentType || sub.agent?.name || "subagent",
+          said: x.description || "",
+          steps: (sub.steps || []).length,
+          tools: [...new Set((sub.steps || []).flatMap(
+            (s) => (s.tool_calls || []).map((c) => c.function_name)))],
+          span: spanMs(sub.steps),
+          fromStep: null,
+          fromIndex: 0,
+          depth,
+        });
+        linked.add(sub.trajectory_id);
+      }
+      loose(sub, depth + 1);
+    }
+  };
+  loose(t, 0);
+
   return lanes;
 }
 
@@ -2529,10 +2566,17 @@ function drawLanes(t) {
          width:${Math.max(100 / Math.max(1, steps), 0.6)}%" title="${esc(lane.kind)}"
          onmouseenter="laneCard(event,'${esc(lane.id)}')" onmouseleave="laneCard(null)"
          onclick="openLane('${esc(lane.id)}')"></button>`)).join("");
-    return laneShell(LANES.length, "", rows,
-      laneRow({ kind: "main thread", steps, main: true }, tight,
+    return laneShell({
+      count: LANES.length,
+      rows,
+      mainRow: laneRow({ kind: "main thread", steps, main: true }, tight,
         `<span class="bar main" style="left:0;width:100%"></span>`),
-      "", "no timestamps — laid out by step");
+      marks: "",
+      // No clock to lay anything against, so no duration is claimed and no
+      // overlap either: without times, two bars sitting side by side would
+      // say something the log never recorded.
+      note: "laid out by step · these steps carry no times",
+    });
   }
 
   // Everything the run touched, parent and children alike.
@@ -2547,11 +2591,6 @@ function drawLanes(t) {
   const scale = timeScale(lo, hi, busy);
   const bands = together(timed);
 
-  const bandLayer = bands.map(([a, b]) => {
-    const left = scale.posOf(a);
-    return `<span class="band" style="left:${left}%;width:${Math.max(scale.posOf(b) - left, 0.3)}%"></span>`;
-  }).join("");
-
   const breaks = scale.gaps.map((g) =>
     `<span class="gapmark" style="left:${g.at}%" title="nothing running for ${esc(g.took)}"></span>`
   ).join("");
@@ -2579,13 +2618,24 @@ function drawLanes(t) {
     return { pos: (m.pos / 100) * scale.room, label: m.label };
   });
 
-  const note = scale.gaps.length
-    ? `${num(scale.gaps.length)} quiet stretch${scale.gaps.length === 1 ? "" : "es"} skipped · ${duration(scale.skipped)} idle`
-    : "on the clock · click a bar to open it";
-
-  return laneShell(LANES.length, duration(scale.kept), rows, mainRow,
-    marks.map((m) => `<span style="left:${m.pos}%">${esc(m.label)}</span>`).join(""),
-    note, bandLayer + breaks, bands.length);
+  // What the axis leaves out, in the reader's terms. How many separate gaps
+  // were collapsed is a fact about the drawing, not about the run, so it is not
+  // said; how much time is missing from the picture very much is.
+  const hidden = scale.gaps.length ? `${duration(scale.skipped)} of waiting hidden` : "";
+  const note = [hidden, "click a bar to open it"].filter(Boolean).join(" · ");
+
+  const [shownAs, wholeAs] = durationPair(scale.kept, hi - lo);
+  return laneShell({
+    count: LANES.length,
+    shown: shownAs,
+    whole: wholeAs,
+    rows,
+    mainRow,
+    marks: marks.map((m) => `<span style="left:${m.pos}%">${esc(m.label)}</span>`).join(""),
+    note,
+    layer: breaks,
+    overlaps: bands.length,
+  });
 }
 
 /* One row: who, how many steps, and the track it sits on. */
@@ -2602,14 +2652,35 @@ function laneRow(lane, tight, inner) {
 }
 
 /* The frame around the lanes: what it is, the axis, and what was left out. */
-function laneShell(count, span, rows, mainRow, marks, note, layer, overlaps) {
+/* What the header says about a run. Every clause is computed, and each is true
+   of any transcript rather than of the one it was written against:
+
+   - the count of subagents;
+   - how much time the axis is showing, and — only when they differ — the whole
+     stretch it was drawn from. Saying "31h" of a run that ran ten days would be
+     wrong, and it is the axis that was shortened, not the run;
+   - how many times two or more were going at once, which is what the view is
+     for. Called "overlapped" rather than "stretches", because the skipped
+     stretches below are the opposite thing and the word was doing both jobs.
+*/
+function laneHeader({ count, shown, whole, overlaps }) {
+  const parts = [many(count, "subagent")];
+  if (shown) parts.push(whole && whole !== shown ? `${shown} shown of ${whole}` : shown);
+  if (overlaps) {
+    parts.push(
+      `<em>overlapped ${overlaps === 1 ? "once" : many(overlaps, "time")}</em>`,
+    );
+  }
+  return parts;
+}
+
+function laneShell({ count, shown, whole, rows, mainRow, marks, note, layer, overlaps }) {
+  const parts = laneHeader({ count, shown, whole, overlaps });
   return `
     <details id="lanes" open>
       <summary>
         <b>Delegation</b>
-        <span class="fine">${num(count)} subagent${count === 1 ? "" : "s"}${span ? " · " + span : ""}${
-          overlaps ? ` · <em>${num(overlaps)} stretch${overlaps === 1 ? "" : "es"} with two or more at once</em>` : ""
-        }</span>
+        <span class="fine">${parts.join(" · ")}</span>
       </summary>
       <div class="lanes-body">
         <div class="lane-axis${rows.includes("lane tight") ? " tight" : ""}">
@@ -2623,7 +2694,6 @@ function laneShell(count, span, rows, mainRow, marks, note, layer, overlaps) {
         <div class="lanes-legend">
           <span><i style="background:var(--ink);opacity:.85"></i>main thread</span>
           <span><i style="background:var(--accent);opacity:.85"></i>subagent</span>
-          ${overlaps ? `<span><i style="background:var(--hl)"></i>two or more at once</span>` : ""}
           <span class="lanes-note">${esc(note)}</span>
         </div>
       </div>
@@ -2671,16 +2741,73 @@ function laneCard(ev, id) {
 /* Open the subagent a lane stands for: scroll to the step that called it and
    unfold the box that is already there, rather than inventing a second place
    for the same thing to live. */
+/* Open the subagent a lane stands for: reach the step that called it, unfold
+   the box already there, and go to it.
+
+   A long run is drawn 250 steps at a time. In one real session all thirty
+   delegations happen after step 1,231, so the box a lane pointed at had never
+   been painted and the click did nothing at all. The run is drawn far enough
+   first. A lane from a record where nothing spawned it is found in the block
+   after the run instead — which only exists in the plain view, so a lens or a
+   search is cleared to get back to it rather than failing quietly. */
 function openLane(id) {
   laneCard(null);
-  const box = document.querySelector(`details.branch[data-lane="${CSS.escape(id)}"]`);
-  if (!box) return;
+  const lane = LANES.find((l) => l.id === id);
+  if (!lane) return;
+
+  const find = () =>
+    document.querySelector(`details.branch[data-lane="${CSS.escape(id)}"]`);
+
+  let box = find();
+  if (!box) {
+    let repaint = false;
+    if (lane.fromStep === null && (lens !== "all" || query)) {
+      lens = "all";
+      query = "";
+      repaint = true;
+    }
+    if (lane.fromIndex >= limit) {
+      // Far enough to include it, and a little beyond so it is not the last row.
+      limit = lane.fromIndex + PAGE_SIZE;
+      repaint = true;
+    }
+    if (repaint) render();
+    box = find();
+  }
+  if (!box) {
+    note("That subagent is not in this view.");
+    return;
+  }
+
   box.open = true;
-  box.scrollIntoView({ behavior: "smooth", block: "center" });
   box.classList.add("found");
+  // After the fold, not before: opening changes the height, and scrolling to
+  // where the box used to end leaves the reader above what they asked for.
+  requestAnimationFrame(() =>
+    box.scrollIntoView({ behavior: "smooth", block: "center" }),
+  );
   setTimeout(() => box.classList.remove("found"), 1400);
 }
 
+/* Subagents that no call refers to. They are drawn after the run rather than
+   inside it, because there is no step they belong to: MALT records an advisor,
+   an agent and its raters as trajectories spawned by nothing, and until now the
+   viewer held them without ever showing them. The timeline made that visible by
+   pointing at boxes that were not there. */
+function looseSubagents(t){
+  const linked=new Set();
+  const mark=p=>{
+    for(const s of p.steps||[]){
+      for(const r of s.observation?.results||[]){
+        for(const ref of r.subagent_trajectory_ref||[])linked.add(ref.trajectory_id);
+      }
+    }
+    for(const sub of p.subagent_trajectories||[])mark(sub);
+  };
+  mark(t);
+  return (t.subagent_trajectories||[]).filter(s=>!linked.has(s.trajectory_id));
+}
+
 function branchIndex(t){
   const out=[];
   t.steps.forEach((s,i)=>{
@@ -2787,7 +2914,16 @@ function trajectoryTab(t,e,branches,branchSteps,counts,q){
     ${shown.map(({s,i})=>step(s,t,0,i,"")).join("")
       ||`<div class="empty">Nothing matches.</div>`}
     ${total>shown.length?`<div class="more"><button onclick="more()">Show more —
-        ${num(shown.length)} of ${num(total)} steps</button></div>`:""}`;
+        ${num(shown.length)} of ${num(total)} steps</button></div>`:""}
+    ${(()=>{
+      // Only in the plain view: a lens or a search is a question about the
+      // steps of this run, and answering it with whole other conversations
+      // would be answering something else.
+      if(lens!=="all"||q)return "";
+      const loose=looseSubagents(t);
+      return loose.length?`<div class="loose"><div class="loose-head">
+          ${many(loose.length,"other conversation")} in this record — no step spawned them</div>
+        ${loose.map(sub=>branch({trajectory_id:sub.trajectory_id},t,0)).join("")}</div>`:""})()}`;
 }
 
 /* The switch stays visible when AI is off for a transcript — otherwise there
@@ -2936,6 +3072,16 @@ function spanOf(steps){
   return ms>0?ms:null;
 }
 
+/* Two durations that will be read against each other, in one unit, so "75m
+   shown of 1.6h" cannot happen — the pair is scaled by the larger of them. */
+function durationPair(small, large){
+  if(small==null||large==null)return [duration(small),duration(large)];
+  const unit=large/1000<90?1000:large/60000<90?60000:large/3600000<48?3600000:86400000;
+  const suffix=unit===1000?"s":unit===60000?"m":unit===3600000?"h":"d";
+  const show=v=>{const n=v/unit;return (n<10?n.toFixed(1).replace(/\.0$/,""):String(Math.round(n)))+suffix};
+  return [show(small),show(large)];
+}
+
 function duration(ms){
   if(ms==null)return null;
   // A whole number reads better without the decimal: 2h, not 2.0h.

{transcript_viewer-0.11.0 → transcript_viewer-0.11.2}/tests/page.test.js

@@ -66,8 +66,31 @@ for (const id of [
 const SAFE_FETCH = () =>
   Promise.resolve({ ok: true, json: () => Promise.resolve({}) });
 
+/* Lookup by id, as the page expects. Reset with fetch on every run: a test that
+   stubs it to watch one element used to leave the next test's render() holding
+   an object with no focus(), which fails somewhere else entirely. */
+const SAFE_BY_ID = () => null;
+
+/* Looking for an element by selector, against what was actually painted. The
+   stub DOM holds markup as a string rather than a tree, so this answers the one
+   question the page asks — is this box on the page — from that string. */
+const SAFE_QUERY = (sel) => {
+  const m = /\[data-lane="([^"]+)"\]/.exec(sel);
+  if (!m) return null;
+  const html = (global.main && global.main.innerHTML) || "";
+  return html.includes(`data-lane="${m[1]}"`)
+    ? { open: false, classList: { add() {}, remove() {} }, scrollIntoView() {} }
+    : null;
+};
+
+/* The page escapes an id before putting it in a selector; the stub DOM has no
+   CSS object, so provide the one method that is used. */
+global.CSS = { escape: (v) => String(v).replace(/["\\]/g, "\\$&") };
+
 const run = (body) => {
   global.fetch = SAFE_FETCH;
+  global.document.getElementById = SAFE_BY_ID;
+  global.document.querySelector = SAFE_QUERY;
   return eval(script + "\n;(() => {" + body + "})()");
 };
 
@@ -1840,8 +1863,30 @@ test("the timeline says how many ran at once", () => {
   const html = run(`return drawLanes(${JSON.stringify(TWO_AT_ONCE)})`);
   assert.match(html, /id="lanes"/);
   assert.match(html, /2 subagents/);
-  assert.match(html, /two or more at once/);
-  assert.match(html, /class="band"/, "the overlap is drawn, not only counted");
+  assert.match(html, /overlapped once/, "one overlap reads as once, not '1 times'");
+  // Overlap is not given a colour of its own: two bars in the same column of
+  // the chart already say it, and a second encoding of the same fact is noise.
+  assert.ok(!/class="band"/.test(html), "the lanes are the encoding");
+});
+
+test("the header counts, and counts in English", () => {
+  const one = run(`return laneHeader({count: 1, shown: "5m", overlaps: 0}).join(" · ")`);
+  assert.strictEqual(one, "1 subagent · 5m");
+
+  const some = run(`return laneHeader({count: 12, shown: "2h", overlaps: 4}).join(" · ")`);
+  assert.match(some, /^12 subagents · 2h · /);
+  assert.match(some, /overlapped 4 times/);
+});
+
+test("the header never passes off the drawn time as the whole run", () => {
+  // The axis skips the waiting, so a run of ten days can show thirty-one hours.
+  // Saying "31h" alone would be false about the run.
+  const elided = run(`return laneHeader({count: 3, shown: "31h", whole: "10d"}).join(" · ")`);
+  assert.match(elided, /31h shown of 10d/);
+
+  // Where nothing was skipped the two are the same and it says it once.
+  const straight = run(`return laneHeader({count: 3, shown: "20m", whole: "20m"}).join(" · ")`);
+  assert.strictEqual(straight, "3 subagents · 20m");
 });
 
 test("a transcript that delegated nothing gets no timeline at all", () => {
@@ -1856,8 +1901,10 @@ test("without timestamps the lanes fall back to step position and say so", () =>
     for (const s of sub.steps) delete s.timestamp;
   }
   const html = run(`return drawLanes(${JSON.stringify(untimed)})`);
-  assert.match(html, /no timestamps/, "it must not imply a duration it does not have");
+  assert.match(html, /carry no times/, "it must not imply a duration it does not have");
   assert.ok(!/class="band"/.test(html), "and must not claim overlap it cannot know");
+  assert.ok(!/overlapped/.test(html), "nor say two things ran together");
+  assert.ok(!/hidden/.test(html), "nor that anything was left out");
 });
 
 test("the axis is read in whole units, not seven of them", () => {
@@ -1946,7 +1993,134 @@ test("what was skipped is stated, not swallowed", () => {
       ] }],
   };
   const html = run(`return drawLanes(${JSON.stringify(t)})`);
-  assert.match(html, /quiet stretch/, "a reader must be told time was left out");
-  assert.match(html, /idle/);
+  assert.match(html, /of waiting hidden/, "a reader must be told time was left out");
+  assert.match(html, /shown of/, "and that the axis is shorter than the run");
   assert.match(html, /class="gapmark"/, "and see where");
+  // How many gaps were collapsed is a fact about the drawing, not the run.
+  assert.ok(!/\d+ quiet stretch/.test(html), "that is not the reader's business");
+});
+
+test("every phrase in the timeline is computed, none of it written per run", () => {
+  // The header and note are built from counts and durations alone: the same run
+  // renders the same words, and a different one renders different ones for the
+  // same reason. Nothing here is specific to any transcript.
+  const twice = [1, 2].map(() =>
+    run(`return drawLanes(${JSON.stringify(TWO_AT_ONCE)})`),
+  );
+  assert.strictEqual(twice[0], twice[1], "the same run must read the same way");
+
+  const bigger = JSON.parse(JSON.stringify(TWO_AT_ONCE));
+  bigger.subagent_trajectories[1].steps = [
+    { step_id: 1, source: "agent", timestamp: "2026-01-01T10:30:00Z" },
+    { step_id: 2, source: "agent", timestamp: "2026-01-01T10:40:00Z" },
+  ];
+  const changed = run(`return drawLanes(${JSON.stringify(bigger)})`);
+  assert.notStrictEqual(changed, twice[0], "a different run must read differently");
+  assert.ok(!/overlapped/.test(changed), "and this one no longer overlaps");
+});
+
+test("a subagent no call spawned still gets a lane and a box", () => {
+  // MALT records an advisor, an agent and its raters as trajectories in their
+  // own right. Walking only the call references found none of them, so a record
+  // with ten subagents drew no timeline and showed none of them anywhere.
+  const t = {
+    steps: [{ step_id: 1, source: "user", message: "do the thing",
+      timestamp: "2026-01-01T10:00:00Z" }],
+    subagent_trajectories: [
+      { trajectory_id: "advisor", agent: { name: "metr-malt" }, extra: {},
+        steps: [{ step_id: 1, source: "agent", timestamp: "2026-01-01T10:00:05Z" },
+                { step_id: 2, source: "agent", timestamp: "2026-01-01T10:02:00Z" }] },
+      { trajectory_id: "rater", agent: { name: "metr-malt" }, extra: {},
+        steps: [{ step_id: 1, source: "agent", timestamp: "2026-01-01T10:01:00Z" },
+                { step_id: 2, source: "agent", timestamp: "2026-01-01T10:03:00Z" }] },
+    ],
+  };
+
+  const lanes = run(`return laneIndex(${JSON.stringify(t)})`);
+  assert.strictEqual(lanes.length, 2, "both belong on the timeline");
+  assert.deepStrictEqual(lanes.map((l) => l.fromStep), [null, null],
+    "and neither claims a step spawned it");
+
+  const loose = run(`return looseSubagents(${JSON.stringify(t)}).map(s=>s.trajectory_id)`);
+  assert.deepStrictEqual(loose, ["advisor", "rater"],
+    "the transcript must show them somewhere, or the lanes point at nothing");
+});
+
+test("a subagent a call did spawn is not also shown loose", () => {
+  const t = {
+    steps: [{ step_id: 1, source: "agent",
+      tool_calls: [{ tool_call_id: "c1", function_name: "Task" }],
+      observation: { results: [{ source_call_id: "c1",
+        subagent_trajectory_ref: [{ trajectory_id: "a" }] }] } }],
+    subagent_trajectories: [{ trajectory_id: "a", agent: { name: "claude-code" },
+      extra: {}, steps: [] }],
+  };
+  const loose = run(`return looseSubagents(${JSON.stringify(t)})`);
+  assert.deepStrictEqual(loose, [], "it already has a home in the run");
+});
+
+test("two durations read against each other share a unit", () => {
+  // "75m shown of 1.6h" is two scales in one sentence.
+  const pair = run(`return durationPair(75*60000, 96*60000)`);
+  assert.deepStrictEqual(pair, ["1.3h", "1.6h"]);
+
+  const wide = run(`return durationPair(31*3600000, 10*86400000)`);
+  assert.deepStrictEqual(wide, ["1.3d", "10d"]);
+});
+
+test("a lane reaches its box even when the run has not been drawn that far", () => {
+  // The bug: a long run paints 250 steps at a time, and in one real session all
+  // thirty delegations happen after step 1,231 — so the box a lane pointed at
+  // had never been painted and clicking did nothing whatever.
+  const steps = [];
+  for (let i = 0; i < 400; i++) {
+    steps.push({ step_id: i + 1, source: "agent", message: "working" });
+  }
+  steps[300] = {
+    step_id: 301, source: "agent",
+    tool_calls: [{ tool_call_id: "c1", function_name: "Task" }],
+    observation: { results: [{ source_call_id: "c1",
+      subagent_trajectory_ref: [{ trajectory_id: "far" }] }] },
+  };
+  const t = {
+    steps,
+    subagent_trajectories: [{ trajectory_id: "far", agent: { name: "claude-code" },
+      extra: { agentType: "Explore" }, steps: [] }],
+  };
+
+  const out = run(
+    setup({ ...ROW, key: "k" }) + `
+    traj = ${JSON.stringify(t)};
+    cur = "k"; lens = "all"; query = ""; limit = 250;
+    render();
+    const before = !!document.querySelector('details.branch[data-lane="far"]');
+    LANES = laneIndex(traj);
+    openLane("far");
+    const after = !!document.querySelector('details.branch[data-lane="far"]');
+    return { before, after, limit };
+  `);
+
+  assert.strictEqual(out.before, false, "the box starts undrawn — this is the bug");
+  assert.strictEqual(out.after, true, "and the click has to reach it");
+  assert.ok(out.limit > 300, `the run was drawn far enough (limit ${out.limit})`);
+});
+
+test("a lane whose box is filtered away brings the view back rather than failing", () => {
+  const t = {
+    steps: [{ step_id: 1, source: "user", message: "go" }],
+    subagent_trajectories: [{ trajectory_id: "loose", agent: { name: "metr-malt" },
+      extra: {}, steps: [] }],
+  };
+  const out = run(
+    setup({ ...ROW, key: "k" }) + `
+    traj = ${JSON.stringify(t)};
+    cur = "k"; lens = "tools"; query = "nothing matches this"; limit = 250;
+    render();
+    LANES = laneIndex(traj);
+    openLane("loose");
+    return { lens, query, found: !!document.querySelector('details.branch[data-lane="loose"]') };
+  `);
+  assert.strictEqual(out.lens, "all", "the lens is cleared to reach it");
+  assert.strictEqual(out.query, "");
+  assert.strictEqual(out.found, true);
 });

{transcript_viewer-0.11.0 → transcript_viewer-0.11.2}/uv.lock

@@ -388,7 +388,7 @@ wheels = [
 
 [[package]]
 name = "transcript-viewer"
-version = "0.11.0"
+version = "0.11.2"
 source = { editable = "." }
 dependencies = [
     { name = "atif-make" },