humanish 0.118.0 → 0.119.0

package/dist/analysis/responses.d.ts

@@ -0,0 +1,19 @@
+import type { RejectedAnalysisOutput } from "./diagnostics.js";
+import type { AnalysisProviderResult } from "./provider.js";
+import type { AnalysisArtifact, AnalysisConfig, AnalysisInput, AnalysisResult } from "./types.js";
+export type CheckedProviderAnalysis = {
+    ok: true;
+    result: AnalysisResult;
+} | {
+    ok: false;
+    error: string;
+    rejected?: RejectedAnalysisOutput;
+};
+export declare function checkProviderAnalysis(input: AnalysisInput, value: unknown): CheckedProviderAnalysis;
+/**
+ * Copy the reported tokens of every response onto the artifact, summed. OpenAI usage is priced with
+ * each response as its own request, since the long-context tier re-prices one request at a time.
+ */
+export declare function recordProviderUsage(artifact: AnalysisArtifact, config: AnalysisConfig, responses: readonly AnalysisProviderResult[]): void;
+/** The warnings a Codex response carries about its CLI release and protocol. */
+export declare function codexWarnings(config: AnalysisConfig, response: AnalysisProviderResult): string[];

package/dist/analysis/responses.js

@@ -0,0 +1,201 @@
+// What the provider responses of one attempt give it: the usage they report, the warnings a Codex
+// response carries, and each response checked before it becomes an analysis result (the response
+// schema, the scrub of known transient values from generated prose, and the evidence rules in
+// validation.ts). Only an allowlisted code leaves a check; the rejected output goes to the caller
+// for local diagnosis.
+import { truncatedFrameWarning, unknownNotificationsWarning, } from "../actors/codex/restricted-notifications.js";
+import { protocolAdditionsWarning, protocolIncompatibilityMessage, } from "../actors/codex/protocol-compat.js";
+import { estimateActorCost } from "../run/pricing.js";
+import { transientCommsKnownValueScrub } from "../run/transient-comms-secrets.js";
+import { analysisResponseSchema, checkAnalysisResult } from "./validation.js";
+/** Scrub only generated prose. Source evidence, provenance and integrity hashes remain exact. A
+ * known value is found as written and in its encoded forms. */
+function scrubGeneratedNarrative(result) {
+    const scrub = transientCommsKnownValueScrub();
+    const observation = (value) => ({
+        ...value,
+        claim: scrub(value.claim),
+        limitation: scrub(value.limitation),
+    });
+    // A model can also echo a key as a syntactically valid finding ID. Refuse it without rewriting
+    // IDs, references or enums (including accidental collisions); never repair citation structure.
+    const structural = [
+        ...result.participants.flatMap((value) => [
+            value.streamId,
+            value.outcome,
+            ...value.evidenceIds,
+            ...value.feedback.map((quote) => quote.evidenceId),
+        ]),
+        ...result.findings.flatMap((value) => [
+            value.id,
+            value.impact,
+            value.recovery,
+            value.confidence,
+            ...value.affectedStreamIds,
+            ...value.exposedStreamIds,
+            ...value.observations.flatMap((item) => [item.basis, ...item.evidenceIds]),
+        ]),
+        ...(result.designFindings ?? []).flatMap((value) => [
+            value.id,
+            value.severity,
+            value.confidence,
+            ...value.seenByStreamIds,
+            ...value.evidenceIds,
+        ]),
+        ...(result.concernReviews ?? []).flatMap((value) => [
+            value.basis,
+            value.disposition,
+            ...(value.findingId === null ? [] : [value.findingId]),
+            ...value.evidenceIds,
+        ]),
+    ];
+    if (structural.some((value) => scrub(value) !== value))
+        throw new Error("ANALYSIS_TRANSIENT_SECRET_IN_STRUCTURE");
+    return {
+        ...result,
+        summary: scrub(result.summary),
+        limitations: result.limitations.map(scrub),
+        participants: result.participants.map((value) => ({
+            ...value,
+            summary: scrub(value.summary),
+            intent: scrub(value.intent),
+            outcomeReason: scrub(value.outcomeReason),
+            limitations: value.limitations.map(scrub),
+            feedback: value.feedback.map((quote) => ({ ...quote, text: scrub(quote.text) })),
+        })),
+        findings: result.findings.map((value) => ({
+            ...value,
+            title: scrub(value.title),
+            ...(value.headline === undefined ? {} : { headline: scrub(value.headline) }),
+            ...(value.experience === undefined ? {} : { experience: scrub(value.experience) }),
+            summary: scrub(value.summary),
+            exposureReason: scrub(value.exposureReason),
+            nextStep: scrub(value.nextStep),
+            priorityReason: scrub(value.priorityReason),
+            observations: value.observations.map(observation),
+        })),
+        ...(result.designFindings === undefined
+            ? {}
+            : {
+                designFindings: result.designFindings.map((value) => ({
+                    ...value,
+                    headline: scrub(value.headline),
+                    screen: scrub(value.screen),
+                    notice: scrub(value.notice),
+                    whyItMatters: scrub(value.whyItMatters),
+                    suggestion: scrub(value.suggestion),
+                })),
+            }),
+        ...(result.concernReviews === undefined
+            ? {}
+            : {
+                concernReviews: result.concernReviews.map((value) => ({
+                    ...observation(value),
+                    reason: scrub(value.reason),
+                })),
+            }),
+    };
+}
+const VALIDATION_FAILURES = Object.freeze({
+    ANALYSIS_RESULT_SCHEMA_INVALID: "analysis_validation_failed_schema_invalid",
+    ANALYSIS_DESIGN_FINDING_ID_DUPLICATE: "analysis_validation_failed_design_finding_id_duplicate",
+    ANALYSIS_DESIGN_REFERENCE_INVALID: "analysis_validation_failed_design_reference_invalid",
+    ANALYSIS_DESIGN_WITHOUT_CAPTURE: "analysis_validation_failed_design_without_capture",
+    ANALYSIS_DESIGN_MEMBERSHIP_INVALID: "analysis_validation_failed_design_membership_invalid",
+    ANALYSIS_INPUT_DUPLICATES: "analysis_validation_failed_input_duplicates",
+    ANALYSIS_PARTICIPANT_COVERAGE_INVALID: "analysis_validation_failed_participant_coverage_invalid",
+    ANALYSIS_PARTICIPANT_REFERENCE_INVALID: "analysis_validation_failed_participant_reference_invalid",
+    ANALYSIS_OUTCOME_WITHOUT_EVIDENCE: "analysis_validation_failed_outcome_without_evidence",
+    ANALYSIS_QUOTE_INVALID: "analysis_validation_failed_quote_invalid",
+    ANALYSIS_FINDING_ID_DUPLICATE: "analysis_validation_failed_finding_id_duplicate",
+    ANALYSIS_OBSERVATION_REFERENCE_INVALID: "analysis_validation_failed_observation_reference_invalid",
+    ANALYSIS_VISUAL_WITHOUT_CAPTURE: "analysis_validation_failed_visual_without_capture",
+    ANALYSIS_ACTION_SOURCE_INVALID: "analysis_validation_failed_action_source_invalid",
+    ANALYSIS_STATEMENT_SOURCE_INVALID: "analysis_validation_failed_statement_source_invalid",
+    ANALYSIS_FINDING_MEMBERSHIP_INVALID: "analysis_validation_failed_finding_membership_invalid",
+    ANALYSIS_AFFECTED_WITHOUT_EVIDENCE: "analysis_validation_failed_affected_without_evidence",
+    ANALYSIS_CONCERN_FINDING_INVALID: "analysis_validation_failed_concern_finding_invalid",
+});
+export function checkProviderAnalysis(input, value) {
+    try {
+        const parsed = analysisResponseSchema.safeParse(value);
+        if (!parsed.success) {
+            const error = VALIDATION_FAILURES.ANALYSIS_RESULT_SCHEMA_INVALID;
+            return { ok: false, error, rejected: { error, errors: [], output: value } };
+        }
+        let scrubbed;
+        try {
+            scrubbed = scrubGeneratedNarrative(parsed.data);
+        }
+        catch (error) {
+            if (!(error instanceof Error && error.message === "ANALYSIS_TRANSIENT_SECRET_IN_STRUCTURE"))
+                return { ok: false, error: "analysis_validation_failed_unexpected" };
+            const rejected = "analysis_validation_failed_scrub_rejected";
+            return {
+                ok: false,
+                error: rejected,
+                rejected: { error: rejected, errors: [], output: value },
+            };
+        }
+        const checked = checkAnalysisResult(input, scrubbed);
+        if (!checked.ok) {
+            const error = VALIDATION_FAILURES[checked.errors[0] ?? ""] ?? "analysis_validation_failed_unexpected";
+            return {
+                ok: false,
+                error,
+                rejected: { error, errors: [...checked.errors], output: scrubbed },
+            };
+        }
+        return checked;
+    }
+    catch {
+        return { ok: false, error: "analysis_validation_failed_unexpected" };
+    }
+}
+/**
+ * Copy the reported tokens of every response onto the artifact, summed. OpenAI usage is priced with
+ * each response as its own request, since the long-context tier re-prices one request at a time.
+ */
+export function recordProviderUsage(artifact, config, responses) {
+    const { usage } = artifact;
+    usage.dispatched = responses.some((response) => response.dispatched);
+    const turns = responses.flatMap((response) => (response.usage ? [response.usage] : []));
+    if (turns.length === 0)
+        return;
+    const total = (key) => turns.some((turn) => turn[key] !== undefined)
+        ? turns.reduce((sum, turn) => sum + (turn[key] ?? 0), 0)
+        : undefined;
+    const tokens = {
+        input: total("input"),
+        output: total("output"),
+        ...(total("cachedInput") === undefined ? {} : { cachedInput: total("cachedInput") }),
+        ...(total("cacheWriteInput") === undefined
+            ? {}
+            : { cacheWriteInput: total("cacheWriteInput") }),
+    };
+    const priced = config.provider === "codex"
+        ? { estimatedCostUsd: null, ratesAsOf: null }
+        : estimateActorCost({ ...tokens, turns }, config.model);
+    usage.inputTokens = tokens.input;
+    usage.outputTokens = tokens.output;
+    usage.cachedInputTokens = tokens.cachedInput ?? null;
+    usage.cacheWriteInputTokens = tokens.cacheWriteInput ?? null;
+    usage.usageComplete = responses.every((response) => !response.dispatched ||
+        (response.usage !== null && (response.usageComplete ?? config.provider !== "codex")));
+    usage.estimatedCostUsd = priced.estimatedCostUsd;
+    usage.ratesAsOf = priced.ratesAsOf;
+}
+/** The warnings a Codex response carries about its CLI release and protocol. */
+export function codexWarnings(config, response) {
+    if (config.provider !== "codex")
+        return [];
+    const { cliVersion } = config.identity;
+    return [
+        response.protocolIncompatibilities === undefined
+            ? undefined
+            : protocolIncompatibilityMessage(cliVersion, response.protocolIncompatibilities),
+        protocolAdditionsWarning(cliVersion, response.protocolAdditions),
+        unknownNotificationsWarning(response.unknownNotifications, cliVersion),
+        truncatedFrameWarning(response.truncatedFrameBytes),
+    ].filter((warning) => warning !== undefined);
+}

package/dist/analysis/store.js

@@ -10,7 +10,8 @@ import { ANALYSIS_ID_PATTERN, } from "./types.js";
 import { RUN_BUNDLE_FILE } from "../run/bundle.js";
 export const ANALYSIS_DIRECTORY = "analysis";
 export const ANALYSIS_EXECUTION_DIRECTORY = "analysis-attempts";
-export const ANALYSIS_MAX_BYTES = 4 * 1024 * 1024;
+// 4 MiB held one packet; a run of 128 participants stores eight cohorts' packets.
+export const ANALYSIS_MAX_BYTES = 16 * 1024 * 1024;
 export const MAX_VERSIONS = 256;
 const MAX_CORRECTIONS = 256;
 const MAX_CORRECTION_BYTES = 32 * 1024;

package/dist/analysis/validation.js

@@ -2,7 +2,7 @@ import { validStoredCodexAnalysisConfig } from "./codex-config.js";
 import { createHash } from "node:crypto";
 import { z } from "zod";
 import { ACTOR_STATUSES, ACTOR_STOP_CAUSES } from "../actors/contract.js";
-import { ANALYSIS_LIMITS, hasControlCharacter, hasRevisionFields } from "./analysis-limits.js";
+import { ANALYSIS_LIMITS, EVIDENCE_LIMITS, MAX_ANALYSIS_COHORTS, hasControlCharacter, hasRevisionFields, } from "./analysis-limits.js";
 import { SHA256_HEX_PATTERN, ACTION_CAPTURE_VERSION, ANALYSIS_SCHEMA, ANALYSIS_CORRECTION_SCHEMA, } from "./types.js";
 const text = (max) => z
     .string()
@@ -17,7 +17,7 @@ const id = z
 const sourceId = text(256).min(1);
 const digest = z.string().regex(SHA256_HEX_PATTERN);
 const timestamp = z.string().datetime({ offset: true });
-const sourceIds = z.array(sourceId).max(128);
+const sourceIds = z.array(sourceId).max(EVIDENCE_LIMITS.participants);
 const refs = z.array(id).min(1).max(ANALYSIS_LIMITS.evidenceRefs);
 const limitations = z.array(text(2000).min(1)).max(100);
 const observationSchema = z
@@ -60,7 +60,7 @@ const analysisResultSchema = z
         limitations,
     })
         .strict())
-        .max(128),
+        .max(EVIDENCE_LIMITS.participants),
     findings: z
         .array(z
         .object({
@@ -116,12 +116,18 @@ const normalizedResult = ({ concernReviews, designFindings, findings, ...result
     ...(designFindings === undefined ? {} : { designFindings }),
     ...(concernReviews === undefined ? {} : { concernReviews }),
 });
+// A run's packet holds every cohort's packet.
+const MAX_PACKET_EVIDENCE = EVIDENCE_LIMITS.evidence * MAX_ANALYSIS_COHORTS;
 const analysisCoverageSchema = z
     .object({
     includedStreamIds: sourceIds,
     omittedStreamIds: sourceIds,
-    evidenceCount: z.number().int().min(0).max(2000),
-    captureCount: z.number().int().min(0).max(64),
+    evidenceCount: z.number().int().min(0).max(MAX_PACKET_EVIDENCE),
+    captureCount: z
+        .number()
+        .int()
+        .min(0)
+        .max(EVIDENCE_LIMITS.captures * MAX_ANALYSIS_COHORTS),
     complete: z.boolean(),
     omissions: limitations,
 })
@@ -264,9 +270,9 @@ const analysisArtifactSchema = z
         provenance: analysisParticipantProvenanceSchema,
     })
         .strict())
-        .max(128),
+        .max(EVIDENCE_LIMITS.participants),
     coverage: analysisCoverageSchema,
-    evidence: z.array(analysisEvidenceSchema).max(2000),
+    evidence: z.array(analysisEvidenceSchema).max(MAX_PACKET_EVIDENCE),
     result: analysisResultSchema.nullable(),
     error: z
         .string()

package/dist/cli/commands/analyze.js

@@ -1,4 +1,4 @@
-import { resolveAutomaticAnalysis, DEFAULT_ANALYSIS_MODEL, DEFAULT_ANALYSIS_TIMEOUT_MS, } from "../../analysis/automatic-config.js";
+import { analysisRequestsText, resolveAutomaticAnalysis, DEFAULT_ANALYSIS_MODEL, DEFAULT_ANALYSIS_TIMEOUT_MS, } from "../../analysis/automatic-config.js";
 import { Command, Option } from "commander";
 import { forTerminal } from "../../routes/terminal/encoding.js";
 import { analyzeRun, correctAnalysis, dryRunBundleRefusal, showAnalysis, } from "../../analysis/service.js";
@@ -233,8 +233,13 @@ async function handleAnalyzeCorrect(io, options, command) {
         io.setExitCode(2);
     }
 }
-/** An admitted dry run's costs: the expected cost, the worst case and the cap it was admitted under. */
+/**
+ * An admitted dry run's costs: the expected cost, the worst case and the cap it was admitted
+ * under. The worst case of an analysis in cohorts is every request writing its whole allowance.
+ */
 function admittedDryRunText(admission) {
     const usd = (value) => value === null || value === undefined ? "unknown" : `$${value.toFixed(2)}`;
-    return `Expected cost: ${usd(admission?.estimatedCostUsd)}. Worst case: ${usd(admission?.worstCaseCostUsd)}, if the analyst writes its whole ${admission?.outputTokenAllowance ?? "unknown"}-token output allowance, reasoning included. Admitted under the $${admission?.maxCostUsd ?? "unknown"} cap. No request sent.\n`;
+    const requests = analysisRequestsText(admission?.requests ?? 1);
+    const writer = requests === undefined ? "the analyst writes its" : `every request (${requests}) writes its`;
+    return `Expected cost: ${usd(admission?.estimatedCostUsd)}. Worst case: ${usd(admission?.worstCaseCostUsd)}, if ${writer} whole ${admission?.outputTokenAllowance ?? "unknown"}-token output allowance, reasoning included. Admitted under the $${admission?.maxCostUsd ?? "unknown"} cap. No request sent.\n`;
 }

package/dist/cli/commands/study-route-computer-use.js

@@ -1,4 +1,4 @@
-import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
+import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
 import { Command } from "commander";
 import {} from "../../run-study.js";
 import { resolveStudyDryRun } from "../../study/plan.js";
@@ -237,7 +237,7 @@ async function reportCuaRun(args, prepared, result, live) {
         };
     }
     writeResult(args.command, args.io, output, (value) => formatCuaStudyHuman(value, args.config.subject));
-    args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
+    args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
     await writeRunFindings(args.command, args.io, args.options.cwd, result);
     if (server && (result.observer?.ok || attachedObserver)) {
         const followResult = output.observer?.ok

package/dist/cli/commands/study-route-scripted.js

@@ -1,4 +1,4 @@
-import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
+import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
 import { Command } from "commander";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { wantsJson, writeResult } from "../io.js";
@@ -35,7 +35,7 @@ export function scriptedRouteRun(args) {
             }
             const result = outcome.result;
             writeResult(args.command, args.io, result, (value) => formatScriptedStudyHuman(value, args.config.subject));
-            args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
+            args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
             await writeRunFindings(args.command, args.io, args.options.cwd, result);
             // Watch mode serves the Observer the route rendered through its finished run.
             if (finishedPlan !== undefined && result.ok && result.observer !== undefined) {

package/dist/cli/commands/study-route-shared-world.js

@@ -1,4 +1,4 @@
-import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
+import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
 import { Command } from "commander";
 import { resolveStudyDryRun } from "../../study/plan.js";
 import { serveObserver } from "../../observer/render.js";
@@ -121,7 +121,7 @@ export function sharedWorldRouteRun(args) {
                 };
             }
             writeResult(args.command, args.io, output, formatConcurrentSharedWorldStudyHuman);
-            args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
+            args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
             await writeRunFindings(args.command, args.io, args.options.cwd, result);
             if (server && output.observer?.ok) {
                 await followObserver(args.io, output.observer, server);

package/dist/cli/commands/study-route-terminal.js

@@ -1,4 +1,4 @@
-import { studyAnalysisSucceeded } from "../../study/automatic-analysis-plan.js";
+import { automaticAnalysisSucceeded } from "../../analysis/automatic-completion.js";
 import { Command } from "commander";
 import { cliAnalysisOptions } from "./analysis-signals.js";
 import { wantsJson, writeResult } from "../io.js";
@@ -35,7 +35,7 @@ export function terminalRouteRun(args) {
             }
             const result = outcome.result;
             writeResult(args.command, args.io, result, formatTerminalStudyHuman);
-            args.io.setExitCode(result.ok && studyAnalysisSucceeded(result) ? 0 : 2);
+            args.io.setExitCode(result.ok && automaticAnalysisSucceeded(result) ? 0 : 2);
             await writeRunFindings(args.command, args.io, args.options.cwd, result);
             if (finishedPlan !== undefined && result.ok && result.observer !== undefined) {
                 await showObserver({

package/dist/cli/commands/study-run.js

@@ -2,7 +2,7 @@ import { resolve } from "node:path";
 import { Command } from "commander";
 import { deriveRunFacts } from "../telemetry.js";
 import { resolveStudyManifest } from "../../study/discover.js";
-import { formatStudyAnalysisBudget, studyAnalysisBudget, } from "../../study/automatic-analysis-plan.js";
+import { automaticAnalysisBudget, formatAutomaticAnalysisBudget, } from "../../analysis/automatic-config.js";
 import { warnAndQueue } from "../deprecations.js";
 import { planStudy, resolveStudyDryRun } from "../../study/plan.js";
 import { keyNamesOf } from "../../study/requirements.js";
@@ -131,9 +131,9 @@ export async function runStudyCommand(args) {
                 // Surface it so the invoker (who may not be the manifest author) knows executable code ran.
                 args.io.writeErr(`warning: review scorer ${scorer.provenance.ref} (${scorer.provenance.source}) is code that humanish loaded and ran in this process. Review it as you would any code you run.\n`);
             }
-            const analysisBudget = studyAnalysisBudget(config.review?.analysis, route, computerUseParticipantCount(config));
+            const analysisBudget = automaticAnalysisBudget(config.review?.analysis, route, computerUseParticipantCount(config));
             if (analysisBudget && resolveStudyDryRun(config, args.options.dryRun, true) === false) {
-                args.io.writeErr(`${formatStudyAnalysisBudget(analysisBudget)}\n`);
+                args.io.writeErr(`${formatAutomaticAnalysisBudget(analysisBudget)}\n`);
             }
             return scorer === undefined ? {} : { scorer };
         }, 

package/dist/cli/commands/study.js

@@ -1,4 +1,4 @@
-import { formatStudyAnalysisBudget } from "../../study/automatic-analysis-plan.js";
+import { formatAutomaticAnalysisBudget } from "../../analysis/automatic-config.js";
 import { resolve } from "node:path";
 import { Command, Option } from "commander";
 import { inspectStudyManifest, listStudyManifests } from "../../study/discover.js";
@@ -136,7 +136,7 @@ function formatStudyCheckHuman(result) {
         `targets: ${checkedTargets.length ? `${reachableTargets.length}/${checkedTargets.length} reachable` : `${result.targets.length} declared, not checked`}`,
         ...(blockedTargets.length ? [`blocked-targets: ${blockedTargets.length}`] : []),
         `spend: ${result.spend.e2bDesktop ? "one e2b desktop, no model calls" : "none"}`,
-        ...(result.analysis ? [formatStudyAnalysisBudget(result.analysis)] : []),
+        ...(result.analysis ? [formatAutomaticAnalysisBudget(result.analysis)] : []),
         ...(result.sandbox.created
             ? [`sandbox: created=yes killed=${result.sandbox.killed === true ? "yes" : "no"}`]
             : []),

package/dist/cli/io.js

@@ -1,10 +1,10 @@
+import { automaticAnalysisSucceeded, } from "../analysis/automatic-completion.js";
 import { costRefusal, refusedCost } from "../analysis/admission.js";
 import { Command, Option } from "commander";
 import { loadEnvFile, recordDotenvNames } from "../keys/env-file.js";
 import { discoverProviderKeys } from "../keys/key-resolution.js";
 import { deriveRunFacts } from "./telemetry.js";
 import { warnAndQueue, withQueuedWarnings } from "./deprecations.js";
-import { PARTICIPANT_LIMIT_SKIP, PARTICIPANT_LIMIT_SKIP_TEXT, studyAnalysisSucceeded, } from "../study/automatic-analysis-plan.js";
 import { forTerminal } from "../routes/terminal/encoding.js";
 import { cli } from "./invocation.js";
 export const CLI_RESPONSE_SCHEMA = "humanish.cli-response.v1";
@@ -295,7 +295,6 @@ const ANALYSIS_REASON_TEXT = {
     AUTOMATIC_ANALYSIS_BUSY: "skipped because another analysis is running",
     AUTOMATIC_ANALYSIS_ADMISSION_REFUSED: "refused before it started: its configuration, question, evidence or cost did not pass admission",
     AUTOMATIC_ANALYSIS_CLEANUP_UNCONFIRMED: "not started because the run's cleanup was not confirmed",
-    [PARTICIPANT_LIMIT_SKIP]: PARTICIPANT_LIMIT_SKIP_TEXT,
     AUTOMATIC_ANALYSIS_REUSED: "complete, reusing an earlier analysis of the same evidence",
     AUTOMATIC_ANALYSIS_LIMITATIONS: "partial, because it covered only part of the evidence",
     AUTOMATIC_ANALYSIS_ADMISSION_EXCEEDED: "partial, because it went over its estimated cost or output",
@@ -321,5 +320,5 @@ export function automaticAnalysisEnvelope(result) {
         !("ok" in result))
         return result;
     const run = result;
-    return { ...run, runOk: run.ok, ok: run.ok && studyAnalysisSucceeded(run) };
+    return { ...run, runOk: run.ok, ok: run.ok && automaticAnalysisSucceeded(run) };
 }