@agentwhy/cli 0.0.0-dev

package/dist/report/build-report.js

@@ -0,0 +1,1037 @@
+import { programsIn } from '../core/access/command-line.js';
+import { printedLines, protectedAccesses, readsContent } from '../core/access/protected-access.js';
+import { filesTracedIn, returnsOf, traceValues } from '../core/access/returns.js';
+import { valueUses } from '../core/access/uses.js';
+import { wordsBeforeCalls } from '../core/access/words-before.js';
+import { firstSentence } from '../shared/sentence.js';
+import { NAMES_PER_FILE } from './report-model.js';
+import { filesRead } from './flow-reads.js';
+/**
+ * Identifiers are shortened in a report (§7.3). Both ends are kept: a `toolu_01…` prefix is shared by every
+ * call in a session, so a head-only abbreviation makes two different calls look like the same one.
+ */
+const SHORTEN_ABOVE = 20;
+const HEAD = 10;
+const TAIL = 4;
+/** Programs that carry text rather than reach a file; naming them in a finding only adds noise. */
+const NAMES_NOTHING = new Set(['echo', 'printf', 'true', 'false', ':', 'sleep', 'cd', 'export']);
+const GAP_WORDS = {
+    'session-missing': 'the session transcript itself could not be read, so nothing here is a finding',
+    'source-missing': 'a source was absent or could not be read',
+    'record-damaged': 'a record could not be parsed',
+    'result-missing': 'a call has no result, so its outcome is unknown',
+    'spilled-result-missing': 'a result points at a spilled file that is gone',
+    'outcome-unrecognised': 'an outcome marker carried a value this version does not know',
+    'relation-unresolved': 'identifiers did not allow a confident join, so no outcome was assigned',
+    'result-incomplete': 'a text may not hold everything, so what is not in it cannot be said',
+    'capability-absent': 'the record does not show all of this',
+    'capability-unmeasured': 'whether the record shows all of this has not been measured',
+};
+/** The order a call's reached steps take when its files had different outcomes: the established one first. */
+const OUTCOME_ORDER = ['succeeded', 'blocked', 'unknown'];
+/** What a capability gap cannot answer, completing its words (`2026-09-27-what-codex-wrote.md` X23). */
+const QUESTION_WORDS = {
+    actions: 'which actions ran',
+    access: 'what an action reached',
+    'output-delivery': 'what reached the AI',
+    'own-words': 'everything the AI wrote',
+    reasoning: 'what the AI worked out before acting',
+    refusals: 'whether an action was refused',
+    permissions: 'which permissions were in force',
+};
+const FULL_VIEW = { share: false, projectRoot: { kind: 'absent' } };
+export function buildReport(model, policy, redactor, view = FULL_VIEW) {
+    const accesses = protectedAccesses(model, policy);
+    // The trace is built by the redactor, which owns this run's salt: what it holds means nothing outside this report.
+    // One trace for the run: what came back and what an agent wrote before a call ask the same question of it.
+    const traced = traceValues(model, accesses, (values) => redactor.trace(values));
+    const returns = returnsOf(model, accesses, traced);
+    const uses = valueUses(model, accesses, traced);
+    // F57: which patterns a person asked only to be told about, so a finding under one says the agent was let read it.
+    const told = new Set(policy.protected.filter((entry) => entry.mode === 'tell').map((entry) => entry.pattern));
+    const findings = accesses.map((access) => toFinding(access, model, redactor, view, told.has(access.pattern)));
+    const secretShapes = secretShapesIn(model, redactor, view);
+    const delegations = model.delegations.map((delegation) => toDelegation(delegation, model, accesses, redactor, view));
+    const gaps = gapsOf(model.gaps, returns);
+    const attributed = new Set(model.delegations.map((delegation) => delegation.childAgentId));
+    const unattributedAgents = model.agents
+        .filter((agent) => agent.id !== model.sessionId && !attributed.has(agent.id))
+        .map((agent) => toAgent(agent, model, accesses, redactor, view));
+    const wordsBefore = wordsBeforeCalls(model);
+    const stories = storiesOf(model, accesses, wordsBefore, traced, redactor, view);
+    const statements = returns.map((entry) => toReturn(entry, model, redactor, view));
+    // The graph and the flows are built before the tally, because one of its counts is read from them: how many
+    // agents the contents of a protected file reached. That is the question the headline answers first, and every
+    // other view of this session - the index among them - must answer it with the same number.
+    const graph = graphOf(model, accesses, returns, uses, traced, redactor, view);
+    const flows = flowsOf(model, accesses, uses, returns, wordsBefore, traced, redactor, view);
+    const tally = tallyOf(accesses, returns, uses, contentsSeenIn(graph, flows));
+    return {
+        headline: headlineOf(tally, coverageOf(model), redactor),
+        tally,
+        graph,
+        stories,
+        // The scope is built last: the redactor can only report what it did once everything has passed through it.
+        scope: scopeOf(model, policy, redactor, view),
+        summary: {
+            agents: model.agents.length,
+            delegations: model.delegations.length,
+            actions: model.events.length,
+            byOutcome: countOutcomes(model.events),
+            findings: findings.length,
+            secretShapes: secretShapes.length,
+            unattributedAgents: unattributedAgents.length,
+            tools: toolCounts(model.events),
+        },
+        mainAgent: model.events
+            .filter((event) => event.agentId === model.sessionId)
+            .sort((first, second) => first.sequence - second.sequence)
+            .map((event) => toAction(event, model, accesses, redactor, view)),
+        delegations,
+        unattributedAgents,
+        findings,
+        secretShapes,
+        returns: statements,
+        uses: uses.map((use) => toUse(use, model, redactor, view)),
+        flows,
+        privateFiles: privateFilesOf(model, accesses, redactor),
+        everydayFiles: everydayFilesOf(model, accesses, redactor),
+        missing: gaps.map((gap) => redactor.term(missingWords(gap))),
+        gaps,
+        recorded: recordedOf(model, redactor, view),
+    };
+}
+/**
+ * What the runtime recorded beside the actions, across the redaction boundary (`2026-09-27-what-codex-wrote.md` X19-X23):
+ * settings through the term and path doors, reviews by agent index and evidence, and every free text by its size only.
+ */
+function recordedOf(model, redactor, view) {
+    const indexOf = (agentId) => model.agents.findIndex((agent) => agent.id === agentId);
+    const grouped = new Map();
+    for (const turn of model.turns) {
+        if (turn.permissions === undefined)
+            continue;
+        const key = JSON.stringify(turn.permissions);
+        const group = grouped.get(key) ?? { permissions: turn.permissions, turns: 0, agents: new Set() };
+        group.turns += 1;
+        if (indexOf(turn.agentId) >= 0)
+            group.agents.add(indexOf(turn.agentId));
+        grouped.set(key, group);
+    }
+    const capabilities = new Map();
+    for (const record of model.capabilities) {
+        const key = `${record.question} ${record.state}`;
+        const known = capabilities.get(key);
+        capabilities.set(key, { question: record.question, state: record.state, sources: (known?.sources ?? 0) + 1 });
+    }
+    const contexts = { code: 0, conversation: 0, 'unjoined-instruction': 0, 'orphan-output': 0 };
+    for (const context of model.contexts)
+        contexts[context.kind] += 1;
+    return {
+        permissions: [...grouped.values()].map(({ permissions, turns, agents }) => ({
+            turns,
+            agentIndexes: [...agents].sort((first, second) => first - second),
+            ...(permissions.approval === undefined ? {} : { approval: redactor.term(permissions.approval) }),
+            approver: permissions.approver,
+            ...(permissions.sandbox === undefined ? {} : { sandbox: redactor.term(permissions.sandbox) }),
+            network: permissions.network,
+            readScopes: permissions.scopes.filter((scope) => scope.access === 'read').length,
+            writeScopes: permissions.scopes.filter((scope) => scope.access === 'write').length,
+            writablePaths: [...new Set(permissions.scopes.flatMap((scope) => scope.access === 'write' && scope.target.kind === 'path' ? [redactor.path(scope.target.path)] : []))],
+            complete: permissions.complete,
+        })),
+        reviews: model.reviews.map((review) => ({
+            ...(indexOf(review.reviewedAgentId) < 0 ? {} : { reviewedAgentIndex: indexOf(review.reviewedAgentId) }),
+            verdicts: review.verdicts.map((verdict) => ({
+                outcome: verdict.outcome,
+                turnKnown: verdict.turnId !== undefined,
+                ...(verdict.risk === undefined ? {} : { risk: redactor.term(verdict.risk) }),
+                ...(verdict.rationale === undefined ? {} : { rationaleSize: verdict.rationale.length }),
+                evidence: redactor.term(describeEvidence(verdict.evidence, model, view)),
+            })),
+        })),
+        capabilities: [...capabilities.values()],
+        deliveries: model.deliveries.length,
+        contexts,
+    };
+}
+/**
+ * What reading each protected file left behind (`specs/2026-09-23-the-report-page.md` M1, M2): the key formats and the
+ * variable names in its text, by name only. A read is counted for a file only when it named that one protected file and
+ * its result is that file's text; a read of two at once (`cat a.env b.env`) is given to neither, and both say so,
+ * because telling their lines apart would be a guess.
+ */
+function privateFilesOf(model, accesses, redactor) {
+    const found = new Map();
+    const named = new Map();
+    for (const access of accesses) {
+        if (!found.has(access.path))
+            found.set(access.path, { keys: [], names: [], keyed: [], mixed: false });
+        if (access.source !== 'input')
+            continue;
+        named.set(access.eventId, (named.get(access.eventId) ?? new Set()).add(access.path));
+    }
+    const printed = new Set(accesses.filter((access) => access.lines !== undefined).map((access) => access.eventId));
+    for (const event of model.events) {
+        const content = event.result?.content;
+        const paths = [...(named.get(event.id) ?? [])];
+        // H2, H6: a search says whose each line is, so its lines are read for their own file only, and never `mixed`.
+        if (printed.has(event.id)) {
+            for (const [path, lines] of printedLines(event, paths)) {
+                const file = found.get(path);
+                if (file !== undefined)
+                    readInto(file, lines.join('\n'), redactor);
+            }
+        }
+        if (paths.length === 0 || content === undefined || event.outcome !== 'succeeded' || !readsContent(event))
+            continue;
+        if (paths.length > 1) {
+            for (const path of paths)
+                found.get(path).mixed = true;
+            continue;
+        }
+        const file = found.get(paths[0]);
+        if (file !== undefined)
+            readInto(file, content, redactor);
+    }
+    return [...found].map(([path, file]) => ({
+        path: redactor.path(path),
+        keys: file.keys.map((key) => redactor.term(key)),
+        names: file.names,
+        keyed: file.keyed.map((line) => ({ name: line.name, key: redactor.term(line.key) })),
+        ...(file.mixed ? { mixed: true } : {}),
+    }));
+}
+/** What one file's text shows, through the redactor (M2, M2a): key classes, variable names, keyed lines - never a value. */
+function readInto(file, content, redactor) {
+    for (const key of redactor.keyClassesIn(content))
+        if (!file.keys.includes(key))
+            file.keys.push(key);
+    for (const name of redactor.keysIn(content)) {
+        if (file.names.length < NAMES_PER_FILE && !file.names.includes(name))
+            file.names.push(name);
+    }
+    for (const line of redactor.keyedIn(content)) {
+        if (file.keyed.length < NAMES_PER_FILE && !file.keyed.some((each) => each.name === line.name))
+            file.keyed.push(line);
+    }
+}
+/**
+ * The files no protected pattern matches that a file tool worked on (M6): a known tool whose result is the named
+ * file's text, or which writes it. A call whose outcome was not recorded is left out - it may not have reached the
+ * file, and a list of what the AI opened must not grow by what it may have opened.
+ */
+function everydayFilesOf(model, accesses, redactor) {
+    const RANK = { changed: 2, read: 1, stopped: 0 };
+    const guarded = new Set(accesses.map((access) => access.eventId + '\u0000' + access.path));
+    const delegating = new Set(model.delegations.map((delegation) => delegation.id));
+    const files = new Map();
+    for (const event of model.events) {
+        if (!event.toolKnown || delegating.has(event.id) || event.outcome === 'unknown')
+            continue;
+        const writes = event.written !== undefined;
+        if (!writes && event.resultShape !== 'content')
+            continue;
+        const how = event.outcome === 'blocked' ? 'stopped' : writes ? 'changed' : 'read';
+        for (const path of new Set(event.targets)) {
+            if (path === '' || guarded.has(event.id + '\u0000' + path))
+                continue;
+            const known = files.get(path);
+            files.set(path, { calls: (known?.calls ?? 0) + 1, how: known === undefined || RANK[how] > RANK[known.how] ? how : known.how });
+        }
+    }
+    return [...files].map(([path, file]) => ({ path: redactor.path(path), calls: file.calls, how: file.how }));
+}
+/**
+ * A recognised key format in what came back - `S-shape` of §5.4. It is reported even when the call touched no
+ * protected path: a secret exported in a shell profile sits in no `.env` file, so path matching is blind to it.
+ */
+function secretShapesIn(model, redactor, view) {
+    return model.events.flatMap((event) => {
+        const content = event.result?.content;
+        if (content === undefined)
+            return [];
+        const classes = redactor.classesIn(content);
+        if (classes.length === 0)
+            return [];
+        const agentIndex = model.agents.findIndex((agent) => agent.id === event.agentId);
+        return [
+            {
+                ...(agentIndex < 0 ? {} : { agentIndex }),
+                tool: redactor.term(event.toolName),
+                outcome: event.outcome,
+                classes: classes.map((name) => redactor.term(name)),
+                evidence: redactor.term(describeEvidence(event.result?.evidence ?? event.evidence, model, view)),
+            },
+        ];
+    });
+}
+/**
+ * What the agent wrote before this call, across the redaction boundary (`specs/2026-09-15-why-this-call.md` R6, R7). The
+ * sentence is shown only when those words carried no traced value and the view is not the shared one; how much was
+ * written, and before how many calls, is shown either way. The words are never introduced as a reason: judging an
+ * instruction is the detector's work, behind the D1 gate.
+ */
+function wroteBefore(before, model, traced, redactor, view) {
+    const words = before?.words ?? [];
+    // A block the record kept empty is not words, and is not nothing either: both are reported, each as itself.
+    const spoken = words.filter((message) => message.text.trim() !== '');
+    const texts = spoken.map((message) => message.text);
+    const carried = filesTracedIn(texts, traced);
+    const first = spoken[0];
+    const quotable = first !== undefined && carried.length === 0 && !view.share;
+    const sentence = quotable && first !== undefined ? firstSentence(first.text) : undefined;
+    return {
+        size: texts.reduce((total, text) => total + text.length, 0),
+        blank: words.length - spoken.length,
+        covers: before?.covers ?? 1,
+        ...(sentence === undefined ? {} : { sentence: redactor.scan(sentence.text) }),
+        ...(sentence === undefined || first === undefined ? {} : { kind: first.kind }),
+        ...(sentence?.cut === true ? { cut: true } : {}),
+        carried: [...new Set(carried.map((path) => redactor.path(path)))],
+        evidence: redactor.term(first === undefined ? 'nothing before this call' : describeEvidence(first.evidence, model, view)),
+    };
+}
+/**
+ * The findings as numbers, counted once (`Tally`). Two rules decide every count here:
+ *
+ * - A **refused** attempt reached nothing, so it is never counted as a file that was reached. Saying "30 files
+ *   were reached, and 3 attempts were refused" while the 3 sit inside the 30 is a sentence that misleads by
+ *   arithmetic alone.
+ * - "No call ever named it" means **no** call named it. A path that one command named and another only printed
+ *   belongs to the named side; the result route is the one where nothing was there to inspect.
+ */
+function tallyOf(accesses, returns, uses, contentsSeen) {
+    // X11: reached is what the record establishes. Counting every attempt that was not refused counted a missing file
+    // `cat` failed on, and a call with no result, as a file reached.
+    const reached = accesses.filter((access) => access.outcome === 'succeeded');
+    const files = new Set(reached.map((access) => access.path));
+    const named = new Set(reached.filter((access) => access.source === 'input').map((access) => access.path));
+    const onlyThroughResult = [...files].filter((path) => !named.has(path)).length;
+    return {
+        contentsSeen,
+        filesReached: files.size,
+        onlyThroughResult,
+        namedByCall: files.size - onlyThroughResult,
+        refusedAttempts: accesses.filter((access) => access.outcome === 'blocked').length,
+        unknownAttempts: accesses.filter((access) => access.outcome === 'unknown').length,
+        valuesReturned: returns.filter((entry) => entry.strength === 'value').length,
+        valuesWritten: returns.filter((entry) => entry.strength !== 'value' && entry.writtenFrom.length > 0).length,
+        // Counted from the uses, not from the returns: the main agent returns to nobody, and it is the one agent
+        // every session has. Counted per agent, because that is the question the agent's own panel answers.
+        wroteInMessages: new Set(uses.filter(isInOwnWords).map((use) => use.agentId)).size,
+        filesWrittenOnward: new Set(uses.filter(isWrittenOnward).flatMap((use) => use.targets ?? [])).size,
+        valueUses: uses.length,
+    };
+}
+/**
+ * How many agents the contents of a protected file reached, by the same rule `session-view.ts` applies to draw
+ * one: what a delegation returned, what an agent wrote of it, and every step of its flow that carried a value.
+ * The two must keep agreeing - the report says "3 agents saw what is inside sensitive files" from that rule, and
+ * a row of the index that says something else about the same session is a row that lies.
+ */
+function contentsSeenIn(graph, flows) {
+    // The main agent is kept apart from the rest in the graph, and it is the one agent every session has: counting
+    // only `graph.agents` said "no agent saw anything" of a session whose main agent saw everything.
+    return [graph.main, ...graph.agents].filter((agent) => {
+        if (agent.returned === 'value' || agent.wroteValue === true || agent.wroteOnward === true || agent.received !== undefined)
+            return true;
+        const flow = flows.find((one) => one.agentIndex === agent.index);
+        return flow !== undefined && flow.steps.some((step) => (step.kind === 'reached' && step.outcome === 'succeeded' && filesRead(step).length > 0) ||
+            step.kind === 'received' ||
+            step.kind === 'used' ||
+            (step.kind === 'delegated' && step.strength === 'value'));
+    }).length;
+}
+/**
+ * The session as a shape. One node per agent, each carrying what it was asked and what it reached, ranked so
+ * that a drawing which has room for four lanes draws the four that are worth drawing.
+ *
+ * This is deliberately not a list of delegations: a delegation is a call, and an agent that no call asked for
+ * still ran and still reached things. The node is the agent, and a missing instruction is a fact about it.
+ */
+function graphOf(model, accesses, returns, uses, traced, redactor, view) {
+    // X10: an agent saw a value its model was handed, whichever call - if any the record names - it came from.
+    const received = new Map();
+    for (const delivery of model.deliveries) {
+        if (delivery.status !== 'confirmed')
+            continue;
+        const files = filesTracedIn([delivery.text], traced);
+        if (files.length > 0)
+            received.set(delivery.recipientAgentId, new Set([...(received.get(delivery.recipientAgentId) ?? []), ...files]));
+    }
+    const askedOf = new Map(model.delegations
+        .filter((delegation) => delegation.childAgentId !== undefined && delegation.description !== undefined)
+        .map((delegation) => [delegation.childAgentId ?? '', delegation.description ?? '']));
+    // The delegated agents in the order their positions run, which is the order both renderers number them in.
+    const delegatedOrder = model.agents
+        .map((agent, index) => ({ agent, index }))
+        .filter(({ agent }) => agent.id !== model.sessionId)
+        .map(({ index }) => index);
+    const nodeOf = (agent) => {
+        const parents = model.delegations.filter((delegation) => delegation.childAgentId === agent.id);
+        const parentIndex = parents.length === 1
+            ? model.agents.findIndex((candidate) => candidate.id === parents[0]?.parentAgentId)
+            : -1;
+        const own = accesses.filter((access) => access.agentId === agent.id);
+        const reached = own.filter((access) => access.outcome === 'succeeded');
+        const files = [...new Set(reached.map((access) => access.path))];
+        // What came back is the worse of the two routes, so it is what the node names when there is a choice.
+        const worst = reached.find((access) => access.source === 'result')?.path ?? files[0];
+        const asked = askedOf.get(agent.id);
+        const index = model.agents.indexOf(agent);
+        return {
+            index,
+            ...(agent.id === model.sessionId ? {} : { ordinal: delegatedOrder.indexOf(index) + 1 }),
+            ...(agent.type === undefined ? {} : { type: redactor.term(agent.type) }),
+            ...(parentIndex < 0 ? {} : { parentIndex }),
+            label: redactor.term(agent.id === model.sessionId
+                ? 'the session itself'
+                : `${agentName(agent.id, model, view)}${agent.type === undefined ? '' : ` · ${agent.type}`}`),
+            ...(asked === undefined ? {} : { askedTo: redactor.scan(asked) }),
+            actions: model.events.filter((event) => event.agentId === agent.id).length,
+            filesReached: files.length,
+            refusedAttempts: own.filter((access) => access.outcome === 'blocked').length,
+            ...(worst === undefined ? {} : { topPath: redactor.path(worst) }),
+            ...returnedOf(returns, agent.id),
+            ...(uses.some((use) => use.agentId === agent.id && isWrittenOnward(use)) ? { wroteOnward: true } : {}),
+            ...(received.has(agent.id) ? { received: [...new Set([...(received.get(agent.id) ?? [])].map((path) => redactor.path(path)))] } : {}),
+        };
+    };
+    const main = model.agents.find((agent) => agent.id === model.sessionId);
+    return {
+        main: main === undefined
+            ? { index: -1, label: redactor.term('the session itself'), actions: 0, filesReached: 0, refusedAttempts: 0 }
+            : nodeOf(main),
+        agents: model.agents
+            .filter((agent) => agent.id !== model.sessionId)
+            .map(nodeOf)
+            .sort((first, second) => second.filesReached - first.filesReached ||
+            second.refusedAttempts - first.refusedAttempts ||
+            second.actions - first.actions),
+        totalAgents: model.agents.length,
+    };
+}
+/**
+ * X23: read from the declared capabilities, never from the absence of a record. `absent` outranks `unmeasured`: one source
+ * known not to show it settles the question that an unmeasured one leaves open.
+ */
+function coverageOf(model) {
+    const states = new Set(model.capabilities
+        .filter((record) => record.question === 'actions' || record.question === 'access')
+        .map((record) => record.state));
+    return states.has('absent') ? 'absent' : states.has('unmeasured') ? 'unmeasured' : 'complete';
+}
+/**
+ * The answer first. A reader who reads one line should learn whether anything the policy protects was reached,
+ * and should not be left to work that out from a table of 65 rows.
+ */
+function headlineOf(tally, coverage, redactor) {
+    const { filesReached, onlyThroughResult, refusedAttempts, unknownAttempts } = tally;
+    const refused = refusedAttempts === 0 ? '' : `, and ${refusedAttempts} ${refusedAttempts === 1 ? 'attempt was' : 'attempts were'} refused`;
+    // An attempt whose effect is not established is never "nothing was reached", however the rest went (X11).
+    if (filesReached === 0 && unknownAttempts > 0) {
+        return {
+            severity: 'attention',
+            sentence: redactor.term(`No file this policy protects is known to have been reached, but ${unknownAttempts} ` +
+                `${unknownAttempts === 1 ? 'attempt at one has' : 'attempts at them have'} no recorded outcome${refused}.`),
+        };
+    }
+    // X23: a record that does not show every action that ran, or what each reached, is never a clean report - absent and
+    // unmeasured said apart, in `GAP_WORDS`' words.
+    if (filesReached === 0 && coverage !== 'complete') {
+        return {
+            severity: 'attention',
+            sentence: redactor.term('No file this policy protects is known to have been reached, but ' +
+                (coverage === 'absent' ? 'the record does not show everything that ran' : 'whether the record shows everything that ran has not been measured') +
+                `${refused}.`),
+        };
+    }
+    if (filesReached === 0 && refusedAttempts === 0) {
+        return { severity: 'clear', sentence: redactor.term('No file this policy protects was reached in this session.') };
+    }
+    // Every attempt refused: the policy held throughout, which is not the same news as nothing having happened.
+    if (filesReached === 0) {
+        return {
+            severity: 'clear',
+            sentence: redactor.term(`No file this policy protects was reached: ${refusedAttempts} ` +
+                `${refusedAttempts === 1 ? 'attempt was' : 'attempts were'} refused, and nothing else came close.`),
+        };
+    }
+    return {
+        severity: 'attention',
+        sentence: redactor.term(`${filesReached} ${filesReached === 1 ? 'file' : 'files'} this policy protects ` +
+            `${filesReached === 1 ? 'was' : 'were'} reached` +
+            `${onlyThroughResult === 0 ? '' : `, ${onlyThroughResult} of them without any call ever naming ${onlyThroughResult === 1 ? 'it' : 'them'}`}` +
+            `${refusedAttempts === 0 ? '' : `, and ${refusedAttempts} further ${refusedAttempts === 1 ? 'attempt was' : 'attempts were'} refused`}` +
+            `${unknownAttempts === 0 ? '' : `${refusedAttempts === 0 ? ', and' : ';'} ${unknownAttempts} further ${unknownAttempts === 1 ? 'attempt has' : 'attempts have'} no recorded outcome`}.` +
+            returnedClause(tally) +
+            onwardClause(tally)),
+        // Said out loud, because a number that is partly noise and does not say so is worse than no number.
+        caveat: redactor.term('A path named inside a shell command is counted as reached; some of those are mentions rather than openings.'),
+    };
+}
+/**
+ * One line per path and route, carrying the chain: who reached it, what they had been asked to do, and how.
+ * The instruction is the cause - it is the reason this project exists - so it is what the line leads with.
+ */
+function storiesOf(model, accesses, wordsBefore, traced, redactor, view) {
+    const byAgent = new Map(model.agents.map((agent) => [agent.id, agent]));
+    const askedOf = new Map(model.delegations
+        .filter((delegation) => delegation.childAgentId !== undefined && delegation.description !== undefined)
+        .map((delegation) => [delegation.childAgentId ?? '', delegation.description ?? '']));
+    const grouped = new Map();
+    for (const access of accesses) {
+        const key = `${access.path}\u0000${access.source}\u0000${access.agentId}\u0000${access.outcome}`;
+        grouped.set(key, [...(grouped.get(key) ?? []), access]);
+    }
+    return [...grouped.values()]
+        .map((group) => {
+        const access = group[0];
+        const agent = byAgent.get(access.agentId);
+        const asked = askedOf.get(access.agentId);
+        return {
+            ...(agent === undefined ? {} : { agentIndex: model.agents.indexOf(agent) }),
+            path: redactor.path(access.path),
+            source: access.source,
+            outcome: access.outcome,
+            who: access.agentId === model.sessionId
+                ? redactor.term('the session itself')
+                : redactor.term(`${agentName(access.agentId, model, view)}${agent?.type === undefined ? '' : ` (${agent.type})`}`),
+            ...(asked === undefined ? {} : { askedTo: redactor.scan(asked) }),
+            did: redactor.term(didOf(access, model)),
+            toolKnown: model.events.find((event) => event.id === access.eventId)?.toolKnown ?? false,
+            evidence: redactor.term(describeEvidence(access.evidence, model, view)),
+            occurrences: group.length,
+            ...linesTotal(group),
+            wrote: wroteBefore(wordsBefore.get(access.eventId), model, traced, redactor, view),
+        };
+    })
+        .sort((first, second) => rank(first) - rank(second) || second.occurrences - first.occurrences);
+}
+/**
+ * The most serious finding first, and the first one is what a page leads with. An agent that was given an
+ * instruction and reached a file through what came back is the shape of the incident this project was built
+ * from: the instruction explains it, and no call parameter would have shown it.
+ *
+ * A refusal ranks **last**. It is good news, and a page whose first line is good news answers "what happened?"
+ * with the one thing that did not. The refusals are still counted in the tally, badged as the policy holding,
+ * and listed in the table - they are placed, not hidden.
+ */
+function rank(story) {
+    if (story.outcome === 'blocked')
+        return 6;
+    if (story.outcome === 'unknown')
+        return 5;
+    if (story.askedTo !== undefined)
+        return story.source === 'result' ? 0 : 1;
+    return story.source === 'result' ? 2 : 3;
+}
+/** The tool, and for a shell the programs it ran - which is structure. The command text itself stays out (§7.3). */
+function didOf(access, model) {
+    const event = model.events.find((candidate) => candidate.id === access.eventId);
+    return event === undefined ? access.toolName : didOfEvent(event);
+}
+function didOfEvent(event) {
+    // Only programs that could have reached something: naming `echo` beside `grep` says nothing about the file.
+    const programs = [...new Set(event.commands.flatMap(programsIn))]
+        .filter((program) => !NAMES_NOTHING.has(program))
+        .slice(0, 2);
+    return programs.length === 0 ? event.toolName : `${event.toolName} (${programs.join(', ')})`;
+}
+function toolCounts(events) {
+    const counts = {};
+    for (const event of events)
+        counts[event.toolName] = (counts[event.toolName] ?? 0) + 1;
+    return counts;
+}
+function scopeOf(model, policy, redactor, view) {
+    return {
+        // A session id names a run on someone's machine and nothing a reader of a shared report can act on.
+        sessionId: redactor.term(view.share ? 'not shown' : shorten(model.sessionId)),
+        provider: model.provider,
+        policy: {
+            level: redactor.term(policy.level),
+            origin: redactor.term(describeOrigin(policy, redactor)),
+            patterns: policy.protected.length,
+            exceptions: policy.allowed.length,
+        },
+        // A reader weighing "nothing was found" deserves to know what was not looked for. All three match classes
+        // of §5.4 are implemented as of ruleset v2, so the list is empty and the line is not printed.
+        redaction: { ...redactor.summary(), missingClasses: [] },
+        completeness: model.completeness,
+        ...timesOf(model, view),
+        paths: {
+            shared: view.share,
+            root: view.projectRoot.kind,
+            ...(view.projectRoot.kind === 'ambiguous' ? { workingDirectories: view.projectRoot.count } : {}),
+        },
+    };
+}
+/**
+ * M4: the first and the last time any recorded call was written - a span to show, never an order: the earliest and the
+ * latest are read, nothing is sorted by them (architecture invariant 3). A shared report says when nothing happened.
+ */
+function timesOf(model, view) {
+    if (view.share)
+        return {};
+    const times = model.events.flatMap((event) => [event.evidence.at, event.result?.evidence.at]).filter((at) => at !== undefined);
+    return times.length === 0 ? {} : { times: { first: Math.min(...times), last: Math.max(...times) } };
+}
+/** M4: the time a record was written, where it has one and the report may say it - never in a shared report. */
+function atOf(evidence, view) {
+    return view.share || evidence.at === undefined ? {} : { at: evidence.at };
+}
+/**
+ * In words, because "default" printed as a value reads like a decision someone took.
+ *
+ * The file it names is a path on the same machine as every other path in the report, so it goes through the
+ * same door. It used to be concatenated straight in, which left `--share --policy /Users/someone/…` printing
+ * an account name in a report whose whole promise is that it does not.
+ */
+function describeOrigin(policy, redactor) {
+    const { origin } = policy;
+    if (origin.kind === 'file')
+        return `policy file ${redactor.path(origin.path)}`;
+    if (origin.kind === 'settings') {
+        const path = redactor.path(origin.path);
+        return `deny rules of ${path} — ${origin.used} used, ${origin.ignored} ignored as command patterns`;
+    }
+    return 'BUILT-IN DEFAULT — no policy file was given';
+}
+function toDelegation(delegation, model, accesses, redactor, view) {
+    const events = model.events
+        .filter((event) => event.agentId === delegation.childAgentId)
+        .sort((first, second) => first.sequence - second.sequence);
+    const parentAgentIndex = model.agents.findIndex((agent) => agent.id === delegation.parentAgentId);
+    const childAgentIndex = model.agents.findIndex((agent) => agent.id === delegation.childAgentId);
+    return {
+        id: redactor.term(view.share ? `${model.delegations.indexOf(delegation) + 1}` : shorten(delegation.id)),
+        ...(parentAgentIndex < 0 ? {} : { parentAgentIndex }),
+        ...(childAgentIndex < 0 ? {} : { childAgentIndex }),
+        evidence: redactor.term(describeEvidence(delegation.evidence, model, view)),
+        ...(delegation.requestedType === undefined ? {} : { agentType: redactor.term(delegation.requestedType) }),
+        ...(delegation.depth === undefined ? {} : { depth: delegation.depth }),
+        // §7.3: the full text of a prompt does not go into a report. The short description does, scanned, and the
+        // instruction is reported by its size. Quoting the fragment a finding rests on needs a finding to rest on,
+        // and that is the detector's - until then, a report that quoted everything would be the leak it warns about.
+        ...(delegation.description === undefined ? {} : { description: redactor.scan(delegation.description) }),
+        ...(delegation.prompt === undefined ? {} : { instructionSize: delegation.prompt.length }),
+        laterInstructions: delegation.followUps.map((followUp) => ({
+            size: followUp.text.length,
+            evidence: redactor.term(describeEvidence(followUp.evidence, model, view)),
+        })),
+        actions: events.map((event) => toAction(event, model, accesses, redactor, view)),
+        completeness: delegation.completeness,
+    };
+}
+/** An agent nobody can say was asked for. Its actions are still evidence, so they are shown. */
+function toAgent(agent, model, accesses, redactor, view) {
+    return {
+        agentIndex: model.agents.indexOf(agent),
+        id: redactor.term(agentName(agent.id, model, view)),
+        ...(agent.type === undefined ? {} : { type: redactor.term(agent.type) }),
+        ...(agent.depth === undefined ? {} : { depth: agent.depth }),
+        actions: model.events
+            .filter((event) => event.agentId === agent.id)
+            .sort((first, second) => first.sequence - second.sequence)
+            .map((event) => toAction(event, model, accesses, redactor, view)),
+    };
+}
+function toAction(event, model, accesses, redactor, view) {
+    const touched = accesses.find((access) => access.eventId === event.id);
+    return {
+        sequence: event.sequence,
+        tool: redactor.term(event.toolName),
+        outcome: event.outcome,
+        // What the call was pointed at: the protected path when there was one, and otherwise nothing - the full
+        // parameters are transcript content and do not belong in a report (§7.3).
+        ...(touched === undefined ? {} : { target: redactor.path(touched.path) }),
+        evidence: redactor.term(describeEvidence(event.evidence, model, view)),
+        ...atOf(event.evidence, view),
+    };
+}
+/** H10: how many lines of one file a group of calls printed, or nothing where none did. */
+function linesTotal(group) {
+    const total = group.reduce((sum, access) => sum + (access.lines ?? 0), 0);
+    return total === 0 ? {} : { lines: total };
+}
+/** H5: the files of one call whose lines a search printed, with how many - redacted, as every path of a step is. */
+function linesIn(group, redactor) {
+    const printed = group.filter((access) => (access.lines ?? 0) > 0).map((access) => ({ path: redactor.path(access.path), count: access.lines }));
+    return printed.length === 0 ? {} : { lines: printed };
+}
+function toFinding(access, model, redactor, view, told) {
+    return {
+        path: redactor.path(access.path),
+        source: access.source,
+        outcome: access.outcome,
+        tool: redactor.term(access.toolName),
+        pattern: redactor.term(access.pattern),
+        evidence: redactor.term(describeEvidence(access.evidence, model, view)),
+        ...(told ? { told: true } : {}),
+    };
+}
+/**
+ * R11: the headline carries the strongest fact. A value that came back is stronger than the reach it follows; failing
+ * that, a value an agent wrote into its own messages is, because the session's transcript now keeps it - which is all
+ * the motivating case's transcript records of its incident. A path or a report that came back is weaker than the
+ * reach already said, so it changes nothing here.
+ */
+function returnedClause(tally) {
+    const { valuesReturned, valuesWritten } = tally;
+    if (valuesReturned === 1)
+        return " An agent's answer carried a value from one of them back to the agent that started it.";
+    if (valuesReturned > 1) {
+        return ` In ${valuesReturned} delegations, an agent's answer carried a value from one of them back to the agent that started it.`;
+    }
+    if (valuesWritten === 1) {
+        return " An agent wrote a value from one of them into its own messages, which the session's transcript now keeps.";
+    }
+    if (valuesWritten > 1) {
+        return ` Agents in ${valuesWritten} delegations wrote a value from one of them into their own messages, which the session's transcript now keeps.`;
+    }
+    return '';
+}
+/**
+ * where-the-value-went R11: a value put into a file that is not protected leads. Uses in words, commands, prompts and
+ * other calls do not change the headline, and neither does a write into a protected file - editing configuration.
+ */
+function onwardClause({ filesWrittenOnward, valuesReturned }) {
+    if (filesWrittenOnward === 0)
+        return '';
+    // After a value came back the sentence before names it, and "the same value" is the plainer way to say it again.
+    const subject = valuesReturned > 0 ? 'The same value' : 'A value from one of them';
+    return filesWrittenOnward === 1
+        ? ` ${subject} was also written into a file that is not protected.`
+        : ` ${subject} was also written into ${filesWrittenOnward} files that are not protected.`;
+}
+function isWrittenOnward(use) {
+    return use.landed === 'file' && use.intoProtected !== true;
+}
+/** R7: an agent's own words, of either kind - the words the transcript keeps whether or not anything came back. */
+function isInOwnWords(use) {
+    return use.landed === 'said' || use.landed === 'reasoning';
+}
+/** R9: where the value landed crosses the boundary; the value, the words and the command line never do. */
+function toUse(use, model, redactor, view) {
+    const agentIndex = model.agents.findIndex((agent) => agent.id === use.agentId);
+    const paths = (list) => [...new Set(list.map((path) => redactor.path(path)))];
+    return {
+        ...(agentIndex < 0 ? {} : { agentIndex }),
+        files: paths(use.files),
+        ...(use.fileUncertain === true ? { fileUncertain: true } : {}),
+        landed: use.landed,
+        ...(use.targets === undefined ? {} : { targets: paths(use.targets), intoProtected: use.intoProtected === true }),
+        ...(use.programs === undefined ? {} : { programs: use.programs.map((program) => redactor.term(program)), commits: use.commits === true }),
+        source: use.source,
+        ...(use.sourceTargets === undefined ? {} : { sourceTargets: paths(use.sourceTargets) }),
+        evidence: redactor.term(describeEvidence(use.evidence, model, view)),
+    };
+}
+/** The strongest of what came back from this agent, and whether it wrote a value that did not, for its node (R12). */
+function returnedOf(returns, agentId) {
+    const own = returns.filter((entry) => entry.agentId === agentId);
+    const returned = own.some((entry) => entry.strength === 'value')
+        ? 'value'
+        : own.some((entry) => entry.strength === 'path')
+            ? 'path'
+            : undefined;
+    const wrote = returned !== 'value' && own.some((entry) => entry.writtenFrom.length > 0);
+    return { ...(returned === undefined ? {} : { returned }), ...(wrote ? { wroteValue: true } : {}) };
+}
+/** A return across the redaction boundary: files through the path door, agents by index, and no text of it (R10). */
+function toReturn(entry, model, redactor, view) {
+    const agentIndex = model.agents.findIndex((agent) => agent.id === entry.agentId);
+    const parentAgentIndex = model.agents.findIndex((agent) => agent.id === entry.parentAgentId);
+    return {
+        ...(agentIndex < 0 ? {} : { agentIndex }),
+        ...(parentAgentIndex < 0 ? {} : { parentAgentIndex }),
+        strength: entry.strength,
+        // Two files outside the project are one category in the shared view, and saying it twice says nothing more.
+        paths: [...new Set(entry.paths.map((path) => redactor.path(path)))],
+        writtenFrom: [...new Set(entry.writtenFrom.map((path) => redactor.path(path)))],
+        ...(entry.fileUncertain === true ? { fileUncertain: true } : {}),
+        filesReached: entry.filesReached,
+        ...(entry.reportLength === undefined ? {} : { reportLength: entry.reportLength }),
+        ...(entry.awaited === true ? { awaited: true } : {}),
+        evidence: redactor.term(describeEvidence(entry.evidence, model, view)),
+    };
+}
+/**
+ * What could not be established, counted by kind. R9: a return that could not be read is a gap, and is said among the
+ * others - apart from one that was never delivered (where-the-value-went R5), since "could not be read" would name the
+ * wrong cause.
+ */
+function gapsOf(gaps, returns) {
+    const counted = new Map();
+    for (const gap of gaps) {
+        // A capability gap is counted with its question: "the record does not say which actions ran" is a different gap
+        // from "... what reached the AI", and one count for both would say neither.
+        const key = gap.kind + ' ' + (gap.question ?? '');
+        const known = counted.get(key);
+        counted.set(key, { kind: gap.kind, ...(gap.question === undefined ? {} : { question: gap.question }), count: (known?.count ?? 0) + 1 });
+    }
+    const unknown = returns.filter((entry) => entry.strength === 'unknown');
+    const awaited = unknown.filter((entry) => entry.awaited === true).length;
+    const unreadable = unknown.length - awaited;
+    return [
+        ...counted.values(),
+        ...(unreadable === 0 ? [] : [{ kind: 'answer-unread', count: unreadable }]),
+        ...(awaited === 0 ? [] : [{ kind: 'answer-awaited', count: awaited }]),
+    ];
+}
+function missingWords(gap) {
+    if (gap.kind === 'answer-unread')
+        return `${gap.count} × an agent's answer could not be read, so what was in it is unknown`;
+    if (gap.kind === 'answer-awaited')
+        return `${gap.count} × an agent ran in the background and its answer never arrived, so what was in it is unknown`;
+    const words = gap.question === undefined ? GAP_WORDS[gap.kind] : `${GAP_WORDS[gap.kind]}: ${QUESTION_WORDS[gap.question]}`;
+    return `${gap.count} × ${words}`;
+}
+function countOutcomes(events) {
+    return {
+        succeeded: events.filter((event) => event.outcome === 'succeeded').length,
+        blocked: events.filter((event) => event.outcome === 'blocked').length,
+        unknown: events.filter((event) => event.outcome === 'unknown').length,
+    };
+}
+function describeEvidence(evidence, model, view) {
+    const { source } = evidence;
+    const where = source.kind === 'main'
+        ? 'session'
+        : source.kind === 'agent'
+            ? `agent ${agentName(source.agentId, model, view)}`
+            // A reviewer is no agent of the session: it is named by its place among the reviews, never by its id (X19).
+            : `review ${model.reviews.findIndex((review) => review.id === source.reviewId) + 1}`;
+    return `${where} record ${evidence.record}`;
+}
+/**
+ * How an agent is named. Shortened in the full view; in the shared one, the position it already occupies on the
+ * page (R6). An identifier names a run on someone's machine, an ordinal names a row in this report - and the
+ * ordinal is what a reader is pointing at anyway when they say "agent 6".
+ */
+function agentName(id, model, view) {
+    if (!view.share)
+        return shorten(id);
+    const index = model.agents.findIndex((agent) => agent.id === id);
+    // An agent the report does not hold is still an agent: saying so beats printing an id or printing nothing.
+    return index < 0 ? 'not in this report' : `${index}`;
+}
+function shorten(identifier) {
+    if (identifier.length <= SHORTEN_ABOVE)
+        return identifier;
+    return `${identifier.slice(0, HEAD)}…${identifier.slice(-TAIL)}`;
+}
+const FIRST = Number.MIN_SAFE_INTEGER;
+const LAST = Number.MAX_SAFE_INTEGER;
+/**
+ * Every agent's flow (`specs/2026-09-15-agent-flow.md` R1-R6): what it did with protected files and values, in the order
+ * of its own records, with consecutive steps that say the same thing collapsed (R3, §5.1). Built here, before the
+ * boundary, because the order lives in records a renderer never sees. A delegation is a step that names another agent;
+ * no step of one agent is ever placed among another's.
+ */
+function flowsOf(model, accesses, uses, returns, wordsBefore, traced, redactor, view) {
+    const events = new Map(model.events.map((event) => [event.id, event]));
+    const indexOf = (agentId) => {
+        const index = model.agents.findIndex((agent) => agent.id === agentId);
+        return index < 0 ? undefined : index;
+    };
+    const paths = (list) => [...new Set(list.map((path) => redactor.path(path)))];
+    const raw = new Map();
+    const push = (agentId, step) => {
+        const list = raw.get(agentId);
+        if (list === undefined)
+            raw.set(agentId, [step]);
+        else
+            list.push(step);
+    };
+    // A call that reached, or was refused, a protected file - one step for the call and each outcome its files had. X11: a
+    // search whose own outcome is unknown reached what it printed, and only attempted the rest, so one outcome for the
+    // whole call would say the tally's "reached" of none of them. The established step comes first, so a use after the
+    // call's result follows it.
+    const byEvent = new Map();
+    for (const access of accesses)
+        byEvent.set(access.eventId, [...(byEvent.get(access.eventId) ?? []), access]);
+    const byOutcome = [...byEvent].flatMap(([eventId, all]) => OUTCOME_ORDER.map((outcome) => [eventId, outcome, all.filter((access) => access.outcome === outcome)])
+        .filter(([, , group]) => group.length > 0));
+    for (const [eventId, outcome, group] of byOutcome) {
+        const event = events.get(eventId);
+        const first = group[0];
+        if (event === undefined || first === undefined)
+            continue;
+        const files = [...new Set(group.map((access) => access.path))].sort();
+        const sources = [...new Set(group.map((access) => access.source))].sort();
+        const did = didOf(first, model);
+        // Repeats merge into their first call, so a search that printed lines is never merged into one that printed names.
+        const printed = group.filter((access) => access.lines !== undefined).map((access) => `${access.path}=${access.lines}`).sort();
+        push(event.agentId, {
+            at: event.evidence.record,
+            signature: ['reached', did, sources.join(','), outcome, files.join(','), printed.join(',')].join('\u0000'),
+            keys: event.result === undefined ? [] : [`result ${event.result.evidence.record}`],
+            evidence: event.evidence,
+            build: (common) => ({
+                ...common,
+                ...(outcome === 'unknown' ? { broken: true } : {}),
+                kind: 'reached',
+                did: redactor.term(did),
+                toolKnown: event.toolKnown,
+                files: paths(files),
+                sources,
+                outcome,
+                // X10: a value in what a process printed is in the record, not in the agent's context, until something shows it was
+                // handed to the agent's model.
+                carriedValue: event.result?.content !== undefined && event.result.stage === 'model' && traced.trace.foundIn(event.result.content).size > 0,
+                ...linesIn(group, redactor),
+                viaCommand: event.commands.length > 0,
+                ...(event.result !== undefined && event.result.stage !== 'model' ? { processOutput: true } : {}),
+                wrote: wroteBefore(wordsBefore.get(eventId), model, traced, redactor, view),
+            }),
+        });
+    }
+    // X10: output an agent's model was handed that no call of its returned, holding a value from a protected file - the
+    // agent read that file, and the step names no call it came from, since the record joins it to none.
+    for (const delivery of model.deliveries) {
+        if (delivery.status !== 'confirmed')
+            continue;
+        const files = filesTracedIn([delivery.text], traced).sort();
+        if (files.length === 0)
+            continue;
+        push(delivery.recipientAgentId, {
+            at: delivery.evidence.record,
+            signature: ['received', files.join(',')].join('\u0000'),
+            keys: [],
+            evidence: delivery.evidence,
+            build: (common) => ({ ...common, kind: 'received', files: paths(files) }),
+        });
+    }
+    // A result that reached nothing protected, but carried a value a use came after (where-the-value-went R8).
+    const carried = new Set();
+    for (const use of uses) {
+        if (use.source !== 'unprotected' || use.sourceRecord === undefined)
+            continue;
+        const record = use.sourceRecord;
+        if (carried.has(`${use.agentId} ${record}`))
+            continue;
+        carried.add(`${use.agentId} ${record}`);
+        const event = model.events.find((candidate) => candidate.agentId === use.agentId && candidate.result?.evidence.record === record);
+        if (event === undefined)
+            continue;
+        push(use.agentId, {
+            at: record,
+            signature: `carried ${record}`,
+            keys: [`result ${record}`],
+            evidence: event.result?.evidence ?? event.evidence,
+            build: (common) => ({ ...common, kind: 'carried', did: redactor.term(didOfEvent(event)), named: paths(event.targets) }),
+        });
+    }
+    for (const use of uses) {
+        const sourceKey = use.source === 'returned'
+            ? `delegation ${use.sourceDelegationId ?? ''}`
+            : use.sourceRecord === undefined ? undefined : `result ${use.sourceRecord}`;
+        const onto = use.targets ?? [];
+        push(use.agentId, {
+            at: use.evidence.record,
+            signature: ['used', use.landed, use.files.join(','), onto.join(','), String(use.intoProtected === true), use.source, sourceKey ?? ''].join('\u0000'),
+            keys: [],
+            evidence: use.evidence,
+            ...(use.programs === undefined ? {} : { programs: use.programs }),
+            ...(use.commits === undefined ? {} : { commits: use.commits }),
+            build: (common, merged, afterOf) => {
+                const after = sourceKey === undefined ? undefined : afterOf(sourceKey);
+                return {
+                    ...common,
+                    kind: 'used',
+                    landed: use.landed,
+                    files: paths(use.files),
+                    ...(use.fileUncertain === true ? { fileUncertain: true } : {}),
+                    ...(use.targets === undefined ? {} : { targets: paths(use.targets), intoProtected: use.intoProtected === true }),
+                    ...(use.landed === 'command' ? { programs: merged.programs.map((program) => redactor.term(program)), commits: merged.commits } : {}),
+                    source: use.source,
+                    ...(after === undefined ? {} : { after }),
+                };
+            },
+        });
+    }
+    for (const entry of returns) {
+        const delegation = model.delegations.find((candidate) => candidate.id === entry.delegationId);
+        const child = indexOf(entry.agentId);
+        const parent = indexOf(entry.parentAgentId);
+        const came = {
+            strength: entry.strength,
+            ...(entry.awaited === true ? { awaited: true } : {}),
+            ...(entry.inferred === true ? { inferred: true } : {}),
+            ...(entry.inferred === true ? { inferred: true } : {}),
+            files: paths(entry.strength === 'value' || entry.strength === 'path' ? entry.paths : []),
+            ...(entry.strength === 'unknown' ? { broken: true } : {}),
+        };
+        push(entry.parentAgentId, {
+            at: delegation?.evidence.record ?? entry.evidence.record,
+            signature: `delegated ${entry.delegationId}`,
+            keys: [`delegation ${entry.delegationId}`],
+            evidence: delegation?.evidence ?? entry.evidence,
+            build: (common) => ({ ...common, ...came, kind: 'delegated', ...(child === undefined ? {} : { toAgentIndex: child }) }),
+        });
+        push(entry.agentId, {
+            at: LAST,
+            signature: `returned ${entry.delegationId}`,
+            keys: [],
+            evidence: entry.evidence,
+            build: (common) => ({ ...common, ...came, kind: 'returned', ...(parent === undefined ? {} : { toAgentIndex: parent }) }),
+        });
+    }
+    for (const delegation of model.delegations) {
+        if (delegation.childAgentId === undefined)
+            continue;
+        const parent = indexOf(delegation.parentAgentId);
+        push(delegation.childAgentId, {
+            at: FIRST,
+            signature: `asked ${delegation.id}`,
+            keys: [],
+            evidence: delegation.evidence,
+            alone: true,
+            build: (common) => ({
+                ...common,
+                kind: 'asked',
+                ...(parent === undefined ? {} : { byAgentIndex: parent }),
+                ...(delegation.description === undefined ? {} : { askedTo: redactor.scan(delegation.description) }),
+            }),
+        });
+    }
+    return model.agents.flatMap((agent, agentIndex) => {
+        const steps = [...(raw.get(agent.id) ?? [])].sort((first, second) => first.at - second.at);
+        if (steps.every((step) => step.alone === true))
+            return [];
+        const groups = [];
+        for (const step of steps) {
+            const previous = groups.at(-1);
+            if (previous !== undefined && previous.first.signature === step.signature) {
+                previous.last = step;
+                previous.count += 1;
+                for (const program of step.programs ?? [])
+                    previous.programs.add(program);
+                previous.commits = previous.commits || step.commits === true;
+                previous.keys.push(...step.keys);
+            }
+            else {
+                groups.push({ first: step, last: step, count: 1, programs: new Set(step.programs ?? []), commits: step.commits === true, keys: [...step.keys] });
+            }
+        }
+        const numbers = new Map();
+        groups.forEach((group, index) => {
+            for (const key of group.keys)
+                if (!numbers.has(key))
+                    numbers.set(key, index + 1);
+        });
+        const recordOf = (step) => redactor.term(describeEvidence(step.evidence, model, view));
+        return [{
+                agentIndex,
+                steps: groups.map((group, index) => group.first.build({
+                    number: index + 1,
+                    count: group.count,
+                    evidence: group.count > 1 ? [recordOf(group.first), recordOf(group.last)] : [recordOf(group.first)],
+                    ...atOf(group.first.evidence, view),
+                }, { programs: [...group.programs], commits: group.commits }, (key) => numbers.get(key))),
+            }];
+    });
+}