humanish 0.134.0 → 0.135.0

package/CHANGELOG.md

@@ -8,6 +8,21 @@ The Unreleased section holds the full notes for the next version until it is tag
 
 ## Unreleased
 
+## 0.135.0: Encoded keys in a study's own text stay out of the run (2026-10-14)
+
+humanish 0.135.0 keeps a base64- or percent-encoded key in a study's own text out of the copies of
+that text the run records. The run redacted keys as written, and verify also decodes those
+encodings, so a study whose title, mission, instructions, persona or scripted scenario held an
+encoded key produced a run graded `blocked`. A participant that repeats such a key in its own words
+still does (#1892). `actor.model`, `subject.envValues` and the analysis question now refuse such a
+value before anything runs, which a study that ran before may now meet. verify's per-file scan also
+finds a key behind an HTML reference and a JSON escape. The Observer page and its live feed carry
+each participant's items on their own, so `humanish observe` writes the page of a run whose traces
+together pass V8's longest string: on a synthetic run of 25 participants with 30 MiB traces it
+exits 0 where it exited 2.
+
+[Release notes](https://github.com/danielgwilson/humanish/releases/tag/v0.135.0)
+
 ## 0.134.0: Participants held to an end keep reloading until it (2026-10-14)
 
 humanish 0.134.0 keeps a participant held to a scheduled end running when it reloads a page that

package/dist/analysis/automatic-config.js

@@ -3,7 +3,7 @@ import { DEFAULT_ANALYSIS_MAX_OUTPUT_TOKENS, MAX_ANALYSIS_OUTPUT_TOKENS, analysi
 import { admissionRule } from "./admission.js";
 import { analysisRequestCount, EVIDENCE_LIMITS } from "./analysis-limits.js";
 import { plural } from "../run/text.js";
-import { containsSensitive } from "../evidence/redaction.js";
+import { scanEncodedText } from "../evidence/encoded-text.js";
 export const DEFAULT_ANALYSIS_TIMEOUT_MS = 600_000;
 const MAX_ANALYSIS_TIMEOUT_MS = 600_000;
 export const DEFAULT_ANALYSIS_MODEL = "gpt-6-astra";
@@ -21,6 +21,8 @@ const validTimeout = (value) => typeof value === "number" &&
     value <= MAX_ANALYSIS_TIMEOUT_MS;
 /** An absent question is valid; a present one must be a string of at most 4000 characters. */
 const validQuestion = (value) => value === undefined || (typeof value === "string" && value.length <= 4000);
+// The provider receives the question and analysis.json keeps it. verify reads that file as written
+// and decoded, so the question is refused when scanEncodedText reads a secret in it.
 const SENSITIVE_QUESTION = {
     ok: false,
     message: "review.analysis.question contains sensitive text and cannot be sent for analysis.",
@@ -60,7 +62,7 @@ export function resolveAutomaticAnalysis(raw) {
                 message: `Codex analysis requires the qualified ${CODEX_ANALYSIS_MODEL} model and timeoutMs 1–${MAX_ANALYSIS_TIMEOUT_MS}. Dollar and output-token caps are unavailable; omit them. The optional question is limited to 4000 characters.`,
             };
         }
-        if (question !== null && containsSensitive(question))
+        if (question !== null && scanEncodedText(question).sensitive)
             return SENSITIVE_QUESTION;
         return {
             ok: true,
@@ -99,7 +101,7 @@ export function resolveAutomaticAnalysis(raw) {
             message: `review.analysis requires a positive maxCostUsd up to 1000, a supported analysis model, timeoutMs 1–${MAX_ANALYSIS_TIMEOUT_MS}, maxOutputTokens 256–${MAX_ANALYSIS_OUTPUT_TOKENS}, and an optional question of at most 4000 characters.`,
         };
     }
-    if (question !== null && containsSensitive(question))
+    if (question !== null && scanEncodedText(question).sensitive)
         return SENSITIVE_QUESTION;
     return {
         ok: true,

package/dist/analysis/execute.js

@@ -4,6 +4,7 @@ import { estimateAnalysisCost } from "./admission.js";
 import { createHash, randomUUID } from "node:crypto";
 import { MODEL_RATES } from "../run/pricing.js";
 import { containsSensitive } from "../evidence/redaction.js";
+import { scanEncodedText } from "../evidence/encoded-text.js";
 import { ANALYSIS_ID_PATTERN, ANALYSIS_SCHEMA, } from "./types.js";
 import { INPUT_IMAGE_DATA_URL, createAnalysisProvider, } from "./provider.js";
 import { hashAnalysisValue, analysisResultJsonSchema, validateAnalysisInputMetadata, } from "./validation.js";
@@ -189,7 +190,7 @@ export function estimateAnalysisAdmission(input, config) {
             (typeof config.question !== "string" || config.question.length > 4000))) {
         return denied("analysis_config_invalid");
     }
-    if (config.question !== null && containsSensitive(config.question))
+    if (config.question !== null && scanEncodedText(config.question).sensitive)
         return denied("analysis_question_sensitive");
     const badInput = inputError(input);
     if (badInput)

package/dist/analysis/service.js

@@ -5,6 +5,7 @@ import { lstat, mkdir, realpath, rmdir } from "node:fs/promises";
 import path from "node:path";
 import { renderObserver } from "../observer/render.js";
 import { containsSensitive } from "../evidence/redaction.js";
+import { scanEncodedText } from "../evidence/encoded-text.js";
 import { transientCommsKnownValueScrub } from "../run/transient-comms-secrets.js";
 import { verifyRunPrepared } from "../verify/verify.js";
 import { loadRunBundlePrepared, resolveRunPath } from "../run/locate.js";
@@ -189,7 +190,7 @@ function analyzeConfigRefusal(config) {
         ? !validCodexAnalysisConfig(config)
         : !Number.isFinite(config.maxCostUsd) || config.maxCostUsd <= 0 || config.maxCostUsd > 1000)
         return "ANALYSIS_CONFIG_INVALID";
-    if (config.question !== null && containsSensitive(config.question))
+    if (config.question !== null && scanEncodedText(config.question).sensitive)
         return "ANALYSIS_QUESTION_UNSAFE";
     return null;
 }

package/dist/evidence/encoded-text.d.ts

@@ -8,10 +8,12 @@ export declare const latin1RunsAsUtf8: (text: string) => string;
 export declare function decodeEscapes(text: string): string;
 /**
  * Every reading of the text a scan matches, each once: as written, decodeEscapes, with percent
- * escapes read as UTF-8, decodeEscapes with transfer escapes expanded, and the text as written and
+ * escapes read as UTF-8, decodeEscapes with transfer escapes expanded, the text as written and
  * decoded with each run of U+0080 to U+00FF characters read as UTF-8 bytes, which undoes text that
- * a reader already decoded one byte per character. Either percent reading can split a value that
- * the other keeps whole, as `%E2%80%80` (U+2000, a space, in UTF-8) does.
+ * a reader already decoded one byte per character, decodeEscapes with HTML references left as
+ * written and that reading with transfer escapes expanded, and the text with only HTML references
+ * decoded. Either percent reading can split a value that the other keeps whole, as `%E2%80%80`
+ * (U+2000, a space, in UTF-8) does.
  */
 export declare function readingsOf(text: string): string[];
 /** How scanEncodedText reads text. */
@@ -34,6 +36,14 @@ export interface EncodedTextScan {
  * is opaque unless the caller allows opaque runs.
  */
 export declare function scanEncodedText(text: string, options?: EncodedTextScanOptions, depth?: number): EncodedTextScan;
+/**
+ * redactText, then each whitespace-separated piece that scanEncodedText reads as sensitive replaced
+ * by the secret marker, so a key written in base64 or percent-encoded goes as a literal one does.
+ * When the pieces read clean one at a time but the text still reads sensitive, as `Bearer` before a
+ * percent-encoded token does, the whole text becomes the marker. For study text the run records and
+ * the instructions composed from it: on 32 KiB of prose it took 3 ms, and 34 ms with a key in it.
+ */
+export declare function redactEncodedText(text: string): string;
 /**
  * scanEncodedText, cached in this process. The key is the sha256 of the scanned string's UTF-16
  * code units, the options and ENCODED_SCAN_VERSION. Encoding as UTF-16LE keeps every code unit,

package/dist/evidence/encoded-text.js

@@ -5,7 +5,7 @@
 import { isUtf8 } from "node:buffer";
 import { createHash } from "node:crypto";
 import { readPlainText } from "./plain-text.js";
-import { containsSensitive } from "./redaction.js";
+import { containsSensitive, REDACTION_MARKERS, redactText } from "./redaction.js";
 // HTML5 named references that stand for printable ASCII. Letters and digits have only numeric
 // references, which decodeEscapes handles.
 const ASCII_ENTITIES = new Map([
@@ -97,37 +97,71 @@ function decodePercentBytes(run) {
 export function decodeEscapes(text) {
     return decodeWith(text, decodePercentBytes);
 }
-/** The readings a scan matches, with the two that scanEncodedText also searches for runs. */
+/** The readings a scan matches, with the three that scanEncodedText also searches for runs. */
 function readings(text) {
-    const decoded = decodeEscapes(text);
+    // Decoding references with the other escapes joins a letter reference to the escaped key after
+    // it, `A\u0073k-` to `Ask-`, where a pattern's word boundary fails. With references left as
+    // written, the `;` before the key keeps that boundary. A key that ends in a reference before an
+    // escaped letter, `l\u0041`, keeps the boundary after it when only references are decoded.
+    // The reading with references left as written is also read with transfer escapes expanded, as
+    // the decoded one is, for a key that a quoted-printable soft break splits.
+    const unescaped = decodeCodeEscapes(text, decodePercentBytes);
+    const decoded = decodeReferences(unescaped);
     // The UTF-8 reading differs only where a percent escape holds a byte of 0x80 or more, which
     // decodeEscapes writes as a character from U+0080 to U+00FF. Testing the decoded text also
     // catches a `%` that a `\u0025` wrote.
     const utf8 = HIGH_BYTE.test(decoded) ? decodeWith(text, decodePercentRun) : decoded;
     const expanded = decodeTransferEscapes(decoded);
+    // Without references in the text, or without code escapes, each of these two readings is one
+    // already decoded above, so it reuses that string. On a real 2 MiB Observer page, decoding both
+    // again took 12 ms of the 60 that readingsOf took.
+    const unescapedExpanded = unescaped === decoded ? expanded : decodeTransferEscapes(unescaped);
+    const referencesDecoded = text === unescaped ? decoded : decodeReferences(text);
     const recovered = [text, decoded].filter((reading) => HIGH_BYTE.test(reading));
     return {
+        all: [
+            ...new Set([
+                text,
+                decoded,
+                utf8,
+                expanded,
+                ...recovered.map(latin1RunsAsUtf8),
+                unescaped,
+                unescapedExpanded,
+                referencesDecoded,
+            ]),
+        ],
         decoded,
         expanded,
-        all: [...new Set([text, decoded, utf8, expanded, ...recovered.map(latin1RunsAsUtf8)])],
+        unescapedExpanded,
     };
 }
 /**
  * Every reading of the text a scan matches, each once: as written, decodeEscapes, with percent
- * escapes read as UTF-8, decodeEscapes with transfer escapes expanded, and the text as written and
+ * escapes read as UTF-8, decodeEscapes with transfer escapes expanded, the text as written and
  * decoded with each run of U+0080 to U+00FF characters read as UTF-8 bytes, which undoes text that
- * a reader already decoded one byte per character. Either percent reading can split a value that
- * the other keeps whole, as `%E2%80%80` (U+2000, a space, in UTF-8) does.
+ * a reader already decoded one byte per character, decodeEscapes with HTML references left as
+ * written and that reading with transfer escapes expanded, and the text with only HTML references
+ * decoded. Either percent reading can split a value that the other keeps whole, as `%E2%80%80`
+ * (U+2000, a space, in UTF-8) does.
  */
 export function readingsOf(text) {
     return readings(text).all;
 }
 function decodeWith(text, percent) {
+    return decodeReferences(decodeCodeEscapes(text, percent));
+}
+/** JSON and JS string escapes, then percent-encoding. */
+function decodeCodeEscapes(text, percent) {
     return text
         .replace(/\\u([0-9a-f]{4})/gi, (match, hex) => codePoint(Number.parseInt(hex, 16), match))
         .replace(/\\x([0-9a-f]{2})/gi, (match, hex) => codePoint(Number.parseInt(hex, 16), match))
         .replace(/\\\//g, "/")
-        .replace(/(?:%[0-9a-f]{2})+/gi, percent)
+        .replace(/(?:%[0-9a-f]{2})+/gi, percent);
+}
+/** HTML character references: numeric ones and the ASCII_ENTITIES names. */
+function decodeReferences(text) {
+    return text
         .replace(/&#x([0-9a-f]{1,6});?/gi, (match, hex) => codePoint(Number.parseInt(hex, 16), match))
         .replace(/&#(\d{1,7});?/g, (match, digits) => codePoint(Number.parseInt(digits, 10), match))
         .replace(/&([a-z]+);/gi, namedReference);
@@ -144,6 +178,8 @@ const BASE64_RUN = /[A-Za-z0-9+/]{16}[A-Za-z0-9+/]*={0,2}/g;
 const BASE64URL_RUN = /[A-Za-z0-9_-]{16}[A-Za-z0-9_-]*={0,2}/g;
 // Hex-encoded text, at least sixteen bytes of it.
 const HEX_RUN = /[0-9a-f]{32}[0-9a-f]*/gi;
+// The base64, URL-safe base64 or hex run right after a `;`, such as the one that ends a reference.
+const RUN_AFTER_SEMICOLON = /;([A-Za-z0-9+/_-]{16}[A-Za-z0-9+/_-]*={0,2})/g;
 // A base64 run that decodes to bytes that are neither text nor an archive is unreadable only past
 // this length. Across 173 real run folders surveyed on 2026-10-01, the longest such run outside
 // observer/index.html was a 69-character URL path in a terminal log; base64 of a 94-byte payload,
@@ -293,6 +329,18 @@ function inspectDecoded(bytes, run, options, depth) {
             options.allowOpaqueBase64 !== true,
     };
 }
+/** The base64 and URL-safe base64 runs in a reading, each with its bytes. */
+function base64Runs(reading) {
+    const runs = [];
+    for (const [match] of reading.matchAll(BASE64_RUN))
+        // Hex digests and ids decode to noise; scanEncodedText's hex pass reads hex as hex.
+        if (!/^[0-9a-f]+$/i.test(match.replace(/=+$/, "")))
+            runs.push({ run: match, bytes: Buffer.from(match, "base64") });
+    for (const [match] of reading.matchAll(BASE64URL_RUN))
+        if (/[-_]/.test(match))
+            runs.push({ run: match, bytes: Buffer.from(match, "base64url") });
+    return runs;
+}
 /**
  * Scans text for secrets in each of its readingsOf, and inside each base64 (standard, URL-safe or
  * line-wrapped) and hex run. A run that decodes to text is scanned in
@@ -301,31 +349,31 @@ function inspectDecoded(bytes, run, options, depth) {
  */
 export function scanEncodedText(text, options = {}, depth = 0) {
     const matches = matcherOf(options);
-    const { decoded, expanded, all } = readings(text);
+    const { all, decoded, expanded, unescapedExpanded } = readings(text);
     if (all.some(matches))
         return SENSITIVE;
-    const runs = [];
+    const runs = base64Runs(expanded);
     // A piece or a run decoded from a slash only adds findings; its bytes are not judged opaque.
     const slashStarts = [];
-    for (const [match] of expanded.matchAll(BASE64_RUN)) {
-        // Hex digests and ids decode to noise; the hex pass below reads hex as hex.
-        if (/^[0-9a-f]+$/i.test(match.replace(/=+$/, "")))
-            continue;
-        runs.push({ run: match, bytes: Buffer.from(match, "base64") });
-        if (match.length > MAX_SLASH_START_RUN)
+    for (const { run } of runs) {
+        if (run.length > MAX_SLASH_START_RUN)
             continue;
-        for (const piece of match.split("/"))
-            if (piece.length >= 16 && piece.length < match.length)
+        for (const piece of run.split("/"))
+            if (piece.length >= 16 && piece.length < run.length)
                 slashStarts.push(Buffer.from(piece, "base64"));
-        for (let slash = match.indexOf("/"); slash !== -1 && slash < SLASH_START_SPAN && match.length - slash > 16; slash = match.indexOf("/", slash + 1))
-            slashStarts.push(Buffer.from(match.slice(slash + 1), "base64"));
-    }
-    for (const [match] of expanded.matchAll(BASE64URL_RUN)) {
-        if (/[-_]/.test(match))
-            runs.push({ run: match, bytes: Buffer.from(match, "base64url") });
+        for (let slash = run.indexOf("/"); slash !== -1 && slash < SLASH_START_SPAN && run.length - slash > 16; slash = run.indexOf("/", slash + 1))
+            slashStarts.push(Buffer.from(run.slice(slash + 1), "base64"));
     }
     for (const run of wrappedBase64Runs(expanded))
         runs.push({ run, bytes: Buffer.from(run, "base64") });
+    // A decoded reference right before a run joins its character to the run, which shifts every
+    // base64 quartet and hex pair in it. The run after each `;` with references left as written
+    // adds findings, as a slash start does.
+    const runsAfterSemicolons = unescapedExpanded === expanded
+        ? []
+        : [...unescapedExpanded.matchAll(RUN_AFTER_SEMICOLON)].map(([, run]) => run);
+    for (const { bytes } of runsAfterSemicolons.flatMap(base64Runs))
+        slashStarts.push(bytes);
     let opaque = false;
     for (const { run, bytes } of runs) {
         const result = inspectDecoded(bytes, run, options, depth);
@@ -341,6 +389,7 @@ export function scanEncodedText(text, options = {}, depth = 0) {
     const hexRuns = new Set([
         ...[...expanded.matchAll(HEX_RUN)].map(([match]) => match),
         ...(expanded === decoded ? [] : [...decoded.matchAll(HEX_RUN)].map(([match]) => match)),
+        ...runsAfterSemicolons.flatMap((run) => [...run.matchAll(HEX_RUN)].map(([match]) => match)),
     ]);
     for (const match of hexRuns) {
         const plain = readPlainText(Buffer.from(match, "hex"));
@@ -349,10 +398,24 @@ export function scanEncodedText(text, options = {}, depth = 0) {
     }
     return { sensitive: false, opaque };
 }
+/**
+ * redactText, then each whitespace-separated piece that scanEncodedText reads as sensitive replaced
+ * by the secret marker, so a key written in base64 or percent-encoded goes as a literal one does.
+ * When the pieces read clean one at a time but the text still reads sensitive, as `Bearer` before a
+ * percent-encoded token does, the whole text becomes the marker. For study text the run records and
+ * the instructions composed from it: on 32 KiB of prose it took 3 ms, and 34 ms with a key in it.
+ */
+export function redactEncodedText(text) {
+    const literal = redactText(text);
+    if (!scanEncodedText(literal).sensitive)
+        return literal;
+    const pieces = literal.replace(/\S+/g, (piece) => scanEncodedText(piece).sensitive ? REDACTION_MARKERS.secret : piece);
+    return scanEncodedText(pieces).sensitive ? REDACTION_MARKERS.secret : pieces;
+}
 // Bump when scanEncodedText, decodeEscapes or the sensitive patterns change what they return. The
 // cache lives in one process, so the version guards results across a hot reload or a test that
 // swaps the scanner.
-const ENCODED_SCAN_VERSION = 5;
+const ENCODED_SCAN_VERSION = 6;
 // Distinct files one process verifies in a burst (a run's files, a serve library's runs).
 const SCAN_CACHE_LIMIT = 256;
 const scanCache = new Map();

package/dist/observer/page-data.d.ts

@@ -1,5 +1,11 @@
+import type { LiveItemsRead } from "../run/stream-trace.js";
 import type { ObserverData } from "./data.js";
 /** The page's data elements for `data`, in place of the built page's data slot. */
 export declare function observerDataElements(data: ObserverData): string;
+/**
+ * observer-feed.json's body: observer-data.json's content and the items packed as the page packs
+ * them, with each running participant's cursor from `live` on its entry.
+ */
+export declare function observerFeedBody(data: ObserverData, live?: readonly LiveItemsRead[]): Promise<string>;
 /** JSON that stays inert inside a script element: no `</script>` breakout, no HTML entities. */
 export declare function escapeJsonScript(value: unknown): string;

package/dist/observer/page-data.js

@@ -1,15 +1,42 @@
-// How an Observer page carries a run's data: observer-data.json's content as JSON, and every
-// participant's trace items gzip-compressed in base64, which a file:// page decodes without a
-// fetch. The items are most of a long run's bytes and compress about eight times.
-import { gzipSync } from "node:zlib";
-import { splitObserverData } from "./participant-items.js";
+// How an Observer page and the served feed carry a run's data: observer-data.json's content as
+// JSON, and each participant's trace items gzip-compressed in base64 on their own, which a file://
+// page decodes without a fetch. The items are most of a long run's bytes and compress about eight
+// times. Packing one participant at a time keeps every string under V8's longest string
+// (536,870,888 characters) while each participant's trace stays under the 32 MiB read limit.
+import { promisify } from "node:util";
+import { constants, gzip, gzipSync } from "node:zlib";
+import { withFeedCursors } from "./feed-cursors.js";
+import { splitObserverData, } from "./participant-items.js";
 /** The page's data elements for `data`, in place of the built page's data slot. */
 export function observerDataElements(data) {
     const { shell, items } = splitObserverData(data);
-    const packed = gzipSync(JSON.stringify(items)).toString("base64");
     return (`<script id="observer-data" type="application/json">${escapeJsonScript(shell)}</script>` +
-        `<script id="observer-items" type="application/octet-stream" data-encoding="gzip">${packed}</script>`);
+        `<script id="observer-items" type="application/json">${escapeJsonScript(packObserverItems(items))}</script>`);
 }
+const gzipOnThreadPool = promisify(gzip);
+/**
+ * observer-feed.json's body: observer-data.json's content and the items packed as the page packs
+ * them, with each running participant's cursor from `live` on its entry.
+ */
+export async function observerFeedBody(data, live = []) {
+    const { shell, items } = splitObserverData(data);
+    const cursored = withFeedCursors(items, live);
+    // Each open page polls every 5 seconds and gets every finished participant's items again, so the
+    // server compresses them on the thread pool and answers other requests meanwhile. Level 1 took
+    // half the time of the default on 30 MiB of items, for 13 percent more bytes. One participant
+    // at a time, so a poll holds one participant's JSON text at once.
+    const streams = [];
+    for (const [id, entry] of Object.entries(cursored.streams)) {
+        const packed = await gzipOnThreadPool(entryText(id, entry), { level: constants.Z_BEST_SPEED });
+        streams.push(packed.toString("base64"));
+    }
+    return JSON.stringify({ data: shell, items: { ...cursored, streams } });
+}
+function packObserverItems(items) {
+    const streams = Object.entries(items.streams).map(([id, entry]) => gzipSync(entryText(id, entry)).toString("base64"));
+    return { ...items, streams };
+}
+const entryText = (id, entry) => JSON.stringify({ id, ...entry });
 /** JSON that stays inert inside a script element: no `</script>` breakout, no HTML entities. */
 export function escapeJsonScript(value) {
     return JSON.stringify(value)

package/dist/observer/participant-items.d.ts

@@ -1,6 +1,6 @@
 import type { ActorTraceItem } from "../actors/contract.js";
 import type { ObserverData, ObserverStream } from "./data.js";
-export declare const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v1";
+export declare const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v2";
 /** A stream's actor and live actor, each without its items. */
 type ObserverShellStream = Omit<ObserverStream, "actor" | "liveActor"> & {
     actor?: Omit<NonNullable<ObserverStream["actor"]>, "items">;
@@ -32,6 +32,20 @@ export interface ObserverItems {
         liveAfter?: string;
     }>;
 }
+/**
+ * ObserverItems as the page and the feed carry them: each stream's entry with its stream id, as
+ * gzip-compressed JSON in base64, so no string holds two participants' items. The id goes inside
+ * the entry because the public-safety scan reads the page's plain text: there, `GITHUB_TOKEN`
+ * before a long base64 value reads as a credential, and `https://` with a later id shaped like an
+ * address at an E2B host reads as one E2B URL across the base64 between them.
+ */
+export interface PackedObserverItems extends Omit<ObserverItems, "streams"> {
+    streams: string[];
+}
+/** A packed entry once decoded: the stream's entry with its stream id. */
+export type PackedObserverEntry = ObserverItems["streams"][string] & {
+    id: string;
+};
 /** The data as observer-data.json and the page's items carry it. */
 export declare function splitObserverData(data: ObserverData): {
     shell: ObserverShell;

package/dist/observer/participant-items.js

@@ -1,9 +1,10 @@
 // The Observer's data in two parts: observer-data.json, the run and every participant without
 // their trace items, and the items themselves. A participant working for hours records thousands
 // of items, so the items are most of the bytes; apart, the saved observer-data.json stays small
-// enough to verify, and the page carries the items compressed. The Observer bundles this module,
-// so it imports types only (docs/decisions/0002-observer-is-one-self-contained-file.md).
-export const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v1";
+// enough to verify, and the page and the feed carry each participant's items compressed on their
+// own. The Observer bundles this module, so it imports types only
+// (docs/decisions/0002-observer-is-one-self-contained-file.md).
+export const OBSERVER_ITEMS_SCHEMA = "humanish.observer-items.v2";
 /** The data as observer-data.json and the page's items carry it. */
 export function splitObserverData(data) {
     // No prototype, so a stream id such as `__proto__` is an entry like any other.

package/dist/observer/run-routes.js

@@ -17,7 +17,8 @@ import { MAX_NOTE_FILE_BYTES, readRunNotes, RUN_NOTES_DIR, } from "../run/note-f
 import { analysisCostOf, runCost, runCostLabel } from "../run/run-cost.js";
 import { RUN_STATUS_FILE, RUN_STATUS_STALE_MS, isRunStatusRecord, } from "../run/status.js";
 import { renderObserverHtml } from "./artifact.js";
-import { parseFeedCursors, withFeedCursors } from "./feed-cursors.js";
+import { parseFeedCursors } from "./feed-cursors.js";
+import { observerFeedBody } from "./page-data.js";
 import { splitObserverData } from "./participant-items.js";
 import { buildObserverData, observerDataFromSaved, recordedStreamEmbed, withObserverEndings, } from "./data.js";
 import { buildArtifactSecurityHeaders } from "./http.js";
@@ -130,10 +131,9 @@ export async function serveRunPath(runRoot, relativePath, response, runtimeStrea
             writeResponse(response, 404, `Observer data not found: ${observed.unavailable}`, "text/plain; charset=utf-8");
             return;
         }
-        const { shell, items } = splitObserverData(observed.data);
         writeResponse(response, 200, cleanedRelativePath === "observer/observer-data.json"
-            ? JSON.stringify(shell, null, 2)
-            : JSON.stringify({ data: shell, items: withFeedCursors(items, observed.live) }), "application/json; charset=utf-8");
+            ? JSON.stringify(splitObserverData(observed.data).shell, null, 2)
+            : await observerFeedBody(observed.data, observed.live), "application/json; charset=utf-8");
         return;
     }
     if (cleanedRelativePath === "observer/study-analysis.json") {