@khoavu882/doflow 2.0.0-beta.4 → 2.0.0

package/src/runtime/transcripts/read.js

@@ -0,0 +1,126 @@
+'use strict';
+
+/**
+ * `transcript --action read` (093 IC-022): one agent's recent events. The agent is resolved inside core from
+ * `buildTree`'s node set for the current project (a key outside it is `agent-not-in-project`); its transcript
+ * file is the one the tree joined by session id, and its header `cwd` must lie in one of the project's
+ * checkouts (`session-not-in-project`, R24). Text mode, so reply text and tool arguments come back masked and
+ * capped by the reader. Every agent also gets `record` events, DoFlow's own records of it (worker run start and
+ * end, attempt claim and end, hook records): they carry no text and make a panel non-blank whatever the reader
+ * status. A read with a cursor returns only the record events newer than the cursor's `recordAtMs`; without
+ * one (or after a reset) the 64 newest. Nothing is written; no path, pid or raw session id is printed.
+ *
+ * The cursor stays the reader's four parts. `recordSeq` also counts the record events returned, so `seq` is
+ * one running sequence. `recordAtMs` is raised to the newest record event returned, so one is not returned
+ * twice, except for Kiro, whose reader uses that field as its turn clock (raising it could skip a turn): a
+ * Kiro record event newer than the newest turn can come back again on the next read.
+ */
+
+const fs = require('node:fs');
+const path = require('node:path');
+const { buildTree, READERS } = require('../fleet/tree.js');
+const { listCheckouts } = require('../checkouts.js');
+const { loadTranscriptRegistry } = require('./registry.js');
+const { parseCursor, toMs, toIso } = require('./cursor.js');
+
+const RECORD_EVENTS = 64;
+const AGENT_KEY = /^[0-9a-f]{16}$/;
+
+/** True when `cwd` is a checkout or lies under one. An absent cwd cannot be checked and passes (the join was by session id). */
+function inCheckouts(cwd         , checkouts          , fsImpl      = fs)          {
+  if (cwd === null || cwd === undefined) return true;
+  if (typeof cwd !== 'string' || !path.isAbsolute(cwd)) return false;
+  let real = path.resolve(cwd);
+  try { real = fsImpl.realpathSync(real); } catch { /* a cwd that is gone is compared as written */ }
+  return checkouts.some((root) => {
+    let r = root;
+    try { r = fsImpl.realpathSync(root); } catch { /* as written */ }
+    return real === r || real.startsWith(r.endsWith(path.sep) ? r : r + path.sep);
+  });
+}
+
+/** The project's non-sandbox checkouts. */
+function checkoutRoots({ cwd, exec, fsImpl }     )           {
+  const listed = listCheckouts({ cwd, ...(exec ? { exec } : {}), ...(fsImpl ? { fsImpl } : {}) });
+  return listed.ok ? listed.entries.filter((e     ) => !e.sandbox).map((e     ) => e.path) : [];
+}
+
+/** What the registry says about a node's harness: the reader id and status the body prints. */
+function readerFor(registry                     , node     )                                        {
+  const entry = node.harness ? registry[node.harness] : null;
+  if (!entry) return { id: null, status: 'events-only' };
+  if (node.transcript.reason === 'no-reader' || node.transcript.reason === 'not-linked') return { id: null, status: 'events-only' };
+  return { id: entry.reader, status: entry.status };
+}
+
+function registryById()                      {
+  const loaded = loadTranscriptRegistry();
+  const out                      = {};
+  for (const entry of loaded.ok ? loaded.registry.entries : []) out[entry.harness] = entry;
+  return out;
+}
+
+/** The record events of `records` newer than `sinceMs` (all when null), at most 64 newest, oldest first. */
+function recordEvents(records       , node     , sinceMs               , firstSeq        )        {
+  const timed = records.map((r) => ({ r, ms: toMs(r.at) })).filter((x) => Number.isFinite(x.ms) && (sinceMs === null || x.ms > sinceMs));
+  timed.sort((a, b) => a.ms - b.ms || (a.r.type < b.r.type ? -1 : 1));
+  return timed.slice(-RECORD_EVENTS).map(({ r }, i) => ({
+    seq: firstSeq + i, at: toIso(r.at), kind: 'record', agentKey: node.agentKey, model: null, tool: null, text: null, args: null, cut: false, tokens: null,
+    record: { type: r.type, task: r.task ?? null, result: r.result ?? null },
+  }));
+}
+
+function readAgent({
+  env = process.env, cwd = process.cwd(), agent, cursor, limit, exec, alive, fsImpl = fs, platform, home, now,
+}      = {})      {
+  const built = buildTree({ env, cwd, ...(exec ? { exec } : {}), ...(alive ? { alive } : {}), ...(fsImpl !== fs ? { fsImpl } : {}), ...(platform ? { platform } : {}), ...(home ? { home } : {}), ...(now ? { now } : {}) });
+  if (!built.ok) return { ok: false, error: built.error };
+  const node = AGENT_KEY.test(agent ?? '') ? built.body.nodes.find((n     ) => n.agentKey === agent) : undefined;
+  if (!node) return { ok: false, error: 'agent-not-in-project' };
+  const internal = built.internal.get(node.agentKey) ?? {};
+  const registry = registryById();
+  const reader = readerFor(registry, node);
+  let transcript = { linked: node.transcript.linked, reason: node.transcript.reason };
+  let result      = null;
+
+  if (node.transcript.linked && internal.file) {
+    const mod = READERS[registry[node.harness].reader]();
+    const header = mod.header({ file: internal.file, companion: internal.companion });
+    if (!inCheckouts(header.cwd, checkoutRoots({ cwd, exec, fsImpl }), fsImpl)) return { ok: false, error: 'session-not-in-project' };
+    try {
+      result = mod.read({ file: internal.file, companion: internal.companion, mode: 'text', cursor, limit, agentKey: node.agentKey });
+    } catch (error     ) {
+      if (!error || (error.code !== 'ENOENT' && error.code !== 'ENOTDIR' && error.code !== 'EACCES')) throw error;
+      transcript = { linked: false, reason: 'not-found' }; // the file went away between the tree and the read
+    }
+  }
+
+  const parsed = parseCursor(cursor);
+  const fresh = parsed === null || (result !== null && result.reset);
+  const readerEvents = result ? result.events : [];
+  const firstSeq = result ? parseCursor(result.cursor).seq : parsed ? parsed.seq : 0;
+  const recs = recordEvents(internal.records ?? [], node, fresh ? null : parsed.atMs, firstSeq);
+  const newest = recs.length ? Math.max(...recs.map((e     ) => toMs(e.at))) : null;
+
+  let nextCursor        ;
+  if (result) {
+    const c = parseCursor(result.cursor);
+    const raise = registry[node.harness].reader !== 'kiro-jsonl' && newest !== null ? Math.max(c.atMs, newest) : c.atMs;
+    nextCursor = `${c.ino}:${c.offset}:${c.seq + recs.length}:${raise}`;
+  } else {
+    const prior = parsed ? parsed.atMs : 0;
+    nextCursor = `0:0:${firstSeq + recs.length}:${Math.max(prior, newest ?? 0)}`;
+  }
+
+  return {
+    ok: true,
+    body: {
+      v: 1, agentKey: node.agentKey, harness: node.harness, reader, transcript,
+      events: [...readerEvents, ...recs], cursor: nextCursor, reset: result ? result.reset : false, eof: result ? result.eof : true,
+      otherRecords: result ? result.otherRecords : 0, unparsable: result ? result.unparsable : 0, masked: result ? result.masked : 0,
+      warnings: result ? result.warnings : [],
+    },
+  };
+}
+
+module.exports = { readAgent, inCheckouts, checkoutRoots, registryById, AGENT_KEY };

package/src/runtime/transcripts/readers/claude-jsonl.js

@@ -0,0 +1,74 @@
+'use strict';
+
+/**
+ * 093 V.4 (IC-022): Claude Code reader. `~/.claude/projects/<cwd>/<sessionId>.jsonl`, and a sub-agent's
+ * `<sessionId>/subagents/agent-<id>.jsonl` with its `.meta.json` (R§3). Whitelist: `assistant` records
+ * (`message.content[]` `text` and `tool_use`, `message.usage`), `user` records' `tool_result` blocks.
+ * Thinking, user prompts, attachments, system and every other type are counted, never read. Usage is
+ * deduplicated by `message.id` (the same usage repeats on every line of one message).
+ */
+
+const { readTranscript, headRecords, readJsonFile, label, sizeOf, tokens } = require('../cursor.js');
+
+const REQUIRED_KEYS = ['type', 'timestamp', 'sessionId'];
+
+function blocksOf(content     )        {
+  if (typeof content === 'string') return [{ type: 'text', text: content }];
+  return Array.isArray(content) ? content : [];
+}
+
+const SPEC = {
+  id: 'claude-jsonl',
+  requiredKeys: REQUIRED_KEYS,
+  init: () => ({ seen: new Set        () }),
+  parse(rec     , ctx     )                                   {
+    const events        = [];
+    let other = 0;
+    const msg = rec.message && typeof rec.message === 'object' ? rec.message : null;
+    if (rec.type === 'assistant' && msg) {
+      for (const b of blocksOf(msg.content)) {
+        if (b && b.type === 'text' && typeof b.text === 'string') events.push(ctx.event('reply', rec.timestamp, { model: msg.model, text: b.text }));
+        else if (b && b.type === 'tool_use') {
+          ctx.noteCall(b.id, rec.timestamp, b.name);
+          events.push(ctx.event('tool-call', rec.timestamp, { model: msg.model, tool: ctx.tool(b.name, b.id), args: b.input }));
+        } else other += 1; // thinking and anything else
+      }
+      const first = typeof msg.id !== 'string' || !ctx.state.seen.has(msg.id);
+      if (msg.usage && typeof msg.usage === 'object' && first) {
+        if (typeof msg.id === 'string') ctx.state.seen.add(msg.id);
+        const t = tokens({
+          input: msg.usage.input_tokens, output: msg.usage.output_tokens,
+          cacheRead: msg.usage.cache_read_input_tokens, cacheWrite: msg.usage.cache_creation_input_tokens,
+        });
+        if (t) events.push(ctx.event('usage', rec.timestamp, { model: msg.model, tokens: t }));
+      }
+    } else if (rec.type === 'user' && msg) {
+      for (const b of blocksOf(msg.content)) {
+        if (b && b.type === 'tool_result') {
+          const call = ctx.callOf(b.tool_use_id);
+          events.push(ctx.event('tool-result', rec.timestamp, {
+            tool: ctx.tool(call && call.name, b.tool_use_id, {
+              status: b.is_error === true ? 'error' : b.is_error === false ? 'ok' : null,
+              bytes: sizeOf(b.content), durationMs: ctx.durationOf(b.tool_use_id, rec.timestamp),
+            }),
+          }));
+        } else other += 1; // the user's own text
+      }
+    } else other = 1;
+    return { events, other };
+  },
+};
+
+/** Header facts of a main or sub-agent file; `sessionId` and `cwd` are for core only, never printed. */
+function header({ file, metaFile }                                     )      {
+  const first = headRecords(file).find((r     ) => typeof r.sessionId === 'string') || {};
+  const meta = readJsonFile(metaFile ?? file.replace(/\.jsonl$/, '.meta.json')) || {};
+  return {
+    sessionId: first.sessionId ?? null, agentId: typeof first.agentId === 'string' ? first.agentId : null,
+    cwd: typeof first.cwd === 'string' ? first.cwd : null, parentSessionId: null,
+    label: label(meta.agentType), depth: Number.isInteger(meta.spawnDepth) ? meta.spawnDepth : null, model: label(meta.model),
+    children: [],
+  };
+}
+
+module.exports = { id: 'claude-jsonl', REQUIRED_KEYS, read: (opts     ) => readTranscript(SPEC, opts), header };

package/src/runtime/transcripts/readers/codex-rollout.js

@@ -0,0 +1,70 @@
+'use strict';
+
+/**
+ * 093 V.4 (IC-022): Codex reader. `$CODEX_HOME/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl`, lines
+ * `{timestamp, type, payload}` (R§3). Whitelist: `turn_context` (model), `response_item` assistant
+ * `message`, `function_call`, `custom_tool_call` and their outputs, `event_msg` `token_count` (per-call
+ * `last_token_usage`) and `agent_message`. Reasoning, user and developer messages, `session_meta` and every
+ * other type are counted, never read. Codex writes a reply as both a message item and an `agent_message`;
+ * an identical reply straight after another is skipped.
+ */
+
+const { readTranscript, headRecords, label, sizeOf, tokens } = require('../cursor.js');
+
+const REQUIRED_KEYS = ['timestamp', 'type', 'payload'];
+
+const SPEC = {
+  id: 'codex-rollout',
+  requiredKeys: REQUIRED_KEYS,
+  init: () => ({ model: null, lastReply: null }),
+  parse(rec     , ctx     )                                   {
+    const events        = [];
+    let other = 0;
+    const p = rec.payload && typeof rec.payload === 'object' ? rec.payload : {};
+    const reply = (text     ) => {
+      if (typeof text !== 'string' || text === ctx.state.lastReply) { other += 1; return; }
+      ctx.state.lastReply = text;
+      events.push(ctx.event('reply', rec.timestamp, { text }));
+    };
+    if (rec.type === 'turn_context' && typeof p.model === 'string') {
+      ctx.state.model = p.model;
+      events.push(ctx.event('model-change', rec.timestamp, { model: p.model }));
+    } else if (rec.type === 'response_item' && p.type === 'message' && p.role === 'assistant') {
+      for (const c of Array.isArray(p.content) ? p.content : []) {
+        if (c && c.type === 'output_text') reply(c.text);
+        else other += 1;
+      }
+    } else if (rec.type === 'response_item' && (p.type === 'function_call' || p.type === 'custom_tool_call')) {
+      ctx.noteCall(p.call_id, rec.timestamp, p.name);
+      events.push(ctx.event('tool-call', rec.timestamp, { tool: ctx.tool(p.name, p.call_id), args: p.type === 'function_call' ? p.arguments : p.input }));
+    } else if (rec.type === 'response_item' && (p.type === 'function_call_output' || p.type === 'custom_tool_call_output')) {
+      const call = ctx.callOf(p.call_id);
+      events.push(ctx.event('tool-result', rec.timestamp, {
+        tool: ctx.tool(call && call.name, p.call_id, { bytes: sizeOf(p.output), durationMs: ctx.durationOf(p.call_id, rec.timestamp) }),
+      }));
+    } else if (rec.type === 'event_msg' && p.type === 'token_count' && p.info && p.info.last_token_usage) {
+      const u = p.info.last_token_usage;
+      const t = tokens({ input: u.input_tokens, output: u.output_tokens, cacheRead: u.cached_input_tokens, cacheWrite: u.cache_write_input_tokens, reasoning: u.reasoning_output_tokens });
+      if (t) events.push(ctx.event('usage', rec.timestamp, { tokens: t }));
+      else other = 1;
+    } else if (rec.type === 'event_msg' && p.type === 'agent_message') reply(p.message);
+    else other = 1;
+    if (events.length === 0 && other === 0) other = 1;
+    return { events, other };
+  },
+};
+
+/** Header facts from `session_meta`; `sessionId` and `cwd` are for core only. A sub-agent's `source` names its parent thread. */
+function header({ file }                  )      {
+  const meta = headRecords(file).find((r     ) => r.type === 'session_meta');
+  const p = (meta && meta.payload) || {};
+  const spawn = (p.source && p.source.SubAgent && p.source.SubAgent.ThreadSpawn) || null;
+  return {
+    sessionId: typeof p.id === 'string' ? p.id : null, agentId: null, cwd: typeof p.cwd === 'string' ? p.cwd : null,
+    parentSessionId: spawn && typeof spawn.parent_thread_id === 'string' ? spawn.parent_thread_id : null,
+    label: spawn ? label(spawn.agent_role) : null, depth: spawn && Number.isInteger(spawn.depth) ? spawn.depth : null, model: null,
+    children: [],
+  };
+}
+
+module.exports = { id: 'codex-rollout', REQUIRED_KEYS, read: (opts     ) => readTranscript(SPEC, opts), header };

package/src/runtime/transcripts/readers/copilot-events.js

@@ -0,0 +1,90 @@
+'use strict';
+
+/**
+ * 093 V.4 (IC-022): GitHub Copilot CLI reader. `~/.copilot/session-state/<sessionId>/events.jsonl`, envelope
+ * `{id, parentId, timestamp, type, agentId, data}` (R§3). Whitelist: `assistant.message`,
+ * `tool.execution_start`, `tool.execution_complete`, `subagent.started` and the usage records. Usage is
+ * cumulative per model, so each record is differenced against the previous one; the first record of a window
+ * is differenced against the last usage record before the window (a negative step means the counter restarted
+ * and the value itself is the step). Reasoning, encrypted content, user messages and every other type are
+ * counted, never read.
+ */
+
+const { readTranscript, headRecords, label, sizeOf, tokens } = require('../cursor.js');
+
+const REQUIRED_KEYS = ['id', 'timestamp', 'type', 'data'];
+const USAGE_TYPES = new Set(['session.usage_record', 'session.usage_checkpoint', 'session.shutdown']);
+const FIELDS                          = [
+  ['input', 'inputTokens'], ['output', 'outputTokens'], ['cacheRead', 'cacheReadTokens'], ['cacheWrite', 'cacheWriteTokens'], ['reasoning', 'reasoningTokens'],
+];
+
+/** model -> cumulative `usage` object of one usage record. */
+function metricsOf(rec     )                       {
+  const mm = rec && rec.data && rec.data.modelMetrics;
+  if (!mm || typeof mm !== 'object') return [];
+  return Object.entries(mm).filter(([, v]     ) => v && typeof v.usage === 'object' && v.usage !== null).map(([k, v]     ) => [k, v.usage]);
+}
+
+const SPEC = {
+  id: 'copilot-events',
+  requiredKeys: REQUIRED_KEYS,
+  init: (win     ) => {
+    const base = new Map             ();
+    for (const text of win.prior()) {
+      try {
+        const rec = JSON.parse(text);
+        if (rec && USAGE_TYPES.has(rec.type)) for (const [model, usage] of metricsOf(rec)) base.set(model, usage);
+      } catch { /* torn line */ }
+    }
+    return { base, model: null };
+  },
+  parse(rec     , ctx     )                                   {
+    const events        = [];
+    const d = rec.data && typeof rec.data === 'object' ? rec.data : {};
+    let other = 0;
+    if (rec.type === 'assistant.message' && typeof d.content === 'string') {
+      events.push(ctx.event('reply', rec.timestamp, { model: d.model, text: d.content }));
+    } else if (rec.type === 'tool.execution_start') {
+      ctx.noteCall(d.toolCallId, rec.timestamp, d.toolName);
+      events.push(ctx.event('tool-call', rec.timestamp, { model: d.model, tool: ctx.tool(d.toolName, d.toolCallId), args: d.arguments }));
+    } else if (rec.type === 'tool.execution_complete') {
+      const call = ctx.callOf(d.toolCallId);
+      events.push(ctx.event('tool-result', rec.timestamp, {
+        model: d.model,
+        tool: ctx.tool(call && call.name, d.toolCallId, {
+          status: d.success === true ? 'ok' : d.success === false ? 'error' : null, bytes: sizeOf(d.result && d.result.content),
+          durationMs: ctx.durationOf(d.toolCallId, rec.timestamp),
+        }),
+      }));
+    } else if (rec.type === 'subagent.started') {
+      events.push(ctx.event('subagent-start', rec.timestamp, { model: d.model }));
+    } else if (USAGE_TYPES.has(rec.type)) {
+      for (const [model, cur] of metricsOf(rec)) {
+        const prev = ctx.state.base.get(model) || {};
+        const step = (key        ) => (Number.isFinite(cur[key]) ? cur[key] - (Number.isFinite(prev[key]) ? prev[key] : 0) : null);
+        const restarted = FIELDS.some(([, key]) => (step(key) ?? 0) < 0);
+        const t = tokens(Object.fromEntries(FIELDS.map(([name, key]) => [name, restarted ? cur[key] : step(key)])));
+        ctx.state.base.set(model, cur);
+        if (t && Object.values(t).some((v) => v)) events.push(ctx.event('usage', rec.timestamp, { model, tokens: t }));
+      }
+      return { events, other: 0 };
+    } else other = 1;
+    if (events.length === 0 && other === 0) other = 1;
+    return { events, other };
+  },
+};
+
+/** Header facts: `session.start` ids and the sub-agents this session started (`agentId` and its `agentName`). */
+function header({ file }                  )      {
+  const records = headRecords(file, 2000, 256 * 1024);
+  const start = records.find((r     ) => r.type === 'session.start');
+  const d = (start && start.data) || {};
+  return {
+    sessionId: typeof d.sessionId === 'string' ? d.sessionId : null, agentId: null,
+    cwd: d.context && typeof d.context.cwd === 'string' ? d.context.cwd : null, parentSessionId: null, label: null, depth: null, model: null,
+    children: records.filter((r     ) => r.type === 'subagent.started' && typeof r.agentId === 'string')
+      .map((r     ) => ({ agentId: r.agentId, label: label(r.data && r.data.agentName), depth: null })),
+  };
+}
+
+module.exports = { id: 'copilot-events', REQUIRED_KEYS, read: (opts     ) => readTranscript(SPEC, opts), header };

package/src/runtime/transcripts/readers/kiro-jsonl.js

@@ -0,0 +1,77 @@
+'use strict';
+
+/**
+ * 093 V.4 (IC-022): Kiro reader. `~/.kiro/sessions/cli/<uuid>.jsonl` (`{version, kind, data}`) with its
+ * companion `<uuid>.json` (R§3). Whitelist: `AssistantMessage` (`text`, `toolUse`) and `ToolResults`.
+ * Thinking, prompts, context, `Clear` and every other kind are counted, never read. The JSONL has no
+ * timestamp per record, so every event has `at: null`; per-turn tokens come from the companion's
+ * `user_turn_metadatas[]` as `usage` events (the cursor's `recordAtMs` is the newest turn `end_timestamp`
+ * already returned, so a turn is returned once).
+ */
+
+const { readTranscript, readJsonFile, label, toMs, sizeOf, tokens } = require('../cursor.js');
+
+const REQUIRED_KEYS = ['version', 'kind', 'data'];
+const TAIL_TURNS = 64;
+
+function blocks(data     )        {
+  return Array.isArray(data && data.content) ? data.content.filter((b     ) => b && typeof b === 'object' && b.data && typeof b.data === 'object') : [];
+}
+
+const SPEC = {
+  id: 'kiro-jsonl',
+  requiredKeys: REQUIRED_KEYS,
+  at: () => NaN, // no per-record time
+  init: () => ({ model: null }),
+  parse(rec     , ctx     )                                   {
+    const events        = [];
+    let other = 0;
+    if (rec.kind === 'AssistantMessage') {
+      for (const b of blocks(rec.data)) {
+        if (typeof b.data.modelId === 'string' && b.kind !== 'thinking') ctx.state.model = b.data.modelId;
+        if (b.kind === 'text' && typeof b.data.text === 'string') events.push(ctx.event('reply', null, { text: b.data.text }));
+        else if (b.kind === 'toolUse') {
+          ctx.noteCall(b.data.toolUseId, null, b.data.name);
+          events.push(ctx.event('tool-call', null, { tool: ctx.tool(b.data.name, b.data.toolUseId), args: b.data.input }));
+        } else other += 1; // thinking
+      }
+    } else if (rec.kind === 'ToolResults') {
+      for (const b of blocks(rec.data)) {
+        if (b.kind !== 'toolResult') { other += 1; continue; }
+        const call = ctx.callOf(b.data.toolUseId);
+        const status = b.data.status === 'success' ? 'ok' : typeof b.data.status === 'string' ? 'error' : null;
+        events.push(ctx.event('tool-result', null, { tool: ctx.tool(call && call.name, b.data.toolUseId, { status, bytes: sizeOf(b.data.content) }) }));
+      }
+    } else other = 1;
+    if (events.length === 0 && other === 0) other = 1;
+    return { events, other };
+  },
+  /** Per-turn usage from the companion `.json`, after the JSONL events. */
+  extra(ctx     , win     , opts     , room        )                                                 {
+    const j = readJsonFile(opts.companion ?? opts.file.replace(/\.jsonl$/, '.json'));
+    const turns = ((j && Array.isArray(j.user_turn_metadatas)) ? j.user_turn_metadatas : [])
+      .filter((t     ) => t && typeof t === 'object')
+      .map((t     ) => ({ t, ms: toMs(t.end_timestamp) }));
+    const fresh = win.tail ? turns.slice(-TAIL_TURNS) : turns.filter((x     ) => !(x.ms <= win.cursor.atMs));
+    const take = fresh.slice(0, Math.max(0, room));
+    const events = take.map(({ t }     ) => ctx.event('usage', null, {
+      model: t.model ?? (j.rts_model_state && j.rts_model_state.model_info && j.rts_model_state.model_info.model_id),
+      tokens: tokens({ input: t.input_token_count, output: t.output_token_count, cacheRead: t.cache_read_token_count, cacheWrite: t.cache_write_token_count }),
+    })).filter((e     ) => e.tokens !== null);
+    const newest = take.map((x     ) => x.ms).filter(Number.isFinite);
+    return { events, atMs: newest.length ? Math.max(...newest) : NaN, more: take.length < fresh.length };
+  },
+};
+
+/** Header facts from the companion `.json`; `sessionId`, `cwd` and `parentSessionId` are for core only. */
+function header({ file, companion }                                      )      {
+  const j = readJsonFile(companion ?? file.replace(/\.jsonl$/, '.json')) || {};
+  const model = j.rts_model_state && j.rts_model_state.model_info && j.rts_model_state.model_info.model_id;
+  return {
+    sessionId: typeof j.session_id === 'string' ? j.session_id : null, agentId: null, cwd: typeof j.cwd === 'string' ? j.cwd : null,
+    parentSessionId: typeof j.parent_session_id === 'string' ? j.parent_session_id : null,
+    label: null, depth: null, model: label(model), children: [],
+  };
+}
+
+module.exports = { id: 'kiro-jsonl', REQUIRED_KEYS, read: (opts     ) => readTranscript(SPEC, opts), header };

package/src/runtime/transcripts/readers/pi-jsonl.js

@@ -0,0 +1,59 @@
+'use strict';
+
+/**
+ * 093 V.4 (IC-022): Pi reader. `~/.pi/agent/sessions/--<cwd>--/<ts>_<uuid>.jsonl`, session format v3 (R§3).
+ * Whitelist: `model_change`, `message` with role `assistant` (`text`, `toolCall`, `usage`) and `toolResult`.
+ * Thinking, user messages, the session header, custom messages and every other type are counted, never read.
+ */
+
+const { readTranscript, headRecords, label, sizeOf, tokens } = require('../cursor.js');
+
+const REQUIRED_KEYS = ['type', 'timestamp'];
+
+const SPEC = {
+  id: 'pi-jsonl',
+  requiredKeys: REQUIRED_KEYS,
+  init: () => ({ model: null }),
+  parse(rec     , ctx     )                                   {
+    const events        = [];
+    let other = 0;
+    const m = rec.message && typeof rec.message === 'object' ? rec.message : null;
+    if (rec.type === 'model_change' && typeof rec.modelId === 'string') {
+      ctx.state.model = rec.modelId;
+      events.push(ctx.event('model-change', rec.timestamp, { model: rec.modelId }));
+    } else if (rec.type === 'message' && m && m.role === 'assistant') {
+      for (const b of Array.isArray(m.content) ? m.content : []) {
+        if (b && b.type === 'text' && typeof b.text === 'string') events.push(ctx.event('reply', rec.timestamp, { model: m.model, text: b.text }));
+        else if (b && b.type === 'toolCall') {
+          ctx.noteCall(b.id, rec.timestamp, b.name);
+          events.push(ctx.event('tool-call', rec.timestamp, { model: m.model, tool: ctx.tool(b.name, b.id), args: b.arguments }));
+        } else other += 1; // thinking
+      }
+      const u = m.usage && typeof m.usage === 'object' ? m.usage : null;
+      const t = u && tokens({ input: u.input, output: u.output, cacheRead: u.cacheRead, cacheWrite: u.cacheWrite, reasoning: u.reasoning });
+      if (t) events.push(ctx.event('usage', rec.timestamp, { model: m.model, tokens: t }));
+    } else if (rec.type === 'message' && m && m.role === 'toolResult') {
+      events.push(ctx.event('tool-result', rec.timestamp, {
+        tool: ctx.tool(m.toolName, m.toolCallId, {
+          status: m.isError === true ? 'error' : m.isError === false ? 'ok' : null, bytes: sizeOf(m.content),
+          durationMs: Number.isFinite(m.durationMs) ? m.durationMs : null,
+        }),
+      }));
+    } else other = 1;
+    if (events.length === 0 && other === 0) other = 1;
+    return { events, other };
+  },
+};
+
+/** Header facts from the `session` record; `sessionId`, `cwd` and the parent id are for core only. */
+function header({ file }                  )      {
+  const h = headRecords(file, 1)[0] || {};
+  const parent = typeof h.parentSession === 'string' ? /_([0-9a-f-]{36})\.jsonl$/.exec(h.parentSession) : null;
+  return {
+    sessionId: h.type === 'session' && typeof h.id === 'string' ? h.id : null, agentId: null,
+    cwd: typeof h.cwd === 'string' ? h.cwd : null, parentSessionId: parent ? parent[1] : null,
+    label: label(null), depth: null, model: null, children: [],
+  };
+}
+
+module.exports = { id: 'pi-jsonl', REQUIRED_KEYS, read: (opts     ) => readTranscript(SPEC, opts), header };