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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: transcript-viewer
-Version: 0.11.0
+Version: 0.11.1
 Summary: Browse agent transcripts in a local, dependency-free web viewer.
 License: MIT
 Requires-Python: >=3.12

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

@@ -1,6 +1,6 @@
 [project]
 name = "transcript-viewer"
-version = "0.11.0"
+version = "0.11.1"
 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.1}/src/transcript_viewer/page.html

@@ -420,6 +420,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 +2369,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 +2425,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 +2565,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.
@@ -2579,13 +2622,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: bandLayer + breaks,
+    overlaps: bands.length,
+  });
 }
 
 /* One row: who, how many steps, and the track it sits on. */
@@ -2602,14 +2656,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 +2698,7 @@ 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>` : ""}
+          ${overlaps ? `<span><i style="background:var(--hl)"></i>running at the same time</span>` : ""}
           <span class="lanes-note">${esc(note)}</span>
         </div>
       </div>
@@ -2681,6 +2756,25 @@ function openLane(id) {
   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 +2881,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 +3039,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.1}/tests/page.test.js

@@ -1840,10 +1840,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, /overlapped once/, "one overlap reads as once, not '1 times'");
   assert.match(html, /class="band"/, "the overlap is drawn, not only counted");
 });
 
+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", () => {
   const html = run(`return drawLanes({steps:[{step_id:1,source:"user",message:"hi"}]})`);
   assert.strictEqual(html, "", "an empty chart says less than no chart");
@@ -1856,8 +1876,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 +1968,77 @@ 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"]);
 });

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

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