@qvac/harness 1.0.0-rc.0 → 1.0.0-rc.2

package/dist-lib/plugins/run-report/model.js

@@ -0,0 +1,387 @@
+import { createActor } from 'xstate';
+import { CompletionMachine } from '../../lib/machine/index.js';
+import { errorMessage, isRecord } from '../../lib/guards.js';
+import { RunLog } from '../../lib/run-log/index.js';
+import { story } from './story.js';
+import { decide } from './why.js';
+export async function reportModel(core) {
+    const requests = new Map();
+    for await (const request of RunLog.requests(core)) {
+        requests.set(request.index, request.params);
+    }
+    const fold = new Fold(requests);
+    for await (const entry of RunLog.read(core, { anyMachine: true })) {
+        fold.add(entry);
+    }
+    return fold.finish();
+}
+class Fold {
+    model = {
+        run: emptySummary(),
+        definition: null,
+        steps: [],
+        visits: {},
+        edges: {},
+        story: { prompt: '', rounds: [], tools: [] }
+    };
+    calls = new Map();
+    approvals = new Map();
+    rounds = new Map();
+    receipts = new Map();
+    machine = null;
+    current = null;
+    previous;
+    started = false;
+    lastSaved = 0;
+    round = 0;
+    requests;
+    constructor(requests) {
+        this.requests = requests;
+    }
+    add(entry) {
+        const { index, record } = entry;
+        if (record.type === 'metadata') {
+            this.metadata(record);
+        }
+        else if (record.type === 'operation') {
+            this.receipt(index, record.receipt);
+        }
+        else if (record.type === 'request') {
+            this.request(index, record);
+        }
+        else if (record.type === 'checkpoint' || record.type === 'delta') {
+            this.transition(entry, record);
+        }
+    }
+    finish() {
+        const snapshot = Object(this.previous);
+        const context = Object(snapshot.context);
+        const output = Object(snapshot.output);
+        const metrics = Object(output.metrics ?? context.metrics);
+        Object.assign(this.model.run, {
+            endedAt: this.lastSaved || null,
+            status: String(snapshot.status ?? 'unknown'),
+            outcome: String(output.status ?? context.outcome ?? snapshot.status ?? 'unknown'),
+            response: String(output.response ?? context.response ?? ''),
+            failure: failureOf(context, output),
+            rounds: Array.isArray(metrics.rounds)
+                ? metrics.rounds.length
+                : Number(context.round ?? 0) + 1,
+            tokens: typeof metrics.tokens === 'number' ? metrics.tokens : null
+        });
+        this.model.story = story({
+            context,
+            calls: this.calls,
+            approvals: this.approvals,
+            requests: this.rounds
+        });
+        return this.model;
+    }
+    metadata(record) {
+        const request = Object(record.request);
+        const budget = Object(record.budget);
+        this.model.definition = isDefinition(record.definition) ? record.definition : null;
+        Object.assign(this.model.run, {
+            runId: record.runId,
+            model: String(request.model ?? '?'),
+            agent: String(Object(request.agent).id ?? request.agentId ?? 'default'),
+            startedAt: record.startedAt ?? null,
+            deadline: typeof budget.deadlineMs === 'number' ? budget.deadlineMs : null,
+            machine: record.machine
+        });
+        if (record.machine !== CompletionMachine.VERSION || record.xstate !== RunLog.XSTATE_VERSION) {
+            this.model.run.replay = `Recorded on machine v${record.machine} and xstate ${record.xstate ?? '?'}; this report runs v${CompletionMachine.VERSION} and ${RunLog.XSTATE_VERSION}, so routes are not re-weighed.`;
+            return;
+        }
+        this.machine = CompletionMachine.create();
+    }
+    receipt(index, receipt) {
+        const known = this.receipts.get(receipt.id);
+        if (receipt.status === 'result' && known) {
+            Object.assign(known, { result: receipt.result, settled: true });
+            this.approval(receipt);
+            return;
+        }
+        const step = {
+            kind: 'receipt',
+            index,
+            round: Number(/:round-(\d+):/.exec(receipt.id)?.[1] ?? this.round),
+            id: receipt.id,
+            name: receipt.name,
+            effect: receipt.effect,
+            args: receipt.status === 'result' ? undefined : receipt.args,
+            result: receipt.status === 'result' ? receipt.result : undefined,
+            settled: receipt.status === 'result'
+        };
+        this.receipts.set(receipt.id, step);
+        this.model.steps.push(step);
+    }
+    approval(receipt) {
+        const named = /:round-(\d+):(.+):approve$/.exec(receipt.id);
+        if (receipt.name === 'human:approve' && named && receipt.status === 'result') {
+            this.approvals.set(`${named[1]}:${named[2]}`, receipt.result === true);
+        }
+    }
+    request(index, record) {
+        if (!this.rounds.has(record.round)) {
+            this.rounds.set(record.round, index);
+        }
+        const params = Object(this.requests.get(index));
+        const history = Array.isArray(params.history) ? params.history : [];
+        const tools = Array.isArray(params.tools) ? params.tools : [];
+        this.model.steps.push({
+            kind: 'request',
+            index,
+            round: record.round,
+            attempt: record.attempt,
+            droppedTurns: record.droppedTurns,
+            appended: history.slice(record.keep),
+            tools: tools.map((tool) => String(Object(Object(tool).function ?? tool).name ?? '?'))
+        });
+    }
+    transition({ index, snapshot, events }, record) {
+        const previous = this.previous;
+        this.saw(snapshot, record.savedAt, events);
+        if (!this.started) {
+            this.begin(snapshot);
+            return;
+        }
+        this.inspected(index, snapshot, events);
+        const micro = events.flatMap((event) => this.replay(event));
+        const recorded = record.trace ?? [];
+        this.restore(snapshot);
+        const from = Object(previous).value;
+        const to = Object(snapshot).value;
+        const drift = this.machine !== null && routes(micro) !== routesOf(recorded);
+        const walked = drift ? [] : micro;
+        const step = {
+            kind: 'transition',
+            index,
+            round: this.round,
+            at: record.savedAt,
+            from,
+            to,
+            events,
+            micro,
+            recorded,
+            changes: record.type === 'delta' ? changes(record.patch, { before: previous, after: snapshot }) : [],
+            entered: entered(walked, from, to),
+            taken: this.taken(walked, recorded),
+            facts: events.length > 0 && events.every((event) => event.type === 'FACTS'),
+            drift
+        };
+        this.count(step);
+    }
+    saw(snapshot, savedAt, events) {
+        this.previous = snapshot;
+        this.round = Number(Object(Object(snapshot).context).round ?? this.round);
+        this.lastSaved = savedAt;
+        this.learn(snapshot, events);
+    }
+    inspected(index, snapshot, events) {
+        const round = Object(Object(snapshot).context).round;
+        for (const event of events) {
+            const call = Object(Object(event.output).call);
+            if (String(event.type).endsWith('.tools.inspecting') && typeof call.id === 'string') {
+                this.calls.set(`${round}:${call.id}`, {
+                    name: String(call.name),
+                    args: call.args,
+                    step: index
+                });
+            }
+        }
+    }
+    begin(snapshot) {
+        this.started = true;
+        this.restore(snapshot);
+        for (const id of activeIds(Object(snapshot).value, 'completion')) {
+            this.model.visits[id] = [];
+        }
+    }
+    taken(micro, recorded) {
+        const keys = micro.length > 0
+            ? micro.flatMap((each) => each.candidates.filter((c) => c.verdict === 'taken').map((c) => c.key))
+            : recorded.flatMap((item) => routeKeys(this.model.definition, item));
+        return [...new Set(keys)];
+    }
+    count(step) {
+        const { index, entered, taken } = step;
+        this.model.steps.push(step);
+        for (const id of entered) {
+            ;
+            (this.model.visits[id] ??= []).push(index);
+        }
+        for (const key of taken) {
+            ;
+            (this.model.edges[key] ??= []).push(index);
+        }
+    }
+    learn(snapshot, events) {
+        const run = this.model.run;
+        const policy = Object(Object(Object(snapshot).context).policy);
+        run.maxToolRounds ??= typeof policy.maxToolRounds === 'number' ? policy.maxToolRounds : null;
+        const facts = Object(events.find((event) => event.type === 'FACTS')?.value);
+        const tools = Array.isArray(facts.tools) ? facts.tools : [];
+        if (run.tools.length === 0 && tools.length > 0) {
+            run.tools = tools.map((tool) => String(Object(tool).name ?? '?'));
+        }
+    }
+    replay(event) {
+        if (!this.machine || !this.current || typeof event.type !== 'string') {
+            return [];
+        }
+        try {
+            const decided = decide(this.machine, this.current, { ...event, type: event.type });
+            this.current = decided.at(-1)?.after ?? this.current;
+            return decided.map(({ eventType, before, after, candidates }) => ({
+                eventType,
+                from: before.value,
+                to: after.value,
+                candidates
+            }));
+        }
+        catch (error) {
+            this.model.run.replay ||= `Routes could not be re-weighed: ${errorMessage(error)}`;
+            return [];
+        }
+    }
+    restore(snapshot) {
+        if (!this.machine || !isRecord(snapshot)) {
+            return;
+        }
+        try {
+            const persisted = RunLog.parseSnapshot(snapshot);
+            this.current = createActor(this.machine, { snapshot: persisted }).getSnapshot();
+        }
+        catch (error) {
+            this.model.run.replay ||= `A recorded snapshot did not restore: ${errorMessage(error)}`;
+            this.current = null;
+        }
+    }
+}
+function failureOf(context, output) {
+    const reason = [
+        context.failMessage,
+        Object(context.failure).message,
+        Object(output.error).message,
+        output.error
+    ];
+    const found = reason.find((value) => typeof value === 'string' && value.length > 0);
+    return typeof found === 'string' ? found : '';
+}
+function entered(micro, from, to) {
+    const walks = micro.length > 0 ? micro : [{ from, to }];
+    const out = new Set();
+    for (const walk of walks) {
+        const was = new Set(activeIds(walk.from, 'completion'));
+        for (const id of activeIds(walk.to, 'completion')) {
+            if (!was.has(id)) {
+                out.add(id);
+            }
+        }
+    }
+    return [...out];
+}
+function routeKeys(definition, item) {
+    return item.sourceIds.flatMap((source) => {
+        const state = find(definition, source);
+        const event = item.eventType || 'always';
+        const list = (item.eventType ? state?.on?.[item.eventType] : state?.always) ?? [];
+        const index = list.findIndex((route) => item.targetIds.every((target) => route.target?.includes(target)));
+        return index < 0 ? [] : [`${source}|${event}|${index}`];
+    });
+}
+function find(node, id) {
+    if (!node || node.id === id) {
+        return node;
+    }
+    for (const child of Object.values(node.states ?? {})) {
+        const found = find(child, id);
+        if (found) {
+            return found;
+        }
+    }
+    return null;
+}
+function routes(micro) {
+    return micro
+        .flatMap((step) => step.candidates
+        .filter((candidate) => candidate.verdict === 'taken')
+        .map((candidate) => `${step.eventType}:${candidate.source}>${candidate.targets.join(',')}`))
+        .join(' ');
+}
+function routesOf(trace) {
+    return trace
+        .map((item) => `${item.eventType}:${item.sourceIds.join(',')}>${item.targetIds.join(',')}`)
+        .join(' ');
+}
+function emptySummary() {
+    return {
+        runId: '?',
+        model: '?',
+        agent: 'default',
+        startedAt: null,
+        endedAt: null,
+        tools: [],
+        maxToolRounds: null,
+        deadline: null,
+        status: 'unknown',
+        outcome: 'unknown',
+        response: '',
+        rounds: 0,
+        tokens: null,
+        machine: null,
+        replay: '',
+        failure: ''
+    };
+}
+export function activeIds(value, prefix) {
+    if (typeof value === 'string') {
+        return [`${prefix}.${value}`];
+    }
+    return isRecord(value)
+        ? Object.entries(value).flatMap(([key, child]) => [
+            `${prefix}.${key}`,
+            ...activeIds(child, `${prefix}.${key}`)
+        ])
+        : [];
+}
+function changes(patch, sides) {
+    const out = [];
+    const walk = ({ patch: node, path, before, after }) => {
+        if (!isRecord(node)) {
+            return;
+        }
+        if ('t' in node && Array.isArray(node.a)) {
+            out.push({
+                path,
+                before: undefined,
+                after: undefined,
+                kept: Number(node.t),
+                appended: node.a
+            });
+            return;
+        }
+        if ('$' in node || 't' in node) {
+            out.push({ path: path || '$', before, after });
+            return;
+        }
+        for (const key of Array.isArray(node.d) ? node.d : []) {
+            out.push({ path: join(path, String(key)), before: Object(before)[key], after: undefined });
+        }
+        for (const [key, child] of Object.entries(isRecord(node.o) ? node.o : {})) {
+            const next = { before: Object(before)[key], after: Object(after)[key] };
+            if (key !== 'children' || path !== '') {
+                walk({ patch: child, path: join(path, key), ...next });
+            }
+        }
+    };
+    walk({ patch, path: '', ...sides });
+    return out;
+}
+function isDefinition(value) {
+    return isRecord(value) && typeof value.id === 'string' && typeof value.type === 'string';
+}
+function join(path, key) {
+    return path ? `${path}.${key}` : key;
+}

package/dist-lib/plugins/run-report/page.d.ts

@@ -0,0 +1,13 @@
+import type { Chart } from './layout.ts';
+import type { ReportModel } from './model.ts';
+import type { Flow } from './flow.ts';
+export interface Charts {
+    run: Chart;
+    all: Chart;
+}
+export interface Views {
+    flow: Flow;
+    machine: Charts | null;
+}
+export declare function page(model: ReportModel, views: Views, title: string): string;
+export declare function esc(value: string): string;

package/dist-lib/plugins/run-report/page.js

@@ -0,0 +1,234 @@
+import { WORDMARK } from './brand.js';
+import { MEANINGS } from './meaning.js';
+import { SCRIPT } from './script.js';
+import { flowSvg, storyChips } from './flow-view.js';
+import { STYLE } from './style.js';
+const FONTS = 'https://fonts.googleapis.com/css2?family=Geist:wght@400;500;600;700&family=Inconsolata:wght@400;600;700&display=swap';
+export function page(model, views, title) {
+    return `<!doctype html><html lang="en"><head><meta charset="utf-8"><meta name="viewport" content="width=device-width,initial-scale=1">
+<title>${esc(title)}</title>
+<link rel="preconnect" href="https://fonts.googleapis.com"><link rel="preconnect" href="https://fonts.gstatic.com" crossorigin>
+<link href="${FONTS}" rel="stylesheet"><style>${STYLE}</style></head><body><main>
+<header class="topbar"><div class="brand">${WORDMARK}<span>Run report</span></div><button class="pill" type="button" id="theme">Theme</button></header>
+${hero(model, title)}
+<section id="flow"><h2>How the run went</h2>
+<p class="section-lede">From the request to the answer: each round the model took, and each call it made, colored by how it went, with the reason when it went wrong. Click any box for its details and the state machine steps inside it. Press play or use ← and → to walk the run.</p>
+${board(model, views)}</section>
+</main>
+<script type="application/json" id="data">${json(pageData(model, views))}</script>
+<script>${SCRIPT}</script></body></html>`;
+}
+function pageData(model, views) {
+    const chart = views.machine?.all;
+    return {
+        meanings: MEANINGS,
+        flow: views.flow.nodes.map(({ x, y, w, h, ...box }) => box),
+        run: model.run,
+        steps: model.steps,
+        visits: model.visits,
+        edges: model.edges,
+        story: model.story,
+        nodes: chart?.nodes.map(({ id, label, group, kind, stays }) => ({
+            id,
+            label,
+            group,
+            kind,
+            stays
+        })) ?? [],
+        routes: chart?.edges.map(({ key, source, target, event, guard }) => ({
+            key,
+            source,
+            target,
+            event,
+            guard
+        })) ?? []
+    };
+}
+function board(model, { flow, machine }) {
+    const canvas = flowSvg(flow, esc) +
+        (machine ? svg(machine.run, model, 'run') + svg(machine.all, model, 'all') : '');
+    return `<div class="board"><div class="card flow">
+<div class="toolbar"><div class="views"><button class="pill" type="button" data-chart="flow" aria-pressed="true">The run</button>${machine ? '<button class="pill" type="button" data-chart="machine" aria-pressed="false">State machine</button>' : ''}</div>
+<div class="legend flow-only"><span class="o-ok"><i></i>ok</span><span class="o-failed"><i></i>failed</span><span class="o-rejected"><i></i>rejected</span><span class="o-denied"><i></i>denied</span></div>
+<div class="legend machine-only"><span class="l-now"><i></i>this step</span><span class="l-taken"><i></i>taken</span><span class="l-not"><i></i>never taken</span><span class="l-trouble"><i></i>call turned down</span><span class="l-person"><i></i>a person decides</span><span class="l-error"><i></i>failed</span></div><span class="grow"></span>
+<button class="pill machine-only" type="button" id="untaken" aria-pressed="false">Whole machine</button>
+<button class="pill" type="button" id="facts" aria-pressed="false">Fact refreshes</button>
+<button class="pill" type="button" id="follow" aria-pressed="true">Follow</button>
+<button class="pill" type="button" id="zoom-out" aria-label="Zoom out">−</button><button class="pill" type="button" id="zoom-in" aria-label="Zoom in">+</button><button class="pill" type="button" id="fit">Fit</button></div>
+${jumps(model)}<div class="canvas" id="canvas">${canvas}</div>
+<div class="player"><div class="buttons"><button type="button" id="first" aria-label="First step">⏮</button><button type="button" id="prev" aria-label="Previous step">◀</button><button type="button" class="play" id="play" aria-label="Play">▶</button><button type="button" id="next" aria-label="Next step">▶︎▶︎</button></div>
+<input type="range" id="scrub" min="0" max="0" value="0" aria-label="Step"><span class="where" id="where"></span><div class="ticks" id="ticks"></div></div>
+</div><aside class="card panel" id="panel"></aside></div>`;
+}
+function jumps(model) {
+    const bad = model.story.rounds
+        .flatMap((round) => round.calls)
+        .filter((call) => call.outcome !== 'ok' && call.step !== null);
+    if (bad.length === 0) {
+        return '';
+    }
+    const chips = bad.map((call) => `<button type="button" class="chip o-${call.outcome}" data-goto="${call.step}">Round ${call.round + 1} · ${esc(call.name)} · ${esc(call.outcome === 'pending' ? 'no result' : call.outcome)}</button>`);
+    return `<div class="jumps"><span class="muted">Went wrong:</span>${chips.join('')}</div>`;
+}
+function hero(model, title) {
+    const { run } = model;
+    const wall = run.startedAt && run.endedAt ? duration(run.endedAt - run.startedAt) : '?';
+    const approvals = model.visits['completion.active.tools.approving']?.length ?? 0;
+    const good = run.outcome === 'success' || run.status === 'done';
+    const tiles = [
+        ['rounds', String(run.rounds)],
+        ['tool calls', String(model.story.rounds.flatMap((round) => round.calls).length)],
+        ['approvals', String(approvals)],
+        ['tokens', run.tokens === null ? '?' : String(run.tokens)],
+        ['wall time', wall],
+        ['state changes', String(model.steps.filter((step) => step.kind === 'transition').length)]
+    ];
+    const limits = [
+        run.maxToolRounds === null ? '' : `at most ${run.maxToolRounds} tool rounds`,
+        run.deadline && run.startedAt ? `deadline ${duration(run.deadline - run.startedAt)}` : ''
+    ].filter(Boolean);
+    return `<div class="card hero"><p class="eyebrow">Run ${esc(run.runId.slice(0, 12))}</p>
+<h1>${esc(title)}</h1>
+<p class="lede">Agent <b>${esc(run.agent)}</b> on <code>${esc(run.model)}</code>, completion machine v${esc(String(run.machine ?? '?'))}.</p>
+<div class="chips"><span class="chip ${good ? 'good' : 'warn'}">${esc(run.outcome)}</span>${storyChips(model.story, esc)}${limits.map((limit) => `<span class="chip warn">${esc(limit)}</span>`).join('')}</div>
+${run.tools.length ? `<p class="offered">Tools offered: ${run.tools.map((tool) => `<code>${esc(tool)}</code>`).join(' ')}</p>` : ''}
+<div class="tiles">${tiles.map(([key, val]) => `<div class="tile"><b>${esc(val)}</b><span>${esc(key)}</span></div>`).join('')}</div>
+${run.response ? `<details class="answer"><summary>The answer</summary><pre class="json">${esc(run.response)}</pre></details>` : ''}
+${run.replay ? `<div class="notice">${esc(run.replay)}</div>` : ''}</div>`;
+}
+function svg(chart, model, which) {
+    const pad = 16;
+    const w = chart.w + pad * 2;
+    const h = chart.h + pad * 2;
+    return `<svg id="chart-${which}" class="chart" style="display:none" xmlns="http://www.w3.org/2000/svg" width="${w}" height="${h}" viewBox="${-pad} ${-pad} ${w} ${h}" data-w="${w}" data-h="${h}">
+<defs>${MARKS.map((kind) => marker(kind, which)).join('')}</defs>
+${chart.edges.map((edge) => route(edge, model)).join('\n')}
+${chart.nodes.map((node) => state(node, model)).join('\n')}
+${chart.nodes.map((node) => badge(node, troubles(model))).join('')}
+</svg>`;
+}
+const FILLS = {
+    faint: 'var(--fg-faint)',
+    taken: 'var(--primary)',
+    hot: 'var(--fg)',
+    picked: 'var(--info-fg)',
+    trouble: 'var(--warn-fg)',
+    person: 'var(--info-fg)',
+    limit: 'var(--warn-fg)',
+    error: 'var(--bad-fg)'
+};
+const MARKS = Object.keys(FILLS);
+function marker(kind, which) {
+    const fill = FILLS[kind];
+    return `<marker id="arrow-${which}-${kind}" viewBox="0 0 10 10" refX="9" refY="5" markerWidth="8" markerHeight="8" markerUnits="userSpaceOnUse" orient="auto-start-reverse"><path d="M0,0 L10,5 L0,10 z" style="fill:${fill}"/></marker>`;
+}
+function state(node, model) {
+    const seen = node.kind === 'any' || node.kind === 'start' || node.id in model.visits;
+    const meaning = MEANINGS[node.id];
+    const tone = meaning?.tone ? ` t-${meaning.tone}` : '';
+    const cls = `n ${node.kind} ${seen ? 'visited' : 'unvisited'}${tone}`;
+    const id = esc(node.id);
+    const tip = meaning ? `<title>${esc(meaning.says)}</title>` : '';
+    const cx = node.x + node.w / 2;
+    const cy = node.y + node.h / 2;
+    if (node.kind === 'start') {
+        return `<g class="${cls}" data-id="${id}"><circle cx="${cx}" cy="${cy}" r="7"/></g>`;
+    }
+    if (node.kind === 'history') {
+        return `<g class="${cls}" data-id="${id}">${tip}<circle cx="${cx}" cy="${cy}" r="${node.w / 2}"/><text x="${cx}" y="${cy + 4.5}" text-anchor="middle">H</text></g>`;
+    }
+    const count = model.visits[node.id]?.length;
+    const name = node.group
+        ? `<text class="grp" x="${node.x + 12}" y="${node.y + 15}">${esc(node.group)}</text><text x="${node.x + 12}" y="${node.y + 32}">${esc(node.label)}</text>`
+        : `<text x="${node.x + 12}" y="${cy + 4.5}">${esc(node.label)}</text>`;
+    return `<g class="${cls}" data-id="${id}">${tip}<rect x="${node.x}" y="${node.y}" width="${node.w}" height="${node.h}" rx="10"/>
+${name}${count ? `<text class="count" x="${node.x + node.w - 10}" y="${cy + 4}" text-anchor="end">×${count}</text>` : ''}</g>`;
+}
+function route(edge, model) {
+    const taken = model.edges[edge.key]?.length ?? 0;
+    const start = edge.event === '';
+    const d = `M${edge.points.map(([x, y]) => `${x},${y}`).join(' L')}`;
+    const width = taken ? Math.min(1.6 + Math.log2(taken + 1) * 0.8, 4) : 1.2;
+    const tone = MEANINGS[edge.target]?.tone;
+    const toned = tone && tone !== 'end' ? tone : '';
+    const cls = `e${taken || start ? ' taken' : ''}${toned ? ` to-${toned}` : ''}`;
+    const used = taken > 0 || start;
+    const head = used ? toned || 'taken' : 'faint';
+    const { x, y, w, h } = edge.label;
+    const lines = [edge.event, edge.guard ? `[${edge.guard}]` : ''].filter(Boolean);
+    const label = start
+        ? ''
+        : `<g class="lab"><rect x="${x}" y="${y}" width="${w}" height="${h}" rx="5"/>${lines
+            .map((line, index) => `<text x="${x + 6}" y="${y + 14 + index * 15}">${esc(line)}${index === 0 && taken ? `<tspan class="n-taken" dx="6">×${taken}</tspan>` : ''}</text>`)
+            .join('')}</g>`;
+    return `<g class="${cls}" data-key="${esc(edge.key)}"><path class="hit" d="${d}"/><path class="line" d="${d}" style="stroke-width:${width}" data-head="${head}"/>${label}</g>`;
+}
+const BADGES = [
+    {
+        state: 'completion.active.tools.rejecting',
+        text: 'rejected',
+        tone: 'rejected',
+        counts: (call) => call.outcome === 'rejected'
+    },
+    {
+        state: 'completion.active.tools.executing',
+        text: 'failed',
+        tone: 'failed',
+        counts: (call) => call.outcome === 'failed'
+    },
+    {
+        state: 'completion.active.tools.approving',
+        text: 'approved',
+        tone: 'ok',
+        counts: (call) => call.approved === true
+    },
+    {
+        state: 'completion.active.tools.approving',
+        text: 'declined',
+        tone: 'denied',
+        counts: (call) => call.approved === false
+    }
+];
+function troubles(model) {
+    const calls = model.story.rounds.flatMap((round) => round.calls);
+    const out = new Map();
+    for (const rule of BADGES) {
+        const n = calls.filter(rule.counts).length;
+        if (n > 0) {
+            out.set(rule.state, [
+                ...(out.get(rule.state) ?? []),
+                { text: `${n} ${rule.text}`, tone: rule.tone }
+            ]);
+        }
+    }
+    return out;
+}
+function badge(node, all) {
+    let right = node.x + node.w + 6;
+    return (all.get(node.id) ?? [])
+        .map((trouble) => {
+        const w = trouble.text.length * 6.4 + 14;
+        right -= w + 4;
+        return `<g class="tb o-${trouble.tone}" data-id="${esc(node.id)}"><rect x="${right}" y="${node.y - 11}" width="${w}" height="18" rx="9"/><text x="${right + w / 2}" y="${node.y + 2}" text-anchor="middle">${esc(trouble.text)}</text></g>`;
+    })
+        .join('');
+}
+function json(value) {
+    return JSON.stringify(value).replace(/</g, '\\u003c');
+}
+export function esc(value) {
+    return value
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;');
+}
+function duration(ms) {
+    const s = Math.round(ms / 1000);
+    if (s < 60) {
+        return `${s} s`;
+    }
+    return s < 3600
+        ? `${Math.floor(s / 60)}m ${s % 60}s`
+        : `${Math.floor(s / 3600)}h ${Math.floor((s % 3600) / 60)}m`;
+}

package/dist-lib/plugins/run-report/script.d.ts

@@ -0,0 +1 @@
+export declare const SCRIPT: string;