@gobing-ai/spur 0.4.8 → 0.4.9

package/plugins/sp/lib/run-summary-core.ts

@@ -1,225 +0,0 @@
-/**
- * run-summary core — the rendering and host IO behind the `run-summary` CLI (task 1146; task 1178 R2).
- *
- * Split out of `plugins/sp/scripts/run-summary.ts` when the actor split and the batch roll-up pushed
- * that script past the ADR-130 glue budget. The PURE aggregation and its types now live in
- * `packages/app/src/workflow/run-summary.ts`, reached through the generated pure plan-projection
- * entry; this module keeps only what belongs to the host: the close-step callback, the receipt read,
- * Markdown rendering and durable/scratch report writing. Node builtins plus relative imports only;
- * `import type` for the app projection it is handed.
- */
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
-import { join } from 'node:path';
-import type { WorkflowProgressProjection } from '@gobing-ai/spur-app';
-import { getEnvVars } from './env';
-import {
-    type ActorSplit,
-    buildRunSummary,
-    formatDuration,
-    formatTokenSplit,
-    type GateTime,
-    type Progress,
-    type RunSummary,
-    type SummaryRow,
-    sumTokens,
-    zeroTokens,
-} from './plan-projection.generated.mjs';
-import { parseRows, resolveTranscript } from './transcript';
-
-// Task 1178 R2: the pure aggregation moved to `packages/app/src/workflow/run-summary.ts`. Re-export
-// it from here so the adapter's existing surface (the `run-summary` script and its tests) keeps one
-// import path; the implementation is delegated, never duplicated.
-export {
-    type ActorSplit,
-    actorSplit,
-    buildRunSummary,
-    type GateTime,
-    type Progress,
-    type RunSummary,
-    type SummaryRow,
-} from './plan-projection.generated.mjs';
-
-export function renderSummaryMarkdown(summary: RunSummary): string {
-    const line = (r: SummaryRow, bold = false) => {
-        const stage = bold ? `**${r.stage}**` : r.stage;
-        return `| ${stage} | ${r.status} | ${r.time} | ${r.wait} | ${r.toolCalls ?? 'n/a'} | ${r.token} |`;
-    };
-    const a = summary.actors;
-    const window = summary.total.workMs + summary.total.waitMs;
-    const share = (ms: number): string => (window > 0 ? `${Math.round((ms / window) * 100)}%` : 'n/a');
-    const gate = summary.gate.ms === null ? `n/a (${summary.gate.reason})` : formatDuration(summary.gate.ms);
-    return [
-        '| Stage | Status | Time | Wait | Tool calls | Token (total / non-cached) |',
-        '| --- | --- | ---: | ---: | ---: | ---: |',
-        ...summary.rows.map((r) => line(r)),
-        line(summary.total, true),
-        '',
-        '| Actor | Time | Share |',
-        '| --- | ---: | ---: |',
-        `| operator wait (longest ${formatDuration(a.longestOperatorWaitMs)}) | ${formatDuration(a.operatorMs)} | ${share(a.operatorMs)} |`,
-        `| model | ${formatDuration(a.modelMs)} | ${share(a.modelMs)} |`,
-        `| shell | ${formatDuration(a.shellMs)} | ${share(a.shellMs)} |`,
-        `|   of which gate (informational) | ${gate} | — |`,
-        `| subagent | ${formatDuration(a.subagentMs)} | ${share(a.subagentMs)} |`,
-        `| other tools | ${formatDuration(a.otherToolMs)} | ${share(a.otherToolMs)} |`,
-        `| idle / unattributed | ${formatDuration(a.idleMs)} | ${share(a.idleMs)} |`,
-        '',
-        `Compactions: ${a.compactions} · Subagent errors: ${a.subagentErrors}`,
-    ].join('\n');
-}
-
-/** One `--rollup` input: a close-written `<runId>-summary.json` plus its label. */
-export interface RollupInput {
-    label: string;
-    summary: {
-        runId?: string;
-        startedAt?: string;
-        completedAt?: string;
-        total: SummaryRow;
-        actors: ActorSplit;
-    };
-}
-
-/** Batch roll-up (1146 R3/AC5): one row per run's OWN window, then the sum, then the wall span. */
-export function renderRollupMarkdown(rows: RollupInput[]): string {
-    const line = (label: string, r: SummaryRow, actors: ActorSplit, bold = false): string => {
-        const name = bold ? `**${label}**` : label;
-        return `| ${name} | ${r.status} | ${r.time} | ${r.wait} | ${r.toolCalls ?? 'n/a'} | ${r.token} | ${formatDuration(actors.operatorMs)} | ${formatDuration(actors.subagentMs)} |`;
-    };
-    const total = rows.reduce(
-        (acc, { summary }) => ({
-            workMs: acc.workMs + summary.total.workMs,
-            waitMs: acc.waitMs + summary.total.waitMs,
-            toolCalls: (acc.toolCalls ?? 0) + (summary.total.toolCalls ?? 0),
-            tokens: sumTokens([acc.tokens, summary.total.tokens ?? zeroTokens()]),
-        }),
-        { workMs: 0, waitMs: 0, toolCalls: 0 as number | null, tokens: zeroTokens() },
-    );
-    const totalRow: SummaryRow = {
-        stage: 'Batch total',
-        status: '',
-        workMs: total.workMs,
-        waitMs: total.waitMs,
-        toolCalls: total.toolCalls,
-        tokens: total.tokens,
-        time: formatDuration(total.workMs),
-        wait: formatDuration(total.waitMs),
-        token: formatTokenSplit(total.tokens),
-    };
-    const totalActors: ActorSplit = {
-        operatorMs: 0,
-        longestOperatorWaitMs: 0,
-        modelMs: 0,
-        shellMs: 0,
-        subagentMs: 0,
-        otherToolMs: 0,
-        idleMs: 0,
-        compactions: 0,
-        subagentErrors: 0,
-    };
-    for (const { summary } of rows) {
-        totalActors.operatorMs += summary.actors.operatorMs;
-        totalActors.subagentMs += summary.actors.subagentMs;
-        totalActors.compactions += summary.actors.compactions;
-        totalActors.subagentErrors += summary.actors.subagentErrors;
-    }
-    const out = [
-        '| Run | Status | Time | Wait | Tool calls | Token (total / non-cached) | Operator wait | Subagent |',
-        '| --- | --- | ---: | ---: | ---: | ---: | ---: | ---: |',
-        ...rows.map(({ label, summary }) => line(label, summary.total, summary.actors)),
-        line('Batch total', totalRow, totalActors, true),
-    ];
-    const starts = rows.map((r) => Date.parse(r.summary.startedAt ?? '')).filter((n) => !Number.isNaN(n));
-    const ends = rows.map((r) => Date.parse(r.summary.completedAt ?? '')).filter((n) => !Number.isNaN(n));
-    const overlaps =
-        starts.length === rows.length &&
-        rows.some((r, i) =>
-            rows.some(
-                (o, j) =>
-                    i !== j &&
-                    Date.parse(r.summary.startedAt ?? '') < Date.parse(o.summary.completedAt ?? '') &&
-                    Date.parse(o.summary.startedAt ?? '') < Date.parse(r.summary.completedAt ?? ''),
-            ),
-        );
-    if (overlaps && starts.length > 0 && ends.length > 0) {
-        out.push(
-            '',
-            `Wall span: ${new Date(Math.min(...starts)).toISOString()} → ${new Date(Math.max(...ends)).toISOString()}`,
-        );
-    }
-    return out.join('\n');
-}
-
-/** 1146 R1: the close-step summarizer's input — a structural copy of the app's interface. */
-export interface CloseSummaryRun {
-    readonly runId: string;
-    readonly startedAt: string | undefined;
-    readonly completedAt: string;
-    /** The app's full projection; the summary reads only the subset above. */
-    readonly progress: WorkflowProgressProjection;
-}
-
-/**
- * 1146 R1: write `.spur/run/<runId>-summary.{md,json}` and return the `.md` path (relative to cwd).
- * Never throws: any failure (unresolved transcript, no timed attempts, anything else) leaves the
- * `.md` holding exactly `Execution summary: n/a (<reason>)` and returns its path, so the close's
- * exit code and JSON verdict are untouched.
- */
-export function writeCloseSummary(
-    run: CloseSummaryRun,
-    opts: { env?: Record<string, string | undefined>; projectsRoot?: string; cwd?: string } = {},
-): string {
-    const cwd = opts.cwd ?? process.cwd();
-    const runDir = join(cwd, '.spur', 'run');
-    const rel = join('.spur', 'run', `${run.runId}-summary.md`);
-    const abs = join(cwd, rel);
-    const na = (reason: string): string => {
-        mkdirSync(runDir, { recursive: true });
-        writeFileSync(abs, `Execution summary: n/a (${reason})\n`);
-        return rel;
-    };
-    try {
-        if (run.startedAt === undefined) return na('run row has no started_at');
-        const resolved = resolveTranscript(opts.env ?? getEnvVars(), opts.projectsRoot);
-        if (!resolved.ok) return na(resolved.reason);
-        const { rows, skippedLines } = parseRows(readFileSync(resolved.path, 'utf8').split('\n'));
-        const summary = buildRunSummary(rows, [{ progress: run.progress as unknown as Progress }], {
-            since: run.startedAt,
-            until: run.completedAt,
-            skippedLines,
-        });
-        if (summary.rows.length === 0) return na('no timed attempts');
-        mkdirSync(runDir, { recursive: true });
-        writeFileSync(abs, `${renderSummaryMarkdown(summary)}\n`);
-        writeFileSync(
-            join(runDir, `${run.runId}-summary.json`),
-            JSON.stringify(
-                { ...summary, runId: run.runId, startedAt: run.startedAt, completedAt: run.completedAt },
-                null,
-                2,
-            ),
-        );
-        return rel;
-    } catch (error) {
-        return na(error instanceof Error ? error.message : String(error));
-    }
-}
-
-/**
- * 1146 R4: gate time comes only from THIS run's check receipt (`receipt.runId === runId`); a
- * receipt belonging to another run is a cross-run scratch read (ADR-131) and renders n/a.
- */
-export function gateFromReceipt(cwd: string, runId: string): GateTime {
-    const path = join(cwd, '.spur', 'run', `${runId}-check-receipt.json`);
-    if (!existsSync(path)) return { ms: null, reason: 'no matching check receipt' };
-    try {
-        const parsed = JSON.parse(readFileSync(path, 'utf8')) as { runId?: unknown; gateRuntimeMs?: unknown };
-        if (parsed.runId !== runId) return { ms: null, reason: 'check receipt belongs to another run' };
-        const ms = parsed.gateRuntimeMs;
-        if (typeof ms !== 'number' || !Number.isFinite(ms))
-            return { ms: null, reason: 'check receipt has no gate time' };
-        return { ms };
-    } catch {
-        return { ms: null, reason: 'check receipt is unreadable' };
-    }
-}

package/plugins/sp/lib/spur-bin.ts

@@ -1,36 +0,0 @@
-/**
- * Shared spur-invocation helper for the sp plugin scripts (task 1007 R9, RF-architect-001).
- *
- * `spurCommand` and `defaultSpurBin` moved verbatim from `wrapup-steps.ts` and
- * `workflow-step-profile.ts` so every surviving plugin script imports one copy (imported by
- * relative path like `lib/env.ts`, so the standalone contract holds; not an app bundle
- * because it carries no Spur-domain logic). Node/bun builtins and the vendored `./env`
- * gateway only — bundled standalone by `superskill install`, so no `@gobing-ai/*` value
- * imports (task 0669).
- */
-
-import { existsSync } from 'node:fs';
-import { fileURLToPath } from 'node:url';
-import { getEnvVar } from './env';
-
-/** `spurBin` splits on whitespace into a command plus prefix args (so `bun x.ts` works). */
-export function spurCommand(spurBin: string | undefined): { cmd: string; prefix: string[] } {
-    const parts = (spurBin ?? 'spur')
-        .trim()
-        .split(/\s+/)
-        .filter((p) => p.length > 0);
-    return { cmd: parts[0] ?? 'spur', prefix: parts.slice(1) };
-}
-
-/**
- * Resolve the spur CLI monorepo-safely (twin-safe resolution:
- * self-contained and no plugin script imports another):
- * --spur-bin > SPUR_BIN > monorepo-local CLI entry > PATH `spur`.
- */
-export function defaultSpurBin(): string {
-    const fromEnv = getEnvVar('SPUR_BIN');
-    if (fromEnv) return fromEnv;
-    const local = fileURLToPath(new URL('../../../apps/cli/src/index.ts', import.meta.url));
-    if (existsSync(local)) return `bun ${local}`;
-    return 'spur';
-}

package/plugins/sp/lib/step-profile.generated.d.mts

@@ -1,71 +0,0 @@
-/**
- * GENERATED by scripts/commands/bundle-plugin-lib.ts — do not edit.
- * Source of truth: packages/app/src/workflow/step-profile.ts (task 1005 R1).
- */
-export declare interface ActionCostLike {
-    cacheHit: number | null;
-}
-export declare interface ActionCostAttributionLike {
-    exact: ActionCostLike | null;
-    estimated: ActionCostLike | null;
-}
-export declare interface TraceActionEvent {
-    kind: string;
-    node?: string;
-    actionKind?: string;
-    durationMs?: number | null;
-    startedAt?: string | null;
-    completedAt?: string | null;
-    invocation?: Record<string, string | number | boolean> | null;
-    cost?: ActionCostAttributionLike | null;
-}
-export declare interface StepProfileRun {
-    runId: string;
-    events: readonly TraceActionEvent[];
-}
-export declare interface TraceRunEntry {
-    runId: string;
-    isDryRun?: boolean;
-    status?: string;
-    workflowName?: string;
-}
-export declare type SessionMode = 'fresh' | 'resumed' | 'mixed';
-export declare interface StepProfileExecution {
-    runId: string;
-    node: string;
-    actionKind: string;
-    durationMs: number | null;
-    idleGapMs: number | null;
-    session: 'fresh' | 'resumed' | null;
-    cacheHit: number | null;
-}
-export declare interface StepProfileRow {
-    node: string;
-    actionKind: string;
-    runs: number;
-    executions: number;
-    durationMs: { p50: number | null; max: number | null };
-    idleGapMs: { p50: number | null };
-    session: SessionMode | null;
-    cacheHit: { p50: number | null; known: number; of: number };
-    flags: string[];
-}
-export declare interface StepProfile {
-    workflow: string;
-    windowSec: number;
-    sampledRuns: number;
-    rows: StepProfileRow[];
-}
-export declare const DEFAULT_LAST: number;
-export declare const DEFAULT_WINDOW_SEC: number;
-export declare function nearestRankP50(values: readonly number[]): number | null;
-export declare function extractExecutions(runId: string, events: readonly TraceActionEvent[]): StepProfileExecution[];
-export declare function rowFlags(row: StepProfileRow, windowSec: number): string[];
-export declare function buildRows(executions: readonly StepProfileExecution[], windowSec: number): StepProfileRow[];
-export declare function buildStepProfile(input: {
-    workflow: string;
-    windowSec: number;
-    runs: readonly StepProfileRun[];
-}): StepProfile;
-export declare function nonDryRuns(entries: readonly TraceRunEntry[]): TraceRunEntry[];
-export declare function formatStepProfileHuman(profile: StepProfile): string;

package/plugins/sp/lib/step-profile.generated.mjs

@@ -1,174 +0,0 @@
-// packages/app/src/workflow/step-profile.ts
-var DEFAULT_LAST = 20;
-var DEFAULT_WINDOW_SEC = 300;
-function nearestRankP50(values) {
-  if (values.length === 0)
-    return null;
-  const sorted = [...values].sort((a, b) => a - b);
-  return sorted[Math.ceil(sorted.length / 2) - 1] ?? null;
-}
-function numeric(value) {
-  return typeof value === "number" && Number.isFinite(value) ? value : null;
-}
-function msBetween(from, to) {
-  if (typeof from !== "string" || typeof to !== "string")
-    return null;
-  const start = Date.parse(from);
-  const end = Date.parse(to);
-  if (!Number.isFinite(start) || !Number.isFinite(end))
-    return null;
-  return end - start;
-}
-function sessionOf(event) {
-  const value = event.invocation?.continue;
-  if (value === true)
-    return "resumed";
-  if (value === false)
-    return "fresh";
-  return null;
-}
-function cacheHitOf(event) {
-  return numeric(event.cost?.exact?.cacheHit);
-}
-function startKey(event) {
-  const parsed = typeof event.startedAt === "string" ? Date.parse(event.startedAt) : Number.NaN;
-  return Number.isFinite(parsed) ? parsed : Number.POSITIVE_INFINITY;
-}
-function extractExecutions(runId, events) {
-  const actions = events.filter((e) => e.kind === "action").sort((a, b) => {
-    const left = startKey(a);
-    const right = startKey(b);
-    return left === right ? 0 : left - right;
-  });
-  const executions = [];
-  for (const [index, event] of actions.entries()) {
-    const previous = index === 0 ? undefined : actions[index - 1];
-    executions.push({
-      runId,
-      node: event.node ?? "",
-      actionKind: event.actionKind ?? "",
-      durationMs: numeric(event.durationMs),
-      idleGapMs: msBetween(previous?.completedAt, event.startedAt),
-      session: sessionOf(event),
-      cacheHit: cacheHitOf(event)
-    });
-  }
-  return executions;
-}
-function foldSession(executions) {
-  const known = new Set(executions.map((e) => e.session).filter((s) => s !== null));
-  if (known.size === 0)
-    return null;
-  if (known.size === 1)
-    return [...known][0] ?? null;
-  return "mixed";
-}
-function rowFlags(row, windowSec) {
-  const wMs = windowSec * 1000;
-  const flags = [];
-  const agentRun = row.actionKind === "agent.run";
-  const resumed = row.session === "resumed" || row.session === "mixed";
-  const p50 = row.durationMs.p50;
-  if (!agentRun && p50 !== null && p50 > wMs)
-    flags.push("step-over-window");
-  const idle = row.idleGapMs.p50;
-  if (agentRun && resumed && idle !== null && idle > wMs)
-    flags.push("resume-after-idle");
-  const hit = row.cacheHit.p50;
-  if (agentRun && resumed && row.cacheHit.known > 0 && hit !== null && hit < 0.5)
-    flags.push("resume-cold-cache");
-  if (agentRun && p50 !== null && p50 > 2 * wMs)
-    flags.push("agent-run-over-2w");
-  return flags;
-}
-function buildRows(executions, windowSec) {
-  const grouped = new Map;
-  for (const execution of executions) {
-    const key = `${execution.node}\x00${execution.actionKind}`;
-    const bucket = grouped.get(key);
-    if (bucket === undefined)
-      grouped.set(key, [execution]);
-    else
-      bucket.push(execution);
-  }
-  const rows = [];
-  for (const bucket of grouped.values()) {
-    const first = bucket[0];
-    if (first === undefined)
-      continue;
-    const durations = bucket.map((e) => e.durationMs).filter((d) => d !== null);
-    const gaps = bucket.map((e) => e.idleGapMs).filter((g) => g !== null);
-    const hits = bucket.map((e) => e.cacheHit).filter((h) => h !== null);
-    const row = {
-      node: first.node,
-      actionKind: first.actionKind,
-      runs: new Set(bucket.map((e) => e.runId)).size,
-      executions: bucket.length,
-      durationMs: {
-        p50: nearestRankP50(durations),
-        max: durations.length === 0 ? null : Math.max(...durations)
-      },
-      idleGapMs: { p50: nearestRankP50(gaps) },
-      session: first.actionKind === "agent.run" ? foldSession(bucket) : null,
-      cacheHit: {
-        p50: nearestRankP50(hits),
-        known: hits.length,
-        of: bucket.length
-      },
-      flags: []
-    };
-    row.flags = rowFlags(row, windowSec);
-    rows.push(row);
-  }
-  return rows.sort((a, b) => a.node === b.node ? a.actionKind.localeCompare(b.actionKind) : a.node.localeCompare(b.node));
-}
-function buildStepProfile(input) {
-  const executions = input.runs.flatMap((run) => extractExecutions(run.runId, run.events));
-  return {
-    workflow: input.workflow,
-    windowSec: input.windowSec,
-    sampledRuns: input.runs.length,
-    rows: buildRows(executions, input.windowSec)
-  };
-}
-function nonDryRuns(entries) {
-  return entries.filter((e) => e.isDryRun !== true && typeof e.runId === "string" && e.runId.length > 0);
-}
-function seconds(value) {
-  return value === null ? "?" : `${(value / 1000).toFixed(1)}s`;
-}
-function ratio(value) {
-  return value === null ? "?" : value.toFixed(2);
-}
-function formatStepProfileHuman(profile) {
-  const lines = [
-    `step profile — ${profile.workflow} (window ${profile.windowSec}s, ${profile.sampledRuns} sampled runs)`
-  ];
-  for (const row of profile.rows) {
-    lines.push([
-      row.node.padEnd(20),
-      row.actionKind.padEnd(14),
-      `${row.runs}/${row.executions}`.padEnd(8),
-      `p50=${seconds(row.durationMs.p50)}`.padEnd(12),
-      `max=${seconds(row.durationMs.max)}`.padEnd(12),
-      `idle=${seconds(row.idleGapMs.p50)}`.padEnd(12),
-      `session=${row.session ?? "?"}`.padEnd(15),
-      `cacheHit=${ratio(row.cacheHit.p50)} (${row.cacheHit.known}/${row.cacheHit.of})`.padEnd(20),
-      `flags=${row.flags.length === 0 ? "-" : row.flags.join(",")}`
-    ].join(" "));
-  }
-  return `${lines.join(`
-`)}
-`;
-}
-export {
-  DEFAULT_LAST,
-  DEFAULT_WINDOW_SEC,
-  buildRows,
-  buildStepProfile,
-  extractExecutions,
-  formatStepProfileHuman,
-  nearestRankP50,
-  nonDryRuns,
-  rowFlags
-};

package/plugins/sp/lib/transcript.ts

@@ -1,112 +0,0 @@
-/**
- * Host-transcript adapter shared by session-timeline (session review) and run-summary (dev-run /
- * dev-runall execution summary). Owns the host side: resolving the active transcript path from the
- * environment, detecting the host row format, and parsing raw JSONL lines into timestamped rows.
- * Reads Claude Code / pi JSONL rows read-only. Node builtins only.
- *
- * Task 1178 R2: the pure measurement (row/token/actor aggregation and its normalized types) lives
- * in `packages/app/src/workflow/run-summary.ts` and is reached through the generated pure
- * plan-projection entry. Normalize once here (`parseRows`) and hand the rows to that owner; the
- * re-exports below keep the plugin's one import path for the whole surface.
- */
-import { existsSync, readdirSync } from 'node:fs';
-import { homedir } from 'node:os';
-import { join } from 'node:path';
-import type { Row } from './plan-projection.generated.mjs';
-
-export {
-    type Acc,
-    type ActorSplit,
-    accumulate,
-    actorSplit,
-    type Block,
-    buildRunSummary,
-    formatDuration,
-    formatTokenSplit,
-    formatTokens,
-    type GateTime,
-    isCompaction,
-    newAcc,
-    type Progress,
-    promptText,
-    type Row,
-    type RunSummary,
-    type Span,
-    type SummaryRow,
-    skillInvocationPrompt,
-    sumSpans,
-    sumTokens,
-    type Tokens,
-    zeroTokens,
-} from './plan-projection.generated.mjs';
-
-const SESSION_ID = /^[A-Za-z0-9_-]+$/;
-/** pi roles that prove a `type:"message"` row is a pi transcript, not Claude's `user`/`assistant`. */
-const PI_ROLES = new Set(['user', 'assistant', 'toolResult']);
-
-/** First row matching a known shape decides: `type:"message"` with a pi role → pi, else Claude. */
-export function sniffFormat(rows: Row[]): 'claude' | 'pi' | 'unknown' {
-    for (const row of rows) {
-        if (row.type === 'message' && PI_ROLES.has(row.message?.role ?? '')) return 'pi';
-        if (row.type === 'user' || row.type === 'assistant') return 'claude';
-    }
-    return 'unknown';
-}
-
-/** Timestamped rows in file order; malformed lines counted, timestamp-less rows dropped. */
-export function parseRows(lines: string[]): {
-    rows: [Row, number][];
-    skippedLines: number;
-    format: 'claude' | 'pi' | 'unknown';
-} {
-    const rows: [Row, number][] = [];
-    let skippedLines = 0;
-    for (const line of lines) {
-        if (!line.trim()) continue;
-        let row: Row;
-        try {
-            row = JSON.parse(line) as Row;
-        } catch {
-            skippedLines++;
-            continue;
-        }
-        const ts = row.timestamp ? Date.parse(row.timestamp) : Number.NaN;
-        if (!Number.isNaN(ts)) rows.push([row, ts]);
-    }
-    return { rows, skippedLines, format: sniffFormat(rows.map(([r]) => r)) };
-}
-
-export type Resolved = { ok: true; path: string } | { ok: false; reason: string };
-
-export function resolveTranscript(
-    env: Record<string, string | undefined>,
-    projectsRoot = join(homedir(), '.claude', 'projects'),
-    override?: string,
-): Resolved {
-    if (override) return existsSync(override) ? { ok: true, path: override } : { ok: false, reason: 'no transcript' };
-    const id = env.CLAUDE_CODE_SESSION_ID;
-    if (!id) {
-        // 1138 R1: pi exports PI_SESSION_FILE (an exact path) and no Claude session id. Order is
-        // explicit override → Claude id → PI_SESSION_FILE; PI_SESSION_ID is never used for lookup
-        // because pi's filename embeds a timestamp, so the path is not derivable from the id.
-        const piFile = env.PI_SESSION_FILE;
-        if (piFile !== undefined && piFile !== '') {
-            return existsSync(piFile)
-                ? { ok: true, path: piFile }
-                : { ok: false, reason: `PI_SESSION_FILE ${piFile} does not exist` };
-        }
-        return {
-            ok: false,
-            reason:
-                'no host session id; pass --transcript <path> (pi: ~/.pi/agent/sessions/<cwd-slug>/<file>.jsonl, ' +
-                'or set PI_SESSION_FILE)',
-        };
-    }
-    if (!SESSION_ID.test(id)) return { ok: false, reason: 'refusing a session id with path characters' };
-    if (!existsSync(projectsRoot)) return { ok: false, reason: `no transcript root ${projectsRoot}` };
-    for (const dir of readdirSync(projectsRoot)) {
-        const path = join(projectsRoot, dir, `${id}.jsonl`);
-        if (existsSync(path)) return { ok: true, path };
-    }
-    return { ok: false, reason: `no transcript for session ${id}` };
-}