@markstanden/opencode-test-container 0.0.0-stage → 0.1.0

package/dist/evaluators/skills/assess.d.ts

@@ -0,0 +1,94 @@
+import type { SuiteCase } from "../../contracts/types.ts";
+import { type Usage } from "../../adapters/opencode/events.ts";
+/** The evidence states the evaluator can establish. */
+export type SkillValidity = "valid" | "invalid" | "unknown" | "unrun";
+/** What the trail showed, independent of the expected outcome. */
+export type SkillObservation = "target-activation" | "attempted-target-load" | "failed-target-load" | "other-skill-only" | "no-invocation";
+/** The criterion verdict. */
+export type SkillOutcome = "pass" | "fail" | "unknown";
+/** Exact counts, never collapsed into a single score. */
+export interface SkillCounts {
+    /** The requested target value. */
+    requestedTarget: number;
+    /** The successful target value. */
+    successfulTarget: number;
+    /** The failed target value. */
+    failedTarget: number;
+    /** The other skill value. */
+    otherSkill: number;
+    /** The total skill calls value. */
+    totalSkillCalls: number;
+}
+/** The deterministic assessment of one skill-trigger trial. */
+export interface SkillAssessment {
+    /** The schema version value. */
+    schemaVersion: 1;
+    /** The kind value. */
+    kind: "skill-activation";
+    /** The campaign id value. */
+    campaignId: string;
+    /** The slot id value. */
+    slotId: string;
+    /** The case id value. */
+    caseId: string;
+    /** The arm id value. */
+    armId: string;
+    /** The repetition id value. */
+    repetitionId: string;
+    /** The attempt id value. */
+    attemptId: string;
+    /** The target skill id value. */
+    targetSkillId: string;
+    /** The expected value. */
+    expected: "activation" | "no-activation";
+    /** The validity value. */
+    validity: SkillValidity;
+    /** The observed value. */
+    observed: SkillObservation | "unrun";
+    /** The outcome value. */
+    outcome: SkillOutcome;
+    /** The counts value. */
+    counts: SkillCounts;
+    /** The body routes value. */
+    bodyRoutes: string[];
+    /** The contaminated value. */
+    contaminated: boolean;
+    /** The reasons value. */
+    reasons: string[];
+    /** The usage value. */
+    usage: Usage | null;
+    /** The answered value. */
+    answered: boolean;
+    /** The assessed at value. */
+    assessedAt: string;
+}
+/**
+ * Assess one skill-trigger trial from checked evidence. Capture validity and
+ * criterion outcome are distinct: a complete run with no target activation is
+ * an observed negative; an unreadable or failed load is unknown, never a
+ * passing negative.
+ * @param options Trial identity, case definition and its evidence directory.
+ * @returns The assessment.
+ * @param options.campaignId The campaignId value.
+ * @param options.slotId The slotId value.
+ * @param options.caseId The caseId value.
+ * @param options.armId The armId value.
+ * @param options.repetitionId The repetitionId value.
+ * @param options.testCase The testCase value.
+ * @param options.trialDir The trialDir value.
+ * @param options.attemptId The attemptId value.
+ * @param options.assessedAt The assessedAt value.
+ */
+export declare function assessSkillTrial(options: {
+    campaignId: string;
+    slotId: string;
+    caseId: string;
+    armId: string;
+    repetitionId: string;
+    testCase: Extract<SuiteCase, {
+        kind: "skill-trigger";
+    }>;
+    trialDir: string;
+    attemptId: string;
+    assessedAt: string;
+}): SkillAssessment;

package/dist/evaluators/skills/assess.js

@@ -0,0 +1,207 @@
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+import { bodyRoutes, captureProblems, decodeTrail, skillCalls, } from "../../adapters/opencode/events.js";
+import { isRecord } from "../../contracts/validate.js";
+/** The zeroed count block. */
+function emptyCounts() {
+    return {
+        requestedTarget: 0,
+        successfulTarget: 0,
+        failedTarget: 0,
+        otherSkill: 0,
+        totalSkillCalls: 0,
+    };
+}
+/** Split skill calls into target and other counts. */
+function countsOf(calls, targetSkillId) {
+    const counts = emptyCounts();
+    for (const call of calls) {
+        counts.totalSkillCalls += 1;
+        if (call.requestedId !== targetSkillId) {
+            if (call.loaded)
+                counts.otherSkill += 1;
+            continue;
+        }
+        counts.requestedTarget += 1;
+        if (call.loaded)
+            counts.successfulTarget += 1;
+        else
+            counts.failedTarget += 1;
+    }
+    return counts;
+}
+/** Read a trial meta record without trusting it. */
+function readMeta(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return isRecord(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** Read the usage record, or null when absent/malformed. */
+function readUsage(path) {
+    if (!existsSync(path))
+        return null;
+    try {
+        const value = JSON.parse(readFileSync(path, "utf8"));
+        return isRecord(value) ? value : null;
+    }
+    catch {
+        return null;
+    }
+}
+/** An unrun assessment with no usable evidence. */
+function unrunAssessment(base, reason, assessedAt) {
+    return {
+        ...base,
+        validity: "unrun",
+        observed: "unrun",
+        outcome: "unknown",
+        counts: emptyCounts(),
+        bodyRoutes: [],
+        contaminated: false,
+        reasons: [reason],
+        usage: null,
+        answered: false,
+        assessedAt,
+    };
+}
+/** Capture integrity problems from meta and the decoded trail. */
+function skillIntegrity(meta, trail) {
+    const integrity = [...captureProblems(trail)];
+    if (meta.captureValid !== true)
+        integrity.push(...(meta.captureProblems ?? []));
+    if (meta.exit !== 0)
+        integrity.push(`container exited ${String(meta.exit)}`);
+    if (meta.timedOut)
+        integrity.push("container timed out");
+    return integrity;
+}
+/** The observed state independent of expectation. */
+function observationOf(counts) {
+    if (counts.successfulTarget > 0)
+        return "target-activation";
+    if (counts.otherSkill > 0)
+        return "other-skill-only";
+    return "no-invocation";
+}
+/** The criterion outcome for a valid observation. */
+function outcomeOf(expected, counts) {
+    const activated = counts.successfulTarget > 0;
+    return (expected === "activation") === activated ? "pass" : "fail";
+}
+/**
+ * Assess one skill-trigger trial from checked evidence. Capture validity and
+ * criterion outcome are distinct: a complete run with no target activation is
+ * an observed negative; an unreadable or failed load is unknown, never a
+ * passing negative.
+ * @param options Trial identity, case definition and its evidence directory.
+ * @returns The assessment.
+ * @param options.campaignId The campaignId value.
+ * @param options.slotId The slotId value.
+ * @param options.caseId The caseId value.
+ * @param options.armId The armId value.
+ * @param options.repetitionId The repetitionId value.
+ * @param options.testCase The testCase value.
+ * @param options.trialDir The trialDir value.
+ * @param options.attemptId The attemptId value.
+ * @param options.assessedAt The assessedAt value.
+ */
+export function assessSkillTrial(options) {
+    const { testCase, trialDir } = options;
+    const meta = readMeta(join(trialDir, "meta.json"));
+    const base = {
+        schemaVersion: 1,
+        kind: "skill-activation",
+        campaignId: options.campaignId,
+        slotId: options.slotId,
+        caseId: options.caseId,
+        armId: options.armId,
+        repetitionId: options.repetitionId,
+        attemptId: options.attemptId,
+        targetSkillId: testCase.targetSkillId,
+        expected: testCase.expected,
+    };
+    if (meta === null) {
+        return unrunAssessment(base, "trial meta is missing or unreadable", options.assessedAt);
+    }
+    if (!existsSync(join(trialDir, "events.jsonl"))) {
+        return unrunAssessment(base, "trial event stream is missing", options.assessedAt);
+    }
+    const trail = decodeTrail(readFileSync(join(trialDir, "events.jsonl"), "utf8"));
+    const calls = skillCalls(trail);
+    const counts = countsOf(calls, testCase.targetSkillId);
+    const routes = bodyRoutes(trail, testCase.targetSkillId);
+    const contamination = routes.length > 0;
+    const integrity = skillIntegrity(meta, trail);
+    if (integrity.length > 0) {
+        return {
+            ...base,
+            validity: "invalid",
+            observed: "unrun",
+            outcome: "unknown",
+            counts,
+            bodyRoutes: routes,
+            contaminated: contamination,
+            reasons: integrity,
+            usage: readUsage(join(trialDir, "usage.json")),
+            answered: trail.text.trim() !== "",
+            assessedAt: options.assessedAt,
+        };
+    }
+    if (contamination && testCase.contamination !== "record") {
+        return {
+            ...base,
+            validity: "invalid",
+            observed: counts.successfulTarget > 0
+                ? "target-activation"
+                : "no-invocation",
+            outcome: "unknown",
+            counts,
+            bodyRoutes: routes,
+            contaminated: true,
+            reasons: [
+                `the target body was reached through ${routes.join(", ")}, not a skill-tool activation`,
+            ],
+            usage: readUsage(join(trialDir, "usage.json")),
+            answered: trail.text.trim() !== "",
+            assessedAt: options.assessedAt,
+        };
+    }
+    if (counts.failedTarget > 0) {
+        return {
+            ...base,
+            validity: "unknown",
+            observed: "failed-target-load",
+            outcome: "unknown",
+            counts,
+            bodyRoutes: routes,
+            contaminated: contamination,
+            reasons: [
+                "the target skill load failed; successful activation is unknown",
+            ],
+            usage: readUsage(join(trialDir, "usage.json")),
+            answered: trail.text.trim() !== "",
+            assessedAt: options.assessedAt,
+        };
+    }
+    const observed = observationOf(counts);
+    const outcome = outcomeOf(testCase.expected, counts);
+    return {
+        ...base,
+        validity: "valid",
+        observed,
+        outcome,
+        counts,
+        bodyRoutes: routes,
+        contaminated: contamination,
+        reasons: [],
+        usage: readUsage(join(trialDir, "usage.json")),
+        answered: trail.text.trim() !== "",
+        assessedAt: options.assessedAt,
+    };
+}

package/dist/index.d.ts

@@ -0,0 +1,46 @@
+/**
+ * @markstanden/opencode-test-container
+ *
+ * Public modules are re-exported here for programmatic use. The supported
+ * consumer surface is the `otc` CLI; these exports exist so tests and
+ * evaluators can exercise the same lifecycle without a shell.
+ */
+export { canonicalJson, sha256Bytes, sha256Of } from "./contracts/canonical.ts";
+export { EVALUATOR_VERSION, PACKAGE_NAME, packageVersion, toolIdentity, } from "./contracts/version.ts";
+export type { ToolIdentity } from "./contracts/version.ts";
+export type { Arm, AssessmentKind, Campaign, CampaignBundle, DocsTaskCase, ExpectedDocs, LifecycleState, PrimaryCheckSpec, ProviderRoute, RecoveryDeclaration, RuntimeSpec, SkillTriggerCase, Slot, Suite, SuiteCase, } from "./contracts/types.ts";
+export { ID_PATTERN, isId, isSafeRelativePath, loadCampaignBundle, validateBundle, validateCampaign, validateSuite, } from "./contracts/validate.ts";
+export { DEFAULT_PLUGIN_INCLUDE, loadPreparedManifest, manifestSha256, normaliseCampaign, prepareCampaign, preparedDifferences, } from "./campaign/prepare.ts";
+export type { PreparedManifest, StagedArm } from "./campaign/prepare.ts";
+export { deliveryCheck, freezeCampaign, freezeDifferences, freezeIdentity, loadFrozen, } from "./campaign/freeze.ts";
+export type { FrozenRecord } from "./campaign/freeze.ts";
+export { appendLedgerEvent, launchRefusal, parseLedger, readLedger, trialStarts, } from "./campaign/ledger.ts";
+export type { LedgerEvent, LedgerRead } from "./campaign/ledger.ts";
+export { launchSha256, planTrial, runCampaign, trialDirectory, } from "./campaign/run.ts";
+export type { RunSummary, TrialMeta } from "./campaign/run.ts";
+export { judgeCampaign, buildJudgePacketForSlot, checkedSelection, checkedSelectionForSlot, readJudgeAttempts, readSelectedJudgement, selectionPath, } from "./campaign/judge.ts";
+export type { CheckedSelection, JudgeAttemptMeta, JudgeSummary, SelectedJudgement, StoredJudgement, } from "./campaign/judge.ts";
+export { executePrimaryCheck, primaryCheckPlan, readPrimaryCheck, } from "./campaign/primary.ts";
+export type { PrimaryCheckRecord } from "./campaign/primary.ts";
+export { assessCampaign, assessmentPath, readAssessments, } from "./campaign/assess.ts";
+export type { StoredAssessment } from "./campaign/assess.ts";
+export { closeCampaign } from "./campaign/close.ts";
+export { statusOf } from "./campaign/status.ts";
+export type { StatusReport } from "./campaign/status.ts";
+export { analyseCampaign, reportIdentity, reportIntact, } from "./reporting/report.ts";
+export type { Report } from "./reporting/report.ts";
+export { decodeTrail, captureProblems, skillCalls, } from "./adapters/opencode/events.ts";
+export type { DecodedTrail, SkillCall, Usage, } from "./adapters/opencode/events.ts";
+export { containerArgv, mountProblems, runContainer, } from "./adapters/podman/container.ts";
+export type { ContainerPlan, Mount } from "./adapters/podman/container.ts";
+export { buildImage, containerfileText, parseOpencodeVersion, resolveImage, } from "./adapters/podman/image.ts";
+export { assessDocsTrial, docsVerbOf } from "./evaluators/docs/assess.ts";
+export type { DocsAssessment } from "./evaluators/docs/assess.ts";
+export * from "./evaluators/docs/index.ts";
+export { hostDispatchesFromTrail, isServedRecord, journalIdentityFromTrail, journalMacValid, verifyOperationsJournal, } from "./evaluators/docs/journal.ts";
+export type { JournalDispatch, JournalVerification, } from "./evaluators/docs/journal.ts";
+export { assessSkillTrial } from "./evaluators/skills/assess.ts";
+export type { SkillAssessment } from "./evaluators/skills/assess.ts";
+export { readLegacyManifest, readLegacySchedule } from "./legacy/prod014.ts";
+export type { LegacyManifest, LegacySchedule, LegacySlot, } from "./legacy/prod014.ts";
+export { main, parseArgs, USAGE } from "./cli/otc.ts";

package/dist/index.js

@@ -0,0 +1,29 @@
+/**
+ * @markstanden/opencode-test-container
+ *
+ * Public modules are re-exported here for programmatic use. The supported
+ * consumer surface is the `otc` CLI; these exports exist so tests and
+ * evaluators can exercise the same lifecycle without a shell.
+ */
+export { canonicalJson, sha256Bytes, sha256Of } from "./contracts/canonical.js";
+export { EVALUATOR_VERSION, PACKAGE_NAME, packageVersion, toolIdentity, } from "./contracts/version.js";
+export { ID_PATTERN, isId, isSafeRelativePath, loadCampaignBundle, validateBundle, validateCampaign, validateSuite, } from "./contracts/validate.js";
+export { DEFAULT_PLUGIN_INCLUDE, loadPreparedManifest, manifestSha256, normaliseCampaign, prepareCampaign, preparedDifferences, } from "./campaign/prepare.js";
+export { deliveryCheck, freezeCampaign, freezeDifferences, freezeIdentity, loadFrozen, } from "./campaign/freeze.js";
+export { appendLedgerEvent, launchRefusal, parseLedger, readLedger, trialStarts, } from "./campaign/ledger.js";
+export { launchSha256, planTrial, runCampaign, trialDirectory, } from "./campaign/run.js";
+export { judgeCampaign, buildJudgePacketForSlot, checkedSelection, checkedSelectionForSlot, readJudgeAttempts, readSelectedJudgement, selectionPath, } from "./campaign/judge.js";
+export { executePrimaryCheck, primaryCheckPlan, readPrimaryCheck, } from "./campaign/primary.js";
+export { assessCampaign, assessmentPath, readAssessments, } from "./campaign/assess.js";
+export { closeCampaign } from "./campaign/close.js";
+export { statusOf } from "./campaign/status.js";
+export { analyseCampaign, reportIdentity, reportIntact, } from "./reporting/report.js";
+export { decodeTrail, captureProblems, skillCalls, } from "./adapters/opencode/events.js";
+export { containerArgv, mountProblems, runContainer, } from "./adapters/podman/container.js";
+export { buildImage, containerfileText, parseOpencodeVersion, resolveImage, } from "./adapters/podman/image.js";
+export { assessDocsTrial, docsVerbOf } from "./evaluators/docs/assess.js";
+export * from "./evaluators/docs/index.js";
+export { hostDispatchesFromTrail, isServedRecord, journalIdentityFromTrail, journalMacValid, verifyOperationsJournal, } from "./evaluators/docs/journal.js";
+export { assessSkillTrial } from "./evaluators/skills/assess.js";
+export { readLegacyManifest, readLegacySchedule } from "./legacy/prod014.js";
+export { main, parseArgs, USAGE } from "./cli/otc.js";

package/dist/legacy/prod014.d.ts

@@ -0,0 +1,86 @@
+/**
+ * Explicit readers for the frozen prod014 layout.
+ *
+ * Historical scenario ids, stamps, pair ids and frozen schedule bytes are
+ * records, not templates. These adapters translate the old fields into the
+ * new vocabulary without renaming an id or rewriting the source file. A
+ * legacy campaign is never resumed by the new engine: the reader exists for
+ * comparison and provenance, and new work gets a fresh OTC root.
+ */
+import type { Slot } from "../contracts/types.ts";
+/** One translated legacy slot, retaining every historical identity. */
+export interface LegacySlot {
+    /** The new slot identity: the frozen stamp, unchanged. */
+    slot: Slot;
+    /** The historical numeric slot position. */
+    legacySlot: number;
+    /** The frozen pair identity. */
+    pairId: string;
+    /** The historical scenario id, unchanged. */
+    legacyScenario: string;
+    /** The historical stamp, unchanged. */
+    legacyStamp: string;
+    /** The historical arm label, unchanged. */
+    legacyArm: string;
+}
+/** A translated legacy schedule. */
+export interface LegacySchedule {
+    /** The kind value. */
+    kind: "prod014-schedule";
+    /** The legacy campaign id value. */
+    legacyCampaignId: string;
+    /** The generator value. */
+    generator: string | null;
+    /** The slots value. */
+    slots: LegacySlot[];
+}
+/** A parsed legacy record, or every reason it is unusable. */
+export type LegacyParse<T> = {
+    ok: true;
+    value: T;
+} | {
+    ok: false;
+    problems: string[];
+};
+/**
+ * Translate one frozen prod014 `schedule.json` value.
+ * @param value The parsed JSON value.
+ * @returns The translated schedule, or explicit problems.
+ */
+export declare function readLegacySchedule(value: unknown): LegacyParse<LegacySchedule>;
+/** One translated legacy manifest arm. */
+export interface LegacyArm {
+    /** The arm id value. */
+    armId: string;
+    /** The label value. */
+    label: string;
+}
+/** One translated legacy manifest scenario. */
+export interface LegacyScenario {
+    /** The case id value. */
+    caseId: string;
+    /** The kind value. */
+    kind: string;
+    /** The old mutation/preservation blocks are preserved verbatim. */
+    legacy: Record<string, unknown>;
+}
+/** A translated legacy campaign manifest. */
+export interface LegacyManifest {
+    /** The kind value. */
+    kind: "prod014-manifest";
+    /** The legacy campaign id value. */
+    legacyCampaignId: string;
+    /** The question value. */
+    question: string | null;
+    /** The arms value. */
+    arms: LegacyArm[];
+    /** The scenarios value. */
+    scenarios: LegacyScenario[];
+}
+/**
+ * Translate one frozen prod014 `manifest.json` value. Unknown fields remain
+ * in `legacy` so an old fact is never silently discarded.
+ * @param value The parsed JSON value.
+ * @returns The translated manifest, or explicit problems.
+ */
+export declare function readLegacyManifest(value: unknown): LegacyParse<LegacyManifest>;

package/dist/legacy/prod014.js

@@ -0,0 +1,209 @@
+/**
+ * Explicit readers for the frozen prod014 layout.
+ *
+ * Historical scenario ids, stamps, pair ids and frozen schedule bytes are
+ * records, not templates. These adapters translate the old fields into the
+ * new vocabulary without renaming an id or rewriting the source file. A
+ * legacy campaign is never resumed by the new engine: the reader exists for
+ * comparison and provenance, and new work gets a fresh OTC root.
+ */
+import { isRecord } from "../contracts/validate.js";
+/** A required non-blank string field. */
+function requiredLegacyText(value, field, where, problems) {
+    if (typeof value === "string" && value !== "")
+        return value;
+    problems.push(`${where}.${field} is missing`);
+    return undefined;
+}
+/** A required integer field with a floor. */
+function requiredLegacyInteger(value, field, floor, where, problems) {
+    if (typeof value === "number" &&
+        Number.isInteger(value) &&
+        value >= floor) {
+        return value;
+    }
+    problems.push(`${where}.${field} must be an integer >= ${floor}`);
+    return undefined;
+}
+/** Translate one frozen schedule slot. */
+function legacySlotOf(entry, index) {
+    const where = `legacy schedule slot[${index}]`;
+    if (!isRecord(entry)) {
+        return { ok: false, problems: [`${where} is not an object`] };
+    }
+    const problems = [];
+    const slot = requiredLegacyInteger(entry.slot, "slot", 1, where, problems);
+    const repetition = requiredLegacyInteger(entry.repetition, "repetition", 0, where, problems);
+    const pairId = requiredLegacyText(entry.pairId, "pairId", where, problems);
+    const scenario = requiredLegacyText(entry.scenario, "scenario", where, problems);
+    const arm = requiredLegacyText(entry.arm, "arm", where, problems);
+    const stamp = requiredLegacyText(entry.stamp, "stamp", where, problems);
+    if (problems.length > 0 ||
+        slot === undefined ||
+        repetition === undefined ||
+        pairId === undefined ||
+        scenario === undefined ||
+        arm === undefined ||
+        stamp === undefined) {
+        return { ok: false, problems };
+    }
+    return {
+        ok: true,
+        slot: {
+            slot: {
+                slotId: stamp,
+                caseId: scenario,
+                armId: arm,
+                repetitionId: `r${repetition}`,
+            },
+            legacySlot: slot,
+            pairId,
+            legacyScenario: scenario,
+            legacyStamp: stamp,
+            legacyArm: arm,
+        },
+    };
+}
+/** Translate slots, refusing a duplicate historical stamp. */
+function uniqueLegacySlots(value) {
+    const slots = [];
+    const problems = [];
+    const stamps = new Set();
+    for (const [index, entry] of value.entries()) {
+        const parsed = legacySlotOf(entry, index);
+        if (!parsed.ok) {
+            problems.push(...parsed.problems);
+            continue;
+        }
+        if (stamps.has(parsed.slot.legacyStamp)) {
+            problems.push(`legacy schedule slot[${index}].stamp duplicates ${parsed.slot.legacyStamp}`);
+            continue;
+        }
+        stamps.add(parsed.slot.legacyStamp);
+        slots.push(parsed.slot);
+    }
+    return { slots, problems };
+}
+/**
+ * Translate one frozen prod014 `schedule.json` value.
+ * @param value The parsed JSON value.
+ * @returns The translated schedule, or explicit problems.
+ */
+export function readLegacySchedule(value) {
+    if (!isRecord(value)) {
+        return { ok: false, problems: ["legacy schedule must be an object"] };
+    }
+    if (typeof value.campaign !== "string" || value.campaign === "") {
+        return { ok: false, problems: ["legacy schedule has no campaign id"] };
+    }
+    if (!Array.isArray(value.slots) || value.slots.length === 0) {
+        return { ok: false, problems: ["legacy schedule has no slots"] };
+    }
+    const { slots, problems } = uniqueLegacySlots(value.slots);
+    if (problems.length > 0)
+        return { ok: false, problems };
+    return {
+        ok: true,
+        value: {
+            kind: "prod014-schedule",
+            legacyCampaignId: value.campaign,
+            generator: typeof value.generator === "string" ? value.generator : null,
+            slots,
+        },
+    };
+}
+/** Translate the manifest's arms. */
+function legacyArmsOf(value) {
+    if (value === undefined)
+        return { ok: true, value: [] };
+    if (!Array.isArray(value)) {
+        return {
+            ok: false,
+            problems: ["legacy manifest arms must be an array"],
+        };
+    }
+    const arms = [];
+    for (const [index, entry] of value.entries()) {
+        if (!isRecord(entry) || typeof entry.id !== "string") {
+            return {
+                ok: false,
+                problems: [`legacy manifest arm[${index}] is malformed`],
+            };
+        }
+        arms.push({
+            armId: entry.id,
+            label: typeof entry.label === "string" ? entry.label : "",
+        });
+    }
+    return { ok: true, value: arms };
+}
+/** Translate the manifest's scenarios, preserving unknown blocks. */
+function legacyScenariosOf(value) {
+    if (value === undefined)
+        return { ok: true, value: [] };
+    if (!Array.isArray(value)) {
+        return {
+            ok: false,
+            problems: ["legacy manifest scenarios must be an array"],
+        };
+    }
+    const scenarios = [];
+    for (const [index, entry] of value.entries()) {
+        if (!isRecord(entry) ||
+            typeof entry.id !== "string" ||
+            typeof entry.kind !== "string") {
+            return {
+                ok: false,
+                problems: [`legacy manifest scenario[${index}] is malformed`],
+            };
+        }
+        const { id, kind, ...legacy } = entry;
+        scenarios.push({ caseId: id, kind, legacy });
+    }
+    return { ok: true, value: scenarios };
+}
+/**
+ * Translate one frozen prod014 `manifest.json` value. Unknown fields remain
+ * in `legacy` so an old fact is never silently discarded.
+ * @param value The parsed JSON value.
+ * @returns The translated manifest, or explicit problems.
+ */
+export function readLegacyManifest(value) {
+    if (!isRecord(value)) {
+        return { ok: false, problems: ["legacy manifest must be an object"] };
+    }
+    if (value.schemaVersion !== 1) {
+        return {
+            ok: false,
+            problems: ["legacy manifest schemaVersion must be 1"],
+        };
+    }
+    if (!isRecord(value.campaign)) {
+        return {
+            ok: false,
+            problems: ["legacy manifest has no campaign block"],
+        };
+    }
+    const campaignId = value.campaign.id;
+    if (typeof campaignId !== "string" || campaignId === "") {
+        return { ok: false, problems: ["legacy manifest has no campaign id"] };
+    }
+    const arms = legacyArmsOf(value.arms);
+    if (!arms.ok)
+        return arms;
+    const scenarios = legacyScenariosOf(value.scenarios);
+    if (!scenarios.ok)
+        return scenarios;
+    return {
+        ok: true,
+        value: {
+            kind: "prod014-manifest",
+            legacyCampaignId: campaignId,
+            question: typeof value.campaign.question === "string"
+                ? value.campaign.question
+                : null,
+            arms: arms.value,
+            scenarios: scenarios.value,
+        },
+    };
+}