@agentwhy/cli 0.0.0-dev

package/dist/report/check/session-actions.js

@@ -0,0 +1,90 @@
+import { filesRead } from '../flow-reads.js';
+import { RULE_NAMES } from '../rule-names.js';
+/**
+ * Whether a file read holds keys, as far as what was read says: a recognised key format, or a read shared with another
+ * protected file, whose keys may be this one's (`PrivateFile.mixed`). The to-do list and the marks decide by this alone.
+ */
+export function holdsKeys(file) {
+    return file.keys.length > 0 || file.mixed === true;
+}
+/** Names a file kept as an example rather than as configuration. A convention, matched on the name and nothing else. */
+const TEMPLATE = /\.(example|sample|template|dist)$/;
+/** The patterns of the built-in rules, every one of them for passwords and keys (F45). */
+const KEY_RULES = new Set(RULE_NAMES.flatMap((group) => group.patterns));
+/** Whether a path is named as a template (R12c): the one test the check and the report page share. */
+export function isTemplate(path) {
+    return TEMPLATE.test(path);
+}
+export function actionsOf(report) {
+    const rotate = new Set();
+    for (const flow of report.flows) {
+        for (const step of flow.steps) {
+            // H7: a file whose text reached the agent - a traced value, or lines a search printed - is to see to.
+            if (step.kind === 'reached' && step.toolKnown && step.outcome === 'succeeded') {
+                for (const file of filesRead(step))
+                    rotate.add(file);
+            }
+            // X10: a value its model was handed from code it wrote, which no call of its returned, is read all the same.
+            if (step.kind === 'received')
+                for (const file of step.files)
+                    rotate.add(file);
+        }
+    }
+    for (const statement of report.returns) {
+        if (statement.strength === 'value')
+            for (const file of statement.paths)
+                rotate.add(file);
+        for (const file of statement.writtenFrom)
+            rotate.add(file);
+    }
+    const patternOf = new Map(report.findings.map((finding) => [finding.path, finding.pattern]));
+    const toldPaths = new Set(report.findings.filter((finding) => finding.told === true).map((finding) => finding.path));
+    const routes = new Map();
+    const named = new Set();
+    // A call whose tool the adapter does not know is a mention, wherever the path sat: there is no profile saying that
+    // this tool addresses a file, so its text was searched for want of one. Found by running `check` on real sessions,
+    // where messages between agents were reported as routes to `.env`.
+    const reaching = report.stories.filter((story) => story.toolKnown);
+    const mentions = new Set(report.stories.filter((story) => !story.toolKnown).map((story) => story.path));
+    for (const story of reaching) {
+        if (story.outcome !== 'succeeded' || story.source !== 'input' || toldPaths.has(story.path))
+            continue;
+        named.add(story.path);
+        const key = `${story.path}\u0000${story.did}`;
+        const pattern = patternOf.get(story.path);
+        const known = routes.get(key);
+        routes.set(key, {
+            path: story.path,
+            did: story.did,
+            ...(pattern === undefined ? {} : { pattern }),
+            occurrences: (known?.occurrences ?? 0) + story.occurrences,
+        });
+    }
+    const onlyInResults = new Set(reaching
+        .filter((story) => story.outcome === 'succeeded' && story.source === 'result' && !named.has(story.path) && !toldPaths.has(story.path))
+        .map((story) => story.path));
+    const keyed = new Set(report.privateFiles.filter(holdsKeys).map((file) => file.path));
+    const readOf = new Map(report.privateFiles.map((file) => [file.path, readOfFile(file)]));
+    return {
+        policy: report.scope.policy.origin,
+        // F57: a told file's contents were read because the person let them be; only keys in it still need changing - a key
+        // of a known format, or any file a built-in rule for passwords and keys covers (F45: that rule is itself the fact).
+        rotate: [...rotate].filter((path) => !toldPaths.has(path) || keyed.has(path) || KEY_RULES.has(patternOf.get(path))).sort().map((path) => {
+            const read = readOf.get(path);
+            return { path, template: TEMPLATE.test(path), ...(keyed.has(path) ? { keyed: true } : {}), ...(read === undefined ? {} : { read }) };
+        }),
+        openRoutes: [...routes.values()],
+        ...(toldPaths.size === 0 ? {} : { told: [...new Set(reaching.filter((story) => story.outcome === 'succeeded' && toldPaths.has(story.path)).map((story) => story.path))].sort() }),
+        onlyInResults: [...onlyInResults].sort(),
+        unknown: [...new Set(reaching.filter((story) => story.outcome === 'unknown').map((story) => story.path))].sort(),
+        refusedAttempts: report.tally.refusedAttempts,
+        secretShapes: report.secretShapes.flatMap((finding) => finding.classes),
+        mentions: mentions.size,
+    };
+}
+/** A file's read, where it left anything to name. */
+function readOfFile(file) {
+    if (file.keys.length === 0 && file.names.length === 0 && file.keyed.length === 0 && file.mixed !== true)
+        return undefined;
+    return { keys: file.keys, names: file.names, keyed: file.keyed, ...(file.mixed === true ? { mixed: true } : {}) };
+}

package/dist/report/check/session-check.js

@@ -0,0 +1,91 @@
+import { splitBySince } from '../../core/session-filter.js';
+import { choosePolicy, policyRefusal } from '../choose-policy.js';
+import { digestOf } from './actions-digest.js';
+import { checkOf } from './check-lines.js';
+import { noteProblem, recordMark, recordUnmark } from './mark-request.js';
+import { actionsAfterMarks, marksInRange, standingMarks } from './marks.js';
+/** Each report is run for its actions; the text it also renders is discarded, so this only has to be a valid width. */
+const DISCARDED_WIDTH = 100;
+/**
+ * `agentwhy check`: every session of this project active in the range, read the way `report` reads one, and what a
+ * person can do about them in the terminal (`specs/2026-09-16-worth-running-every-day.md` R11-R16). A check writes
+ * nothing; a mark appends one line to the person's record, outside the project (R31-R35).
+ */
+export class SessionCheck {
+    #dependencies;
+    constructor(dependencies) {
+        this.#dependencies = dependencies;
+    }
+    async run(options) {
+        const analysis = await this.#analyse(options, options.share);
+        if ('answer' in analysis)
+            return analysis.answer;
+        const reading = await this.#dependencies.marks.read();
+        const standing = standingMarks(reading.records);
+        const before = analysis.sessions.map((session) => session.actions);
+        const after = analysis.sessions.map((session) => actionsAfterMarks(session.actions, session.summary.modifiedAt, standing));
+        const { done, reopened } = marksInRange(before, after, standing);
+        const digest = digestOf(after, {
+            asked: options.since.asked,
+            sessionsUnreadable: analysis.unreadable,
+            policyKind: analysis.policyKind,
+            ...(standing.size === 0 && !reading.failed
+                ? {}
+                : { marks: { done, reopened: reopened.map(({ path, result, at }) => ({ path, result, at })), unreadable: reading.failed } }),
+        });
+        return { outcome: 'checked', output: this.#dependencies.createRenderer(options).render(digest) };
+    }
+    async mark(options) {
+        // A note that cannot be recorded is said before a single session is read.
+        const problem = noteProblem(options.note);
+        if (problem !== undefined)
+            return problem;
+        // Marked against the full answer, marks or not: a file marked yesterday can be marked again today.
+        const analysis = await this.#analyse(options, false);
+        if ('answer' in analysis)
+            return analysis.answer;
+        const lines = checkOf(analysis.sessions.map((session) => ({ name: session.summary.id, actions: session.actions }))).rows;
+        return recordMark(this.#dependencies.marks, lines, options, { asked: options.since.asked, now: this.#dependencies.now });
+    }
+    async unmark(options) {
+        return recordUnmark(this.#dependencies.marks, options.path, this.#dependencies.now);
+    }
+    async #analyse(options, share) {
+        const { catalogue, report, files, workingDirectory } = this.#dependencies;
+        const chosen = await choosePolicy(options, files, this.#dependencies.tell);
+        if ('errors' in chosen)
+            return { answer: { outcome: 'policy-refused', output: policyRefusal(chosen.errors) } };
+        const listing = await catalogue.list(workingDirectory);
+        if (!listing.found || listing.sessions.length === 0) {
+            return {
+                answer: {
+                    outcome: 'no-sessions',
+                    output: `No sessions are stored for this directory, so there is nothing to check.\nLooked in ${listing.directory}\n` +
+                        `agentwhy reads sessions Claude Code already keeps, so either this directory has not been used with Claude Code yet, or it is not the one being worked in.\n` +
+                        `Use Claude Code here, then run agentwhy check again - or run agentwhy init now, to be protected before there is history to check.\n`,
+                },
+            };
+        }
+        const { inRange } = splitBySince(listing.sessions, options.since.since);
+        const sessions = [];
+        let unreadable = 0;
+        for (const summary of inRange) {
+            const result = await report.run({
+                input: summary.path,
+                policy: chosen.policy,
+                open: false,
+                ascii: false,
+                full: false,
+                colour: false,
+                share,
+                width: DISCARDED_WIDTH,
+            });
+            // Asked of the result, never of its text, as `start` asks it.
+            if (result.actions === undefined || result.outcome === 'session-unreadable')
+                unreadable += 1;
+            else
+                sessions.push({ summary, actions: result.actions });
+        }
+        return { policyKind: chosen.policy.origin.kind, sessions, unreadable };
+    }
+}

package/dist/report/choose-policy.js

@@ -0,0 +1,61 @@
+import { policyFromDenyRules, readDenyRules } from '../adapter/claude-code/policy/deny-rules.js';
+import { parsePolicy } from '../core/policy/parse-policy.js';
+import { readTellLists, tellPatterns } from './private-files/tell-lists.js';
+import { resolvePolicy } from '../core/policy/resolve-policy.js';
+import { FileAccessError } from '../ports/file-access-error.js';
+/**
+ * Which policy a session is read under: the policy file, else the settings file's deny rules, else the built-in
+ * default. `report` and `watch` both ask this, so an alert and the report it points to cannot be read under different
+ * rules (`specs/2026-09-16-when-an-agent-finishes.md` R10). A file that was named and cannot be read refuses the run
+ * rather than falling back to rules nobody chose.
+ */
+export async function choosePolicy(choice, files, tell) {
+    const file = choice.policyPath;
+    if (file !== undefined) {
+        const text = await readOrUndefined(file, files);
+        if (text === undefined)
+            return { errors: [`${file} could not be read`] };
+        // A policy file is the whole of what was chosen: nothing is added to it.
+        return resolvePolicy({ file: parsePolicy(text, file) });
+    }
+    const settingsPath = choice.settingsPath;
+    const text = settingsPath === undefined ? undefined : await readOrUndefined(settingsPath, files);
+    if (settingsPath !== undefined && text === undefined)
+        return { errors: [`${settingsPath} could not be read`] };
+    const rules = text === undefined ? undefined : readDenyRules(text);
+    // A settings file with no deny list is not a policy; it falls through to the default, which says so.
+    const resolved = resolvePolicy(rules === undefined || settingsPath === undefined ? {} : { settings: policyFromDenyRules(rules, settingsPath) });
+    if ('errors' in resolved || tell === undefined)
+        return resolved;
+    return { policy: withTold(resolved.policy, tellPatterns(await readTellLists(files, tell.pathsFor(settingsPath)))) };
+}
+/**
+ * F57: the files a person asked only to be told about, added as private and `tell`. A pattern the rules block stays
+ * blocked - both lists naming it is a file kept from the agent, which is the safer of the two - and one the built-in
+ * list blocks is told instead, since the built-in list is nobody's choice and the told list is somebody's.
+ */
+function withTold(policy, told) {
+    if (told.length === 0)
+        return policy;
+    const builtIn = policy.origin.kind === 'default';
+    const kept = policy.protected.filter((entry) => !(builtIn && told.includes(entry.pattern)));
+    const blocked = new Set(kept.map((entry) => entry.pattern));
+    return {
+        ...policy,
+        protected: [...kept, ...told.filter((pattern) => !blocked.has(pattern)).map((pattern) => ({ pattern, mode: 'tell' }))],
+    };
+}
+/** The words a refused policy is reported in, the same for every command that reads one. */
+export function policyRefusal(errors) {
+    return `${['The policy file was refused, so nothing was analysed:', ...errors.map((error) => `  - ${error}`)].join('\n')}\n`;
+}
+async function readOrUndefined(path, files) {
+    try {
+        return await files.readText(path);
+    }
+    catch (error) {
+        if (!(error instanceof FileAccessError))
+            throw error;
+        return undefined;
+    }
+}

package/dist/report/flow-reads.js

@@ -0,0 +1,18 @@
+/**
+ * The files a reached step showed the agent the text of (`search-hits-are-reads` H5): every file it reached where a
+ * traced value came back - the result does not say which one it came from - and every file whose lines a search
+ * printed, which it does say. The one answer every reader of "read" asks, so the page, `check`, To fix and the terminal
+ * cannot drift apart.
+ */
+export function filesRead(step) {
+    const printed = (step.lines ?? []).map((line) => line.path);
+    return step.carriedValue ? [...new Set([...step.files, ...printed])] : printed;
+}
+/** Whether a reached step showed the agent the text of this file. */
+export function readIn(step, path) {
+    return filesRead(step).some((file) => file === path);
+}
+/** How many lines of this file a search in the step printed, or undefined where none. */
+export function linesOf(step, path) {
+    return step.lines?.find((line) => line.path === path)?.count;
+}

package/dist/report/private-files/tell-lists.js

@@ -0,0 +1,84 @@
+import { dirname, join } from 'node:path';
+import { projectDirectoryName } from '../../adapter/claude-code/contract/projects.js';
+import { SETTINGS_FILES } from '../../adapter/claude-code/contract/settings.js';
+import { FileAccessError } from '../../ports/file-access-error.js';
+import { parseJsonObject } from '../../shared/json.js';
+export const TELL_LIST_VERSION = 1;
+export function tellListPaths(home, workingDirectory) {
+    return {
+        pathsFor: (settingsPath) => {
+            // A hook is given `$CLAUDE_PROJECT_DIR/.claude/settings.json`: the project is two directories up.
+            const project = settingsPath === undefined ? workingDirectory : dirname(dirname(settingsPath));
+            return {
+                shared: join(project, SETTINGS_FILES.directory, 'agentwhy.json'),
+                local: join(home, '.agentwhy', 'projects', projectDirectoryName(project), 'private-files.json'),
+            };
+        },
+    };
+}
+/**
+ * One list, read. A file that is not there is an empty list; one that cannot be understood is `unreadable`, and the
+ * patterns it may hold are not guessed at - the page says so rather than showing a list nobody wrote.
+ */
+export function readTellList(text) {
+    if (text === undefined)
+        return [];
+    const document = parseJsonObject(text);
+    if (document === undefined || document.version !== TELL_LIST_VERSION || !Array.isArray(document.tell))
+        return 'unreadable';
+    const patterns = document.tell.filter((pattern) => typeof pattern === 'string' && pattern.trim() !== '');
+    return patterns.length === document.tell.length ? [...new Set(patterns.map((pattern) => pattern.trim()))] : 'unreadable';
+}
+export function writtenTellList(patterns) {
+    return `${JSON.stringify({ version: TELL_LIST_VERSION, tell: [...new Set(patterns)].sort() }, undefined, 2)}\n`;
+}
+export async function readTellLists(files, paths) {
+    return { local: readTellList(await textOf(files, paths.local)), shared: readTellList(await textOf(files, paths.shared)) };
+}
+/** Every pattern of both lists that could be read: what the policy adds as `tell`. */
+export function tellPatterns(read) {
+    return [...new Set([read.local, read.shared].flatMap((list) => (list === 'unreadable' ? [] : list)))];
+}
+/**
+ * Writes the lists (F57). The page's switch goes through here and through nothing else, so there is one set of rules
+ * for these files; a list that cannot be read is not written over, since that would lose what someone put in it.
+ */
+export class TellLists {
+    #dependencies;
+    constructor(dependencies) {
+        this.#dependencies = dependencies;
+    }
+    async read() {
+        return readTellLists(this.#dependencies.files, this.#dependencies.paths.pathsFor(undefined));
+    }
+    /** Adds to one list and takes out of it; `false` where the list could not be read or written. */
+    async change(file, add, remove) {
+        const path = this.#dependencies.paths.pathsFor(undefined)[file];
+        const now = readTellList(await textOf(this.#dependencies.files, path));
+        if (now === 'unreadable')
+            return false;
+        const next = [...now.filter((pattern) => !remove.includes(pattern)), ...add.filter((pattern) => !remove.includes(pattern))];
+        if (next.length === now.length && next.every((pattern) => now.includes(pattern)))
+            return true;
+        try {
+            await this.#dependencies.writer.ensureDirectory(dirname(path));
+            await this.#dependencies.writer.writeText(path, writtenTellList(next));
+            return true;
+        }
+        catch (error) {
+            if (!(error instanceof FileAccessError))
+                throw error;
+            return false;
+        }
+    }
+}
+async function textOf(files, path) {
+    try {
+        return await files.readText(path);
+    }
+    catch (error) {
+        if (!(error instanceof FileAccessError))
+            throw error;
+        return undefined;
+    }
+}

package/dist/report/project-rules.js

@@ -0,0 +1,33 @@
+import { join } from 'node:path';
+import { SETTINGS_FILES } from '../adapter/claude-code/contract/settings.js';
+import { readDenyRules } from '../adapter/claude-code/policy/deny-rules.js';
+import { FileAccessError } from '../ports/file-access-error.js';
+import { parseJsonObject } from '../shared/json.js';
+/**
+ * The patterns the project's own settings files deny - its local file and its committed one - read at the moment the
+ * report is written (the report page spec M3, P36). A file one of these matches is *Protected*: Claude Code refuses the
+ * tool before anything is opened. One matched only by the built-in list or a policy file is not.
+ *
+ * `undefined` where a settings file exists and cannot be read or parsed: what it denies is then not known, and the page
+ * says so rather than calling a file unprotected. A file that is absent denies nothing, which is an answer.
+ */
+export async function projectDenyRules(files, projectDirectory) {
+    const patterns = [];
+    for (const name of [SETTINGS_FILES.local, SETTINGS_FILES.shared]) {
+        let text;
+        try {
+            text = await files.readText(join(projectDirectory, SETTINGS_FILES.directory, name));
+        }
+        catch (error) {
+            if (!(error instanceof FileAccessError))
+                throw error;
+            if (error.failure === 'not-found')
+                continue;
+            return undefined;
+        }
+        if (parseJsonObject(text) === undefined)
+            return undefined;
+        patterns.push(...(readDenyRules(text)?.patterns ?? []));
+    }
+    return [...new Set(patterns)];
+}

package/dist/report/render/home-relative.js

@@ -0,0 +1,18 @@
+import { isAbsolute, relative, resolve, sep } from 'node:path';
+/**
+ * Where a folder is, as a person reads it (`.ai/specs/2026-09-27-which-project.md` V1): `~/Projects/shop` under the home
+ * directory, and the path as it is anywhere else. The home directory itself is `~`. `relative` decides what lies under
+ * home, so a folder whose name merely begins like it (`/srv/home-else` beside `/srv/home`) is not shortened, and a Windows path is
+ * compared as its file system compares it. An empty home names no directory, so nothing is shortened.
+ */
+export function homeRelative(path, home) {
+    if (home === '')
+        return path;
+    const inside = relative(resolve(home), resolve(path));
+    if (inside === '')
+        return '~';
+    // `..` or `../…` climbs out of home; a folder of home whose own name begins with two dots does not.
+    if (inside === '..' || inside.startsWith(`..${sep}`) || isAbsolute(inside))
+        return path;
+    return `~${sep}${inside}`;
+}

package/dist/report/render/html-head.js

@@ -0,0 +1,26 @@
+/**
+ * The policy every page this tool writes is served under - by nothing, since a page is opened as a file. It says
+ * that the page may run its own inline script and style and may reach **nowhere**: no fetch, no image but a `data:` one, no form
+ * submission, no base to redirect relative links through (§7.5 hard constraint 1).
+ *
+ * One constant, because two pages carrying two copies of a security header is how one of them ends up weaker.
+ */
+/**
+ * The index's policy: the same, except that it may reach the origin it was loaded from. Opened as a file that is
+ * nothing; served by `start` it is the loopback server a mark is sent to (`worth-running-every-day` R53).
+ */
+export const INDEX_CONTENT_SECURITY_POLICY_META = '<meta http-equiv="Content-Security-Policy" content="default-src \'none\'; script-src \'unsafe-inline\'; ' +
+    'style-src \'unsafe-inline\'; img-src data:; connect-src \'self\'; base-uri \'none\'; form-action \'none\'">';
+export const CONTENT_SECURITY_POLICY_META = '<meta http-equiv="Content-Security-Policy" content="default-src \'none\'; script-src \'unsafe-inline\'; ' +
+    'style-src \'unsafe-inline\'; img-src data:; connect-src \'none\'; base-uri \'none\'; form-action \'none\'">';
+/**
+ * The tab's icon: the mark both pages carry beside the wordmark, in the accent on the page's own background, drawn
+ * as a `data:` URI so the file stays one file. The policies above allow `img-src data:` for exactly this - a `data:`
+ * image is the page's own bytes and reaches nowhere - because a browser that applies `default-src 'none'` to the
+ * icon would otherwise leave the tab blank.
+ */
+const FAVICON_SVG = '<svg xmlns="http://www.w3.org/2000/svg" viewBox="-3 -2 46 44"><rect x="-3" y="-2" width="46" height="44" rx="10" fill="#0d0e11"/>' +
+    '<g fill="none" stroke="#ff997f" stroke-width="6" stroke-linecap="round">' +
+    '<path d="m17 25-3 3a7.07 7.07 0 0 1-10-10l8-8a7.07 7.07 0 0 1 10 0"/>' +
+    '<path d="m23 15 3-3a7.07 7.07 0 0 1 10 10l-8 8a7.07 7.07 0 0 1-10 0"/></g></svg>';
+export const FAVICON_LINK = '<link rel="icon" type="image/svg+xml" href="data:image/svg+xml,' + encodeURIComponent(FAVICON_SVG) + '">';

package/dist/report/render/html-report-components.js

@@ -0,0 +1,48 @@
+import { inLanguages, labelAttributes } from './report-copy.js';
+export function escapeHtml(value) {
+    return value.replace(/[&<>"']/g, (character) => ({
+        '&': '&amp;', '<': '&lt;', '>': '&gt;', '"': '&quot;', "'": '&#39;',
+    })[character] ?? character);
+}
+const OUTCOME_SYMBOL = { succeeded: '!', blocked: '✓', unknown: '?' };
+const EXPAND_GLYPH = '<svg viewBox="0 0 16 16" aria-hidden="true" width="14" height="14"><path d="M9.5 1.5h5v5M14.5 1.5 9 7' +
+    'M6.5 14.5h-5v-5M1.5 14.5 7 9" fill="none" stroke="currentColor" stroke-width="1.4" stroke-linecap="round"' +
+    ' stroke-linejoin="round"/></svg>';
+/**
+ * A table, with a way to give it the width of the page. The button is an enhancement and says so: with no
+ * script the container still scrolls, which is the whole behaviour a reader needs. The dialog only helps where
+ * scrolling a column at a time is the thing that makes a table hard to read.
+ */
+export function scrollTable(table) {
+    return '<div class="table-wrap"><button type="button" class="table-open js-only" data-table-open' +
+        labelAttributes((t) => t('table.expand')) + '>' + EXPAND_GLYPH + '</button>' +
+        '<div class="table-scroll">' + table + '</div></div>';
+}
+export function badge(outcome) {
+    return '<span class="badge ' + outcome + '"><span aria-hidden="true">' + OUTCOME_SYMBOL[outcome] + '</span> ' +
+        inLanguages((t) => t('outcome.' + outcome)) + '</span>';
+}
+export function agentName(agent, report) {
+    return agent.ordinal === undefined ? 'Main agent' : 'Agent ' + agent.ordinal;
+}
+export function actionsFor(agent, report) {
+    if (agent.index === report.graph.main.index)
+        return report.mainAgent;
+    return report.delegations.find((entry) => entry.childAgentIndex === agent.index)?.actions ??
+        report.unattributedAgents.find((entry) => entry.agentIndex === agent.index)?.actions ?? [];
+}
+export function actionTable(actions, prefix) {
+    const heading = (key) => '<th scope="col">' + inLanguages((t) => t(key)) + '</th>';
+    if (actions.length === 0)
+        return '<p class="empty-note">' + inLanguages((t) => t('table.empty')) + '</p>';
+    return scrollTable('<table><caption>' + inLanguages((t) => t('table.caption')) + '</caption><thead><tr>' +
+        heading('table.step') + heading('table.tool') + heading('table.path') + heading('table.outcome') + heading('table.evidence') +
+        '</tr></thead><tbody>' + actions.map((action, index) => '<tr id="' + prefix + '-action-' + index + '" class="' + action.outcome + '"><td>' + action.sequence +
+        '</td><td>' + escapeHtml(action.tool) + '</td><td>' +
+        (action.target === undefined ? '<span class="muted">' + inLanguages((t) => t('table.notDetected')) + '</span>'
+            : '<code>' + escapeHtml(action.target) + '</code>') +
+        '</td><td>' + (action.outcome === 'succeeded' ? '<span class="neutral-outcome">' + inLanguages((t) => t('outcome.succeeded')) + '</span>' : badge(action.outcome)) +
+        '</td><td><code>' + escapeHtml(action.evidence) + '</code></td></tr>').join('') + '</tbody></table>');
+}
+/** The agent's own name is the tool's vocabulary, not the transcript's, so it is written per language. */
+export const agentLabel = (t, name) => (name === 'Main agent' ? t('col.main') : name);