humanish 0.135.0 → 0.136.0

package/dist/run/locate.js

@@ -1,7 +1,7 @@
 import path from "node:path";
 import { bindExistingRunArtifactPaths, isSafeRunIdSegment, resolveExistingRunDirectory, resolveLatestRunDirectory, RUNS_RELATIVE_ROOT, validatePreparedRunArtifactPaths, } from "./paths.js";
 import { assertPreparedSelectedOutputDirectory, bindExistingManagedHumanishOutputDirectory, ContainedReadRefusedError, LATEST_POINTER_MAX_BYTES, readContainedRegularFile, RUN_ARTIFACT_MAX_BYTES, } from "./contained-output.js";
-import { RUN_BUNDLE_FILE } from "./bundle.js";
+import { RUN_BUNDLE_FILE, } from "./bundle.js";
 import { isRunBundle, isRunPointer } from "./bundle-shape.js";
 import { displayedTraces, loadRunTraces, loadStreamTraces } from "./stream-trace.js";
 import { readUnchangedFile } from "./evidence-files.js";
@@ -119,29 +119,36 @@ export async function loadRunBundle(cwdInput, runInput) {
     }
     return loadRunBundlePrepared(cwd, runPaths);
 }
+/** loadRunBundle for a caller that already holds prepared paths. Revalidates them first. */
+export async function loadRunBundlePrepared(cwdInput, runPaths) {
+    const run = await readPreparedRunJson(cwdInput, runPaths);
+    // A trace that does not match its index throws StreamTraceRefusedError, naming the participant.
+    return run === null ? null : { ...run, bundle: await loadRunTraces(runPaths, run.bundle) };
+}
 /**
- * loadRunBundle for a caller that already holds prepared paths. Revalidates them first. With
- * `display`, a participant whose trace the loader refuses, such as one past the read limit, is
- * kept as displayedTraces shows it, for a page that shows the run.
+ * loadRunBundlePrepared for a page that shows the run: a participant whose trace the loader
+ * refuses, such as one past the read limit, is kept as displayedTraces shows it.
  */
-export async function loadRunBundlePrepared(cwdInput, runPaths, options = {}) {
+export async function loadDisplayedRunBundle(cwdInput, runPaths) {
+    const run = await readPreparedRunJson(cwdInput, runPaths);
+    if (run === null)
+        return null;
+    return { ...run, bundle: displayedTraces(await loadStreamTraces(runPaths, run.bundle)) };
+}
+/** The prepared run's run.json when it is a run bundle, after revalidating the paths; else null. */
+async function readPreparedRunJson(cwdInput, runPaths) {
     const cwd = path.resolve(cwdInput);
     await validatePreparedRunArtifactPaths(runPaths);
-    const bundlePath = path.join(runPaths.absoluteRunRoot, RUN_BUNDLE_FILE);
     const read = await readRunJsonIfExists(runPaths, RUN_BUNDLE_FILE);
     // A run.json it refuses is no reason to call the run absent: the caller reports why.
     if (read.status === "refused")
         throw new ContainedReadRefusedError(RUN_BUNDLE_FILE, read);
     const bundle = read.status === "read" ? read.value : null;
-    if (!isRunBundle(bundle)) {
+    if (!isRunBundle(bundle))
         return null;
-    }
     return {
-        // A trace that does not match its index throws StreamTraceRefusedError, naming the participant.
-        bundle: options.display === true
-            ? displayedTraces(await loadStreamTraces(runPaths, bundle))
-            : await loadRunTraces(runPaths, bundle),
-        bundlePath: path.relative(cwd, bundlePath),
+        bundle,
+        bundlePath: path.relative(cwd, path.join(runPaths.absoluteRunRoot, RUN_BUNDLE_FILE)),
         runDir: runPaths.absoluteRunRoot,
     };
 }

package/dist/run/paths.js

@@ -1,5 +1,6 @@
 import { lstat, mkdir, readdir, realpath, rmdir } from "node:fs/promises";
 import path from "node:path";
+import { mapWithConcurrency } from "./concurrency.js";
 import { isNodeError } from "./type-guards.js";
 export const RUNS_RELATIVE_ROOT = path.join(".humanish", "runs");
 const LATEST_RUN_RELATIVE_PATH = path.join(RUNS_RELATIVE_ROOT, "latest.json");
@@ -262,35 +263,44 @@ export async function assertRegularFileOrMissing(filePath, subject = "humanish s
         throw error;
     }
 }
-async function assertNoSymlinkDescendants(directory) {
-    const entries = await readdir(directory, { withFileTypes: true });
-    for (const entry of entries) {
-        const child = path.join(directory, entry.name);
-        // A run directory can be written concurrently with this walk: the atomic writer creates a
-        // `.humanish-write-*.tmp` sibling and renames it, and a run now also refreshes its own status
-        // record on a cadence. An entry that vanished between readdir and lstat therefore proves
-        // nothing except that it is gone, and a path that no longer exists cannot be a symlink escape:
-        // skip it rather than failing the containment check on a benign race.
-        let stats;
-        try {
-            stats = await lstat(child);
-        }
-        catch (error) {
-            if (isNodeError(error) && error.code === "ENOENT") {
-                continue;
-            }
-            throw error;
-        }
-        if (stats.isSymbolicLink()) {
-            throw new Error("humanish run directories must not contain symbolic links.");
-        }
-        if (stats.isDirectory()) {
-            await assertNoSymlinkDescendants(child);
-        }
-        else if (!stats.isFile() || stats.nlink > 1) {
-            throw new Error("humanish run leaves must be single-link regular files, not hardlinks or special files.");
-        }
+// Entries the storage check lists or lstats at once. A run folder holds one entry per screenshot,
+// about 70,000 for 24 participants working 8 hours, and one call at a time left the process idle
+// between calls.
+const STORAGE_CHECK_CONCURRENCY = 32;
+/** Every entry under `root` is a directory or a single-link regular file, checked a level at a time. */
+async function assertNoSymlinkDescendants(root) {
+    let directories = [root];
+    while (directories.length > 0) {
+        const listed = await mapWithConcurrency(directories, STORAGE_CHECK_CONCURRENCY, async (dir) => (await readdir(dir, { withFileTypes: true })).map((entry) => path.join(dir, entry.name)));
+        const children = listed.flat();
+        const kinds = await mapWithConcurrency(children, STORAGE_CHECK_CONCURRENCY, storageEntryKind);
+        directories = children.filter((_, index) => kinds[index] === "directory");
+    }
+}
+async function storageEntryKind(child) {
+    // A run directory can be written concurrently with this walk: the atomic writer creates a
+    // `.humanish-write-*.tmp` sibling and renames it, and a run also refreshes its own status record
+    // on a cadence. An entry that vanished between readdir and lstat therefore proves nothing except
+    // that it is gone, and a path that no longer exists cannot be a symlink escape: skip it rather
+    // than failing the containment check on a benign race.
+    let stats;
+    try {
+        stats = await lstat(child);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT")
+            return "gone";
+        throw error;
+    }
+    if (stats.isSymbolicLink()) {
+        throw new Error("humanish run directories must not contain symbolic links.");
+    }
+    if (stats.isDirectory())
+        return "directory";
+    if (!stats.isFile() || stats.nlink > 1) {
+        throw new Error("humanish run leaves must be single-link regular files, not hardlinks or special files.");
     }
+    return "file";
 }
 async function capturePreparedRunArtifactPaths(paths, runRoot) {
     const physicalRunRoot = await realpath(runRoot);

package/dist/run/stream-trace.d.ts

@@ -1,4 +1,4 @@
-import { type RunBundle, type StoredRunBundle } from "./bundle.js";
+import { type DisplayedRunBundle, type RunBundle, type StoredRunBundle } from "./bundle.js";
 import { type PreparedOutputRoot } from "./contained-output.js";
 import { type LiveItemsCursor } from "./live-items.js";
 import type { LiveItemsIndex, RunStream, StoredRunStream, WithoutRequestLists } from "./streams.js";
@@ -131,7 +131,7 @@ export declare function displayedTraces(loaded: {
     bundle: RunBundle;
     refused: readonly StreamTraceRefusedError[];
     live?: readonly LiveItemsRead[];
-}): RunBundle;
+}): DisplayedRunBundle;
 /**
  * What `reduce` returns for each stream of the bundle, loaded as loadRunTraces loads it, in stream
  * order; the first refusal throws. Streams are loaded one at a time and nothing of a stream's files

package/dist/run/stream-trace.js

@@ -178,7 +178,7 @@ function containedReader(runPaths) {
 }
 /**
  * The stream from the bytes of its trace file: its actor with the file's items, and its artifacts
- * followed by the file's screenshot entries, without the index.
+ * followed by the file's screenshot entries, without the index. Its live actor is as it was.
  */
 function joinTrace(stream, bytes) {
     const index = stream.trace;
@@ -246,12 +246,19 @@ function assertIndex(stream) {
         throw new StreamTraceRefusedError(stream.id, "run.json holds items beside its trace index");
 }
 /**
- * A stream of run.json typed as a loaded one, for the streams the loader joins no trace into: one
- * without an index, which v1 wrote with its actor's lists, and a refused one, kept as run.json
- * holds it. From v4 a refused stream's actor has none of the lists, and its `conversation` lacks
- * the `requests` ActorTrace declares; the loader's `refused` names each such stream.
+ * The joined stream as a loaded one, once its actor's conversation, if any, holds the requests
+ * list ActorTrace types as present. The writer writes the list with every conversation, in
+ * run.json before v4 and in the trace file from v4, so a stream without it was edited, and a reader
+ * that counts the requests would throw. Items a v1 run.json or a humanish.live-actor.v1 live actor
+ * holds inline are taken as they are.
  */
-const unjoined = (stream) => stream;
+function asLoaded(stream) {
+    const conversation = stream.actor?.conversation;
+    if (conversation !== undefined &&
+        !(isRecord(conversation) && Array.isArray(conversation.requests)))
+        throw new StreamTraceRefusedError(stream.id, "its actor records a conversation without the requests list");
+    return stream;
+}
 /** A live actor whose items run.json holds inline: humanish.live-actor.v1, or one with no schema. */
 const isInlineLiveActor = (live) => live.schema === LIVE_ACTOR_V1_SCHEMA || live.schema === undefined;
 /** A live file that could not be read, which a writer that moved on may have removed. */
@@ -345,7 +352,7 @@ async function readLiveTail(read, stream, index, after) {
  */
 async function readStreamTrace(read, stream, maxBytes, liveAfter) {
     const files = [];
-    let joined = unjoined(stream);
+    let joined = stream;
     if (stream.trace !== undefined) {
         assertIndex(stream);
         if (stream.trace.bytes > maxBytes)
@@ -359,7 +366,11 @@ async function readStreamTrace(read, stream, maxBytes, liveAfter) {
     const live = await readLiveItems(read, joined, maxBytes, liveAfter);
     if (live.file !== undefined)
         files.push(live.file);
-    return { stream: live.stream, files, ...(live.read === undefined ? {} : { live: live.read }) };
+    return {
+        stream: asLoaded(live.stream),
+        files,
+        ...(live.read === undefined ? {} : { live: live.read }),
+    };
 }
 /**
  * The stream as a v1 run.json held it: its actor with every item and every artifact entry. A
@@ -500,7 +511,9 @@ async function loadEveryStream(read, bundle, maxBytes, liveAfter) {
             if (!(error instanceof StreamTraceRefusedError))
                 throw error;
             refused.push(error);
-            streams.push(unjoined(stream));
+            // Kept as run.json holds it, typed as loaded: from v2 its actor has no items, and from v4
+            // none of the lists. The loader's `refused` names it, and displayedTraces shows it so.
+            streams.push(stream);
         }
     }
     return { bundle: { ...bundle, streams }, refused, files, live };
@@ -523,12 +536,12 @@ export function displayedTraces(loaded) {
         if (reason === undefined)
             return stream;
         const { liveActor: _live, trace: _index, actor, ...rest } = stream;
-        return unjoined({
+        return {
             ...rest,
             ...(actor === undefined ? {} : { actor: { ...withoutRequestLists(actor), items: [] } }),
             artifacts: stream.artifacts.filter((artifact) => !isScreenshot(artifact)),
             traceUnavailable: reason,
-        });
+        };
     });
     const events = loaded.bundle.streams
         .filter((stream) => reasons.has(stream.id))

package/dist/run/streams.d.ts

@@ -327,11 +327,26 @@ export type WithoutRequestLists<T> = Omit<T, "providerRequests" | "tokenUsage" |
     [K in "conversation" & keyof T]?: Omit<NonNullable<T[K]>, "requests"> | undefined;
 };
 /**
- * A stream as run.json holds it, in any version: its actor and live actor WithoutRequestLists.
- * loadStreamTraces joins the lists from the trace file.
+ * `T` WithoutRequestLists and with `items` optional: a v1 run.json holds the items inline, and from
+ * v2 (an actor) or v3 (a live actor) a file holds them.
+ */
+type StoredTrace<T extends {
+    items: unknown;
+}> = WithoutRequestLists<Omit<T, "items">> & Partial<Pick<T, "items">>;
+/**
+ * A stream as run.json holds it, in any version: its actor and live actor without the per-request
+ * lists, and with items only in a v1 run.json. loadStreamTraces joins both from the files.
  */
 export type StoredRunStream = Omit<RunStream, "actor" | "liveActor"> & {
+    actor?: StoredTrace<ActorTrace>;
+    liveActor?: StoredTrace<NonNullable<RunStream["liveActor"]>>;
+};
+/**
+ * A stream as a reader that shows the run has it (displayedTraces in src/run/stream-trace.ts):
+ * loaded, or with `traceUnavailable` when the loader refused its trace. A refused stream's actor
+ * keeps run.json's summary, which from v4 has none of the per-request lists, so the type has none.
+ */
+export type DisplayedRunStream = Omit<RunStream, "actor"> & {
     actor?: WithoutRequestLists<ActorTrace>;
-    liveActor?: WithoutRequestLists<NonNullable<RunStream["liveActor"]>>;
 };
 export {};

package/dist/study/bundle-estimate.d.ts

@@ -1,6 +1,9 @@
 import type { DwellWindow } from "../actors/stop-conditions.js";
 import type { ParticipantSchedule } from "./arrivals.js";
-/** One participant as the plan has it: its schedule, its dwell window and its mission. */
+/**
+ * One participant as the plan has it: its schedule, its dwell window, its mission and instruction,
+ * and its task goals.
+ */
 export interface EstimatedParticipant {
     readonly schedule: ParticipantSchedule;
     readonly limits: {
@@ -8,8 +11,22 @@ export interface EstimatedParticipant {
     };
     readonly assignment: {
         readonly mission?: string;
+        readonly focus?: string;
     };
+    readonly tasks?: readonly {
+        readonly goal: string;
+    }[];
 }
+/**
+ * The study fields run.json copies into each participant's stream, and the advice to shorten each.
+ * The plan does not keep which form declared the participants, so the advice names both paths.
+ */
+declare const COPIED_FIELDS: Readonly<{
+    mission: "shorten the mission (actor.mission)";
+    focus: "shorten the participants' instructions (participants.instruction or participants[].instruction)";
+    tasks: "shorten the task goals (actor.tasks[].goal)";
+}>;
+type CopiedField = keyof typeof COPIED_FIELDS;
 /** A run's estimated bundle, and the scan's limit for its participants. */
 export interface BundleEstimate {
     /** run.json, which analysis reads whole. */
@@ -34,6 +51,8 @@ export interface BundleEstimate {
         readonly open: number;
         readonly openMs: number;
         readonly dwell: boolean;
+        /** The copied field with the most bytes over all participants, when one has any. */
+        readonly largestField?: CopiedField;
     };
 }
 /**
@@ -51,3 +70,4 @@ export declare function estimateBundle(participants: readonly EstimatedParticipa
 export declare function bundleLimitReason(estimate: BundleEstimate): string | undefined;
 /** The estimate beside the limits, for `study check`. */
 export declare function describeBundle(estimate: BundleEstimate): string;
+export {};

package/dist/study/bundle-estimate.js

@@ -7,12 +7,16 @@
 // observer/index.html carries every participant's items gzipped, so with busy participants it
 // passes verify's 32 MiB long before run.json passes analysis's 16 MiB: at these rates, 20
 // participants working 8 hours. From run bundle v4 run.json grows by participant, not by model
-// request: each participant's per-request lists are only in its trace. run.json holds the mission
-// once for the run, once in each participant's stream and once more in the feedback candidate of
-// each participant that reports friction or stops. The mission is not capped, and the estimate
-// counts that last copy for every participant, so it warns at 100 participants with a mission of
-// 75,238 bytes. On 2026-10-13 the longest mission on the live computer-use runs kept on the
-// maintainer's machine was 807 characters.
+// request: each participant's per-request lists are only in its trace. run.json holds each
+// participant's text, its mission, its instruction and its task goals, in its stream and again in
+// the feedback candidate of a participant that reports friction or stops, and the first
+// participant's once more in the scenario goal. A synthetic live run of 3 participants that all
+// reported friction held their instructions 3, 2 and 2 times, and the mission and each of 2 task
+// goals 7 times. None of the three fields is capped, and the estimate counts the feedback
+// candidate's copy for every participant, so it warns at 100 participants with 75,238 bytes of
+// text each. On 2026-10-13 the longest mission on the live computer-use runs kept on the
+// maintainer's machine was 807 characters. On 2026-10-14 the longest instruction on the 170 live
+// runs kept there was 4,061 characters, and none declared task goals.
 // observer-data.json leaves the lists out too and was 0.94 to 1.12 of run.json's size on the live
 // runs measured, so it passes 32 MiB only after run.json passes 16 MiB, and the estimate does not
 // check it.
@@ -83,10 +87,11 @@ const RATES = Object.freeze({
     /**
      * The page's compact copy of observer-data.json, as a share of run.json before the mission: 0.71
      * to 0.84 on the live runs written as v4, where neither carries the per-request lists. The page
-     * holds the mission at its full size once for the run and once for each participant: dry runs of
-     * 1 and 4 participants grew the page by 2 and 5 copies, as run.json grew, and a 0.128.0 run of 2
-     * participants with 2 feedback candidates held 5 copies in run.json and 3 on the page. An
-     * analysis adds each participant's assignment, cut to 8,000 bytes.
+     * holds each participant's text at its full size once, and the first participant's once more for
+     * the run: dry runs of 1 and 4 participants grew the page by 2 and 5 copies of the mission, as
+     * run.json grew, and a 0.128.0 run of 2 participants with 2 feedback candidates held 5 copies in
+     * run.json and 3 on the page. The synthetic run of 3 held their instructions 2, 1 and 1 times on
+     * the page. An analysis adds each participant's assignment, cut to 8,000 bytes.
      */
     observerPageDataShare: 0.85,
     /**
@@ -107,6 +112,15 @@ const RATES = Object.freeze({
     participantEntries: 3,
 });
 const MIB = 1024 * 1024;
+/**
+ * The study fields run.json copies into each participant's stream, and the advice to shorten each.
+ * The plan does not keep which form declared the participants, so the advice names both paths.
+ */
+const COPIED_FIELDS = Object.freeze({
+    mission: "shorten the mission (actor.mission)",
+    focus: "shorten the participants' instructions (participants.instruction or participants[].instruction)",
+    tasks: "shorten the task goals (actor.tasks[].goal)",
+});
 /**
  * The bundle a live run of `participants` leaves, each in its session of `sessionMs` unless it
  * declares an end or a cap. A participant with an end works its whole window; one without ends
@@ -119,13 +133,14 @@ export function estimateBundle(participants, sessionMs) {
     let frames = 0;
     let traces = 0;
     let largestTrace = 0;
-    let missionBytes = 0;
-    let longestMission = 0;
+    // The bytes of each copied field over all participants, and the longest participant's text.
+    const fieldBytes = { mission: 0, focus: 0, tasks: 0 };
+    let longestText = 0;
     let longestWindowMs = 0;
     // The longest any participant without an end is counted, for the messages.
     let openMs = Math.min(sessionMs, RATES.openSessionMs);
     let scheduled = 0;
-    for (const { schedule, limits, assignment } of participants) {
+    for (const { schedule, limits, assignment, tasks = [] } of participants) {
         const { end } = schedule;
         const budgetMs = end?.windowMs ?? sessionMs;
         let countedMs;
@@ -146,26 +161,32 @@ export function estimateBundle(participants, sessionMs) {
         frames += ownFrames;
         traces += trace;
         largestTrace = Math.max(largestTrace, trace);
-        // The mission's bytes as run.json stores them, a JSON string without its quotes.
-        const mission = assignment.mission === undefined
-            ? 0
-            : Buffer.byteLength(JSON.stringify(assignment.mission)) - 2;
-        missionBytes += mission;
-        longestMission = Math.max(longestMission, mission);
+        const mission = storedBytes(assignment.mission);
+        const focus = storedBytes(assignment.focus);
+        const goals = tasks.reduce((sum, task) => sum + storedBytes(task.goal), 0);
+        fieldBytes.mission += mission;
+        fieldBytes.focus += focus;
+        fieldBytes.tasks += goals;
+        longestText = Math.max(longestText, mission + focus + goals);
     }
+    const textBytes = fieldBytes.mission + fieldBytes.focus + fieldBytes.tasks;
+    // Sorting is stable, so of fields with equal bytes the first declared is named.
+    const [largestField] = Object.keys(fieldBytes)
+        .filter((field) => fieldBytes[field] > 0)
+        .sort((a, b) => fieldBytes[b] - fieldBytes[a]);
     const count = participants.length;
     const dataBytes = RATES.runBytes + count * RATES.participantBytes;
-    // run.json holds the mission in the run's scenario goal, in each participant's stream and in the
-    // feedback candidate of each participant that reports friction or stops, counted for every
-    // participant. The rates were fit on runs with short missions, so a short mission is counted
-    // twice.
-    const runFileBytes = dataBytes + longestMission + 2 * missionBytes;
+    // run.json holds each participant's text in its stream and in its feedback candidate if it
+    // reports friction or stops, counted for every participant, and the first participant's in the
+    // run's scenario goal, counted at the longest. The rates were fit on runs with short texts, so a
+    // short text is counted twice.
+    const runFileBytes = dataBytes + longestText + 2 * textBytes;
     const screenshots = count + turns + frames;
     // The page holds no feedback candidate's copy.
     const observerPageBytes = Math.round(RATES.observerAppBytes +
         RATES.observerPageDataShare * dataBytes +
-        longestMission +
-        missionBytes +
+        longestText +
+        textBytes +
         RATES.observerPageItemsShare * traces);
     return {
         runFileBytes,
@@ -182,9 +203,14 @@ export function estimateBundle(participants, sessionMs) {
             open: count - scheduled,
             openMs,
             dwell: frames > 0,
+            ...(largestField === undefined ? {} : { largestField }),
         },
     };
 }
+/** A text's bytes as run.json stores it, a JSON string without its quotes. */
+function storedBytes(text) {
+    return text === undefined ? 0 : Buffer.byteLength(JSON.stringify(text)) - 2;
+}
 /**
  * The warning for a run whose estimate passes a limit, or undefined: each limit it passes, what the
  * estimate counted, and what to change.
@@ -196,7 +222,7 @@ export function bundleLimitReason(estimate) {
     const passed = [
         ...(runFile
             ? [
-                `This study's run.json may grow to about ${mib(estimate.runFileBytes)}, past the ${mib(EVIDENCE_LIMITS.sourceBytes)} analysis reads. It holds the mission once for the run, once in each participant's stream and once more for each participant that reports friction or stops, and the estimate counts the last copy for every participant.`,
+                `This study's run.json may grow to about ${mib(estimate.runFileBytes)}, past the ${mib(EVIDENCE_LIMITS.sourceBytes)} analysis reads. It holds the mission, the task goals and each participant's instruction in that participant's stream, and again in the feedback candidate of each participant that reports friction or stops. It holds the first participant's mission, instruction and task goals once more for the run, and the estimate counts a feedback candidate for every participant.`,
             ]
             : []),
         ...(estimate.largestTraceBytes > RUN_ARTIFACT_MAX_BYTES
@@ -217,7 +243,7 @@ export function bundleLimitReason(estimate) {
     ];
     if (passed.length === 0)
         return undefined;
-    const { scheduled, longestWindowMs, open, openMs, dwell } = estimate.basis;
+    const { scheduled, longestWindowMs, open, openMs, dwell, largestField } = estimate.basis;
     const counted = [
         ...(scheduled > 0
             ? [
@@ -233,7 +259,7 @@ export function bundleLimitReason(estimate) {
     const changes = [
         ...(scheduled > 0 ? ["shorten the longest windows (participants[].endAfterMs)"] : []),
         ...(dwell ? ["shorten the dwell window (dwell.ms) or capture less often (dwell.everyMs)"] : []),
-        ...(runFile ? ["shorten the mission (actor.mission)"] : []),
+        ...(runFile && largestField !== undefined ? [COPIED_FIELDS[largestField]] : []),
     ];
     // A trace is one participant's, so splitting the study helps only the run's own files.
     if (runFile || page || entries || changes.length === 0)