humanish 0.114.0 → 0.116.0

package/dist/evidence/secret-scrub.js

@@ -2,13 +2,20 @@
 // run's warnings. A value is found as written and in the encoded forms an HTTP client, a log line or
 // a JSON body gives it, so a token that reaches the text percent-encoded or base64-encoded is still
 // removed. Pattern redaction (redactText) runs after this and finds secrets by shape.
-import { decodeEscapes } from "./encoded-text.js";
-const REDACTED = "[REDACTED_SECRET]";
-// A marker already in the text, from this scrub or from redactText. No value is matched inside one.
-const MARKER = /\[REDACTED_[A-Z0-9_]+\]/g;
-// The shortest encoded form searched for. Shorter base64 or hex runs are ordinary text often enough
-// that matching them would redact words. A value itself is searched for at any length.
-const MIN_ENCODED_FORM = 8;
+import { escapeRegExp } from "../run/text.js";
+import { decodeEscapes, latin1RunsAsUtf8, readingsOf } from "./encoded-text.js";
+import { REDACTION_MARKERS } from "./redaction.js";
+const REDACTED = REDACTION_MARKERS.secret;
+// A form wholly inside a marker humanish writes is the marker's own text, as when a value is part
+// of the marker's name. Other bracketed text, such as `[REDACTED_373433393231]`, is searched like
+// any text.
+const MARKER = new RegExp(Object.values(REDACTION_MARKERS).map(escapeRegExp).join("|"), "g");
+// The shortest encoded form searched for: the unpadded base64 of a four-byte value, such as a
+// four-digit code. A given form of n characters turns up by chance in random base64 about once in
+// 64^n characters, once in 69 billion at 6 and once in 17 million at 4. In the text of 9 real runs
+// (2.5 million characters) no 6- or 7-character form of any 4-, 5- or 6-digit code occurred. A
+// value itself is searched for at any length.
+const MIN_ENCODED_FORM = 6;
 /**
  * The characters of a value's base64 encoding that do not depend on its neighbours, with 0, 1 or
  * 2 bytes before it. A prefix byte shares the next character with the value, and so does the byte
@@ -27,9 +34,12 @@ function base64Middles(bytes, encoding) {
 }
 /**
  * A value as written, and percent-encoded, JSON-escaped once (also with non-ASCII characters as
- * `\u` escapes) and twice, its UTF-8 bytes read one per character, base64 at each byte offset, base64url and hex. Twice, because a JSON event can carry a command's JSON output as a string. An
- * escaped form is searched for at any length, as the value is: it holds a backslash or a `%`, so it
- * is not ordinary text.
+ * `\u` escapes) and twice, its UTF-8 bytes read one per character and the reverse, base64 padded,
+ * unpadded and at each byte offset, base64url and hex. Twice, because a JSON event can carry a
+ * command's JSON output as a string. An escaped form is searched for at any length, as the value
+ * is: it holds a backslash or a `%`, so it is not ordinary text. A base64 or hex form is searched
+ * for from MIN_ENCODED_FORM characters, so a four-byte value is found in base64 written whole and
+ * not inside a longer run, where four or five of its characters do not depend on its neighbours.
  */
 export function encodedForms(value) {
     const bytes = Buffer.from(value, "utf8");
@@ -45,8 +55,10 @@ export function encodedForms(value) {
     catch {
         // no percent-encoded form
     }
+    const base64 = bytes.toString("base64");
     const binary = [
-        bytes.toString("base64"),
+        base64,
+        base64.replace(/=+$/, ""),
         bytes.toString("base64url"),
         bytes.toString("hex"),
         ...base64Middles(bytes, "base64"),
@@ -57,13 +69,18 @@ export function encodedForms(value) {
     const bytewise = bytes.toString("latin1");
     if (bytewise !== value)
         escaped.push(bytewise);
+    // The mirror: a value such as xéz€ whose characters include bytes that read as UTF-8, written
+    // with them read (xéz€). No reading of the text turns xéz€ back into the value.
+    const mirrored = latin1RunsAsUtf8(value);
+    if (mirrored !== value)
+        escaped.push(mirrored);
     return [value, ...escaped, ...binary.filter((form) => form.length >= MIN_ENCODED_FORM)];
 }
 /**
- * Whether [at, end) overlaps a marker. The markers are one regex's matches, so they are sorted and
- * disjoint: only the first marker that ends after `at` can also start before `end`.
+ * Whether [at, end) lies wholly inside one marker. The markers are one regex's matches, so they are
+ * sorted and disjoint: only the first marker that ends after `at` can hold it.
  */
-function overlapsMarker(markers, at, end) {
+function insideMarker(markers, at, end) {
     let low = 0;
     let high = markers.length;
     while (low < high) {
@@ -73,33 +90,148 @@ function overlapsMarker(markers, at, end) {
         else
             low = middle + 1;
     }
-    return low < markers.length && markers[low][0] < end;
+    return low < markers.length && markers[low][0] <= at && end <= markers[low][1];
 }
-/** Every occurrence of every form, outside the markers, merged where they overlap or touch. */
-function secretSpans(text, forms) {
+/**
+ * The Knuth-Morris-Pratt failure table: entry `k` is the length of the longest proper prefix of
+ * the form's first `k` characters that is also their suffix.
+ */
+function failureTable(form) {
+    const table = new Int32Array(form.length + 1);
+    for (let at = 1, length = 0; at < form.length; at += 1) {
+        while (length > 0 && form[at] !== form[length])
+            length = table[length];
+        if (form[at] === form[length])
+            length += 1;
+        table[at + 1] = length;
+    }
+    return table;
+}
+/**
+ * Calls `found` with the start of every occurrence of the form, overlapping ones included, in time
+ * linear in the text. indexOf skips to the next occurrence. After one, the failure table carries
+ * the match on through the occurrences that overlap it, so no character is compared again, until
+ * no prefix of the form is left matched and indexOf takes over.
+ */
+function eachOccurrence(text, form, found) {
+    let table;
+    for (let at = text.indexOf(form); at !== -1;) {
+        found(at);
+        table ??= failureTable(form);
+        let matched = table[form.length];
+        let next = at + form.length;
+        for (; matched > 0 && next < text.length; next += 1) {
+            while (matched > 0 && text[next] !== form[matched])
+                matched = table[matched];
+            if (text[next] === form[matched])
+                matched += 1;
+            if (matched === form.length) {
+                found(next + 1 - form.length);
+                matched = table[form.length];
+            }
+        }
+        at = matched > 0 ? -1 : text.indexOf(form, next);
+    }
+}
+/**
+ * Each value's occurrences, the longest value that starts at a position replaced from the start of
+ * the text on, in time linear in the text for each value.
+ */
+function replaceLongestFirst(text, values) {
+    // The length of the longest value that starts at each position, allocated at the first find.
+    let longest;
+    for (const value of values)
+        eachOccurrence(text, value, (at) => {
+            longest ??= new Uint32Array(text.length);
+            longest[at] = Math.max(longest[at], value.length);
+        });
+    if (longest === undefined)
+        return text;
+    let result = "";
+    let cursor = 0;
+    for (let at = 0; at < text.length; at += 1) {
+        if (longest[at] === 0)
+            continue;
+        result += text.slice(cursor, at) + REDACTED;
+        cursor = at + longest[at];
+        at = cursor - 1;
+    }
+    return result + text.slice(cursor);
+}
+/**
+ * A scrub that replaces each non-empty value as written with `[REDACTED_SECRET]`, markers
+ * included. From the start of the text, the longest value that starts at a position is replaced
+ * and the search goes on after it, so the marker it writes is never searched. One global regex of
+ * the values, longest first, does that fastest. V8 compiles it at its first use and refuses it
+ * once a value has 32,768 characters; the scrub then finds each value itself, with the same
+ * output, in time linear in the text for each value.
+ */
+export function scrubValuesAsWritten(values) {
+    const written = [...new Set(values)].filter((value) => value.length > 0);
+    if (written.length === 0)
+        return (text) => text;
+    let pattern = new RegExp([...written]
+        .sort((left, right) => right.length - left.length)
+        .map(escapeRegExp)
+        .join("|"), "g");
+    return (text) => {
+        if (pattern !== undefined)
+            try {
+                return text.replace(pattern, REDACTED);
+            }
+            catch {
+                pattern = undefined;
+            }
+        return replaceLongestFirst(text, written);
+    };
+}
+/** Every occurrence of every form not wholly inside a marker, in no order. */
+function occurrences(text, forms) {
     const markers = [];
     for (const match of text.matchAll(MARKER)) {
         const start = match.index ?? 0;
         markers.push([start, start + match[0].length]);
     }
+    const found = [];
+    for (const form of forms)
+        eachOccurrence(text, form, (at) => {
+            if (!insideMarker(markers, at, at + form.length))
+                found.push([at, at + form.length]);
+        });
+    return found;
+}
+/** The occurrences sorted and merged where they overlap or touch. */
+function merged(found) {
+    found.sort((left, right) => left[0] - right[0]);
     const spans = [];
-    for (const form of forms) {
-        for (let at = text.indexOf(form); at !== -1; at = text.indexOf(form, at + 1)) {
-            const end = at + form.length;
-            if (!overlapsMarker(markers, at, end))
-                spans.push([at, end]);
-        }
-    }
-    spans.sort((left, right) => left[0] - right[0]);
-    const merged = [];
-    for (const span of spans) {
-        const last = merged.at(-1);
+    for (const span of found) {
+        const last = spans.at(-1);
         if (last !== undefined && span[0] <= last[1])
             last[1] = Math.max(last[1], span[1]);
         else
-            merged.push([span[0], span[1]]);
+            spans.push([span[0], span[1]]);
+    }
+    return spans;
+}
+function replaceSpans(text, spans) {
+    let result = "";
+    let cursor = 0;
+    for (const [start, end] of spans) {
+        result += text.slice(cursor, start) + REDACTED;
+        cursor = end;
     }
-    return merged;
+    return result + text.slice(cursor);
+}
+const formsOf = (values) => [
+    ...new Set(values.filter((value) => value.length > 0).flatMap(encodedForms)),
+];
+/**
+ * A check that the text holds one of the values' forms outside the markers in any of its
+ * readingsOf. A scrub's output must pass it.
+ */
+export function holdsSecretValue(values) {
+    const forms = formsOf(values);
+    return (text) => readingsOf(text).some((reading) => occurrences(reading, forms).length > 0);
 }
 /**
  * A scrub that replaces each non-empty value and its encoded forms with `[REDACTED_SECRET]`. Every
@@ -108,19 +240,21 @@ function secretSpans(text, forms) {
  * through decodeEscapes, the decoder verify uses, and returns the decoded text: a warning with
  * percent-encoding, JSON escapes or HTML references shows them decoded, with the values removed.
  * That finds a value written partly encoded, which no single encoded form matches.
+ *
+ * The result's other readingsOf only detect. If one still holds a form, the scrub returns
+ * `[REDACTED_SECRET]` in place of the whole text. That happens for a value encoded twice, which
+ * the decoded text shows encoded once; for a value the UTF-8 or transfer reading holds, such as
+ * one with one of two non-ASCII characters percent-encoded; and for a value that holds part of a
+ * marker, such as `ET]x`, which the marker that replaced it can spell again.
  */
 export function scrubSecretValues(values) {
-    const forms = [...new Set(values.filter((value) => value.length > 0).flatMap(encodedForms))];
+    const forms = formsOf(values);
     if (forms.length === 0)
         return (text) => text;
+    const holds = holdsSecretValue(values);
     return (text) => {
         const decoded = decodeEscapes(text);
-        let result = "";
-        let cursor = 0;
-        for (const [start, end] of secretSpans(decoded, forms)) {
-            result += decoded.slice(cursor, start) + REDACTED;
-            cursor = end;
-        }
-        return result + decoded.slice(cursor);
+        const result = replaceSpans(decoded, merged(occurrences(decoded, forms)));
+        return holds(result) ? REDACTED : result;
     };
 }

package/dist/feedback/draft.d.ts

@@ -1,7 +1,7 @@
 import type { RunBundle, RunFeedbackCandidate } from "../run/bundle.js";
 import type { PreparedRunArtifactPaths } from "../run/paths.js";
 import { loadRunBundlePrepared } from "../run/locate.js";
-import { type RunNotes } from "../run/notes.js";
+import { type RunNotes } from "../run/note-files.js";
 export declare const FEEDBACK_SCHEMA = "humanish.feedback.v1";
 export interface FeedbackDraft {
     schema: typeof FEEDBACK_SCHEMA;

package/dist/feedback/draft.js

@@ -2,6 +2,7 @@
 // participant's feedback candidate or from a reviewed analysis finding, and its markdown rendering.
 // The commands that resolve the run and read or write drafts are in feedback.ts.
 import path from "node:path";
+import { findingLead } from "../analysis/finding-lead.js";
 import { analysisSharingProblems } from "../analysis/sharing.js";
 import { loadAnalysis } from "../analysis/load.js";
 import { hashAnalysisValue } from "../analysis/validation.js";
@@ -9,7 +10,9 @@ import { formatParticipantOutcomes, formatRunTaskFunnel, participantOutcomeDetai
 import { loadRunBundlePrepared } from "../run/locate.js";
 import { isFeedbackIdempotencyKey } from "../run/feedback-shape.js";
 import { runNoteFile } from "../run/note-files.js";
-import { formatRunTime, runParticipantCaptions } from "../run/notes.js";
+import { byRunTime } from "../run/note-shape.js";
+import { formatRunTime } from "../run/run-clock.js";
+import { runParticipantCaptions } from "../run/participant-records.js";
 import { isRecord } from "../run/type-guards.js";
 import { feedbackProofCommands, projectFeedbackAcceptanceProof } from "./proof.js";
 export const FEEDBACK_SCHEMA = "humanish.feedback.v1";
@@ -122,8 +125,10 @@ export async function buildAnalysisDraft(context, options) {
     const root = path.dirname(context.loaded.bundlePath);
     const evidenceIds = new Set(finding.observations.flatMap((item) => item.evidenceIds));
     const evidence = analysis.evidence.filter((item) => evidenceIds.has(item.id));
-    const amended = correction?.status === "amended";
-    const claim = amended ? correction.replacementClaim : (finding.headline ?? finding.title);
+    const lead = findingLead(finding, correction);
+    // An analysis written before headlines has no lead, so the amended claim or the title names it.
+    const amendedClaim = correction?.status === "amended" ? correction.replacementClaim : null;
+    const claim = lead?.headline ?? amendedClaim ?? finding.title;
     const firstLine = claim.trim().split(/\r?\n/)[0] || `Reviewed finding ${finding.id}`;
     const summary = Array.from(firstLine).length > 160
         ? Array.from(firstLine).slice(0, 159).join("") + "…"
@@ -147,19 +152,11 @@ export async function buildAnalysisDraft(context, options) {
         summary,
         expected: "Review the cited behavior against the participant assignment and confirm the expected product behavior.",
         actual: [
-            // The plain account leads; an amendment makes it stale, so the draft says so in its place.
-            ...(finding.headline === undefined
-                ? []
-                : amended
-                    ? [
-                        "This finding was corrected in human review. The reviewer's claim above replaces its original headline and account.",
-                        "",
-                    ]
-                    : finding.experience === undefined
-                        ? []
-                        : [finding.experience, ""]),
+            ...(lead?.account ? [lead.account, ""] : []),
             "Independent study analysis; does not replace participant feedback or recorded completion outcomes.",
-            amended ? `Amended claim: ${claim}. Original analysis: ${finding.summary}` : finding.summary,
+            amendedClaim === null
+                ? finding.summary
+                : `Amended claim: ${amendedClaim}. Original analysis: ${finding.summary}`,
             `Impact: ${finding.impact}. ${finding.affectedStreamIds.length} affected / ${finding.exposedStreamIds.length} observed exposed participants. ${finding.exposureReason}`,
             `Recovery: ${finding.recovery}. Confidence: ${finding.confidence}.`,
             ...finding.observations.map((item) => `${item.basis}: ${item.claim}${item.limitation ? ` Limitation: ${item.limitation}` : ""}`),
@@ -234,7 +231,7 @@ export function withReviewerNotes(draft, notes, bundle, runRoot) {
     if (notes === null || notes.notes.length === 0)
         return draft;
     const captions = runParticipantCaptions(bundle);
-    const ordered = [...notes.notes].sort((left, right) => left.atMs - right.atMs || left.createdAt.localeCompare(right.createdAt));
+    const ordered = byRunTime(notes.notes);
     return {
         ...draft,
         evidence: [

package/dist/feedback/export-bundle.js

@@ -10,18 +10,18 @@ import { renderObserver } from "../observer/render.js";
 import { buildObserverData } from "../observer/data.js";
 import { inventorySandboxIds, scrubSandboxIdBytes } from "../run/sandbox-ids.js";
 import { containsSensitive, redactSandboxIds, redactScreenshot, redactText, } from "../evidence/redaction.js";
-import { decodeEscapes, utf8ReadingOf } from "../evidence/encoded-text.js";
+import { decodeEscapes, readingsOf } from "../evidence/encoded-text.js";
 import { readPlainText } from "../evidence/plain-text.js";
-import { streamScreenshotPaths } from "../verify/artifacts.js";
+import { MAX_RUN_ENTRIES, streamScreenshotPaths } from "../verify/artifacts.js";
 import { verifyRunPrepared } from "../verify/verify.js";
 import { loadRunBundlePrepared, resolveRunPath } from "../run/locate.js";
 import {} from "../run/bundle.js";
 import { runIdOf, isPathInside, prepareRunArtifactPaths, validatePreparedRunArtifactPaths, } from "../run/paths.js";
 import { isAnalysisRecordPath } from "../analysis/sharing.js";
 import { LOCAL_ONLY_RUN_FILES } from "../run/local-only-files.js";
-import { assertPreparedSelectedOutputDirectory, prepareManagedHumanishOutputDirectory, prepareSelectedOutputDirectory, readContainedRegularFile, writeContainedOutputFile, } from "../run/contained-output.js";
+import { readUnchangedFile } from "../run/evidence-files.js";
+import { assertPreparedSelectedOutputDirectory, prepareManagedHumanishOutputDirectory, prepareSelectedOutputDirectory, writeContainedOutputFile, } from "../run/contained-output.js";
 const DERIVATION_SCHEMA = "humanish.redacted-derivation.v1";
-const MAX_FILES = 10_000;
 const TEXT_EXTENSIONS = new Set([
     ".json",
     ".ndjson",
@@ -69,8 +69,8 @@ async function inventory(root, maxBytes) {
         if (!before.isDirectory() || before.isSymbolicLink())
             throw new Error("Source contains an unsafe directory.");
         for (const name of (await readdir(directory)).sort()) {
-            if (++entriesSeen > MAX_FILES)
-                throw new Error(`Source exceeds ${MAX_FILES} inventory entries.`);
+            if (++entriesSeen > MAX_RUN_ENTRIES)
+                throw new Error(`Source exceeds ${MAX_RUN_ENTRIES} inventory entries.`);
             if (name.includes("\\") || name.includes("\0"))
                 throw new Error("Source contains an unsafe path segment.");
             const rel = relative ? `${relative}/${name}` : name;
@@ -86,15 +86,17 @@ async function inventory(root, maxBytes) {
             else {
                 if (path.extname(rel).toLowerCase() === ".mp4")
                     throw new Error("Continuous video/audio cannot be redacted by bundle export. Use --local-only HTML export for a snapshot-only copy.");
-                if (info.size > BigInt(maxBytes - total))
-                    throw new Error("Source inventory exceeds --max-bytes.");
-                const bytes = await readContainedRegularFile(root, rel);
-                if (bytes === null)
+                // At most what is left of --max-bytes, so a file that grows after this lstat is refused
+                // unread. With nothing left, an empty file still reads and any other is refused.
+                const read = await readUnchangedFile(root, rel, Math.max(1, maxBytes - total));
+                if (read.state === "unavailable")
                     throw new Error("Source artifact could not be read through its bound identity.");
-                total += bytes.length;
+                if (read.state === "limit")
+                    throw new Error("Source inventory exceeds --max-bytes.");
+                total += read.bytes.length;
                 if (total > maxBytes)
                     throw new Error("Source inventory exceeds --max-bytes.");
-                files.push({ path: rel, bytes, sha256: hash(bytes) });
+                files.push({ path: rel, bytes: read.bytes, sha256: hash(read.bytes) });
             }
         }
         const after = await lstat(directory, { bigint: true });
@@ -148,9 +150,9 @@ async function prospectivePhysicalPath(requested) {
 function assertNoInlineRaster(text) {
     // Decode the escapes verify decodes (decodeEscapes) before checking. Unknown embedded bytes are
     // refused: copying a text extension must not smuggle untransformed pixels.
-    const decoded = decodeEscapes(text);
-    if ([text, decoded, utf8ReadingOf(text, decoded) ?? ""].some(containsSensitive))
+    if (readingsOf(text).some(containsSensitive))
         throw new Error("Decoded text contains a secret-shaped value or private path; export refused.");
+    const decoded = decodeEscapes(text);
     if (/data\s*:\s*(?:image\/|application\/|text\/|[^,\s]*;base64,|,)/i.test(decoded) ||
         /iVBORw0KGgo|\/9j\/[A-Za-z0-9+/]|R0lGOD|UklGR[A-Za-z0-9+/]{4}|<svg\b/i.test(decoded)) {
         throw new Error("Text contains an inline image/data payload; embedded raster redaction is unsupported.");
@@ -541,10 +543,12 @@ async function buildDerivative(stage, source, runId, bundle, maxBytes) {
         throw new Error("Derivative Observer could not be rebuilt.");
     const generated = [];
     for (const relative of ["observer/index.html", "observer/observer-data.json"]) {
-        const bytes = await readContainedRegularFile(stagePaths, relative);
-        if (bytes === null)
+        const read = await readUnchangedFile(stagePaths, relative, maxBytes);
+        if (read.state === "limit")
+            throw new Error("The regenerated Observer exceeds --max-bytes.");
+        if (read.state === "unavailable")
             throw new Error("Regenerated Observer artifact could not be read safely.");
-        generated.push({ path: relative, sha256: hash(bytes) });
+        generated.push({ path: relative, sha256: hash(read.bytes) });
     }
     await writeContainedOutputFile(stagePaths, "derivation.json", jsonBytes({ ...receipt, generated }));
     const derivativeVerify = await verifyRunPrepared(stage.physicalPath, runId, stagePaths);

package/dist/feedback/export.js

@@ -19,7 +19,7 @@ import { verifyRun } from "../verify/verify.js";
 import {} from "../run/bundle.js";
 import { exportRedactedBundle } from "./export-bundle.js";
 import { loadAnalysis } from "../analysis/load.js";
-import { readNotesForSharing } from "../run/notes.js";
+import { readNotesForSharing } from "../run/note-files.js";
 import { cli } from "../cli/invocation.js";
 import { analysisSharingProblems } from "../analysis/sharing.js";
 import { EVIDENCE_LIMITS, validateAnalysisEvidence } from "../analysis/evidence.js";
@@ -288,7 +288,10 @@ function makePortable(inlined, verified) {
             }
         }
     }
-    // What verify said, in the file, so the chrome can agree with the result envelope.
+    recordShareSafety(inlined, verified);
+}
+/** What verify said, in the file, so the chrome can agree with the result envelope. */
+function recordShareSafety(inlined, verified) {
     const publicSafety = (inlined.publicSafety ?? {});
     inlined.publicSafety = {
         ...publicSafety,
@@ -299,6 +302,23 @@ function makePortable(inlined, verified) {
         },
     };
 }
+/**
+ * Adds a failed sharing check to verify's result. The reason joins verify's reasons and the status
+ * is the worse of the two, as verify grades an analysis. The export is refused unless --local-only,
+ * which writes the new status into the file.
+ */
+function applySharingProblem(verified, inlined, options, problem) {
+    verified.shareSafety = {
+        status: problem.status === "blocked" || verified.shareSafety.status === "blocked"
+            ? "blocked"
+            : "local_only",
+        reasons: [...verified.shareSafety.reasons, problem.reason],
+    };
+    if (options.localOnly !== true)
+        return "blocked";
+    recordShareSafety(inlined, verified);
+    return "downgraded";
+}
 /**
  * Revalidates the analysis against source evidence and its sharing checks. A failed check
  * downgrades share safety, which only --local-only may export.
@@ -322,24 +342,13 @@ async function recheckAnalysis(runPaths, analysis, verified, inlined, options) {
     const analysisSharing = analysisSharingProblems(analysis);
     if (!analysisSharing.sensitive && !analysisSharing.unverified)
         return "ok";
-    verified.shareSafety = {
+    return applySharingProblem(verified, inlined, options, {
         status: analysisSharing.sensitive ? "blocked" : "local_only",
-        reasons: [
-            ...verified.shareSafety.reasons,
-            {
-                code: "ANALYSIS_UNVERIFIED",
-                message: "The exact analysis snapshot being exported did not pass sharing checks.",
-            },
-        ],
-    };
-    if (options.localOnly !== true)
-        return "blocked";
-    inlined.publicSafety.share = {
-        status: verified.shareSafety.status,
-        verifiedAt: new Date().toISOString(),
-        reasons: verified.shareSafety.reasons.map((reason) => reason.code),
-    };
-    return "downgraded";
+        reason: {
+            code: "ANALYSIS_UNVERIFIED",
+            message: "The exact analysis snapshot being exported did not pass sharing checks.",
+        },
+    });
 }
 /**
  * The run's notes for the export, read once within the notes size limit. That snapshot is scanned
@@ -347,36 +356,13 @@ async function recheckAnalysis(runPaths, analysis, verified, inlined, options) {
  * reach the file unchecked. A finding blocks the export, or downgrades it under --local-only.
  */
 async function checkedNotes(runPaths, verified, inlined, options, warnings) {
-    const { notes, finding } = await readNotesForSharing(runPaths);
+    const { notes, problem } = await readNotesForSharing(runPaths);
     for (const skipped of notes.skipped)
         warnings.push(`Reviewer notes: ${skipped}`);
-    if (finding === null)
-        return { notes, check: "ok" };
-    verified.shareSafety = {
-        status: finding === "sensitive" || verified.shareSafety.status === "blocked"
-            ? "blocked"
-            : "local_only",
-        reasons: [
-            ...verified.shareSafety.reasons,
-            finding === "sensitive"
-                ? {
-                    code: "PUBLIC_SAFETY_FINDINGS",
-                    message: "The reviewer notes being exported match secret, token or local-path patterns.",
-                }
-                : {
-                    code: "UNSCANNED_ARTIFACT",
-                    message: "The reviewer notes being exported hold encoded text the scan cannot read.",
-                },
-        ],
-    };
-    if (options.localOnly !== true)
-        return { notes, check: "blocked" };
-    inlined.publicSafety.share = {
-        status: verified.shareSafety.status,
-        verifiedAt: new Date().toISOString(),
-        reasons: verified.shareSafety.reasons.map((reason) => reason.code),
+    return {
+        notes,
+        check: problem === null ? "ok" : applySharingProblem(verified, inlined, options, problem),
     };
-    return { notes, check: "downgraded" };
 }
 /** The portable Observer HTML, with the local-only banner when the export is watermarked. */
 function renderExportHtml(inlined, review, assets, verified, watermarked, omittedRecording) {