@dailephd/my-dev-kit-lab 0.4.2 → 0.4.4

package/dist/src/experiments/plugins/contextStrategyComparison/loadV043StrategyArtifacts.js

@@ -0,0 +1,397 @@
+import { readImplementationContextPacketV1, readImplementationContextRetrievalReportV1, readMyDevKitContextCapsuleV1, readMyDevKitRetrievalAuditRecordV1, readOrchestratorWorkflowInstructionPacketV1, readTestContextPacketV1, readTestContextRetrievalReportV1, validateOrchestratorContextReadinessResultV1 } from "../../../evaluation/upstreamArtifacts/index.js";
+import { checkMyDevKitContextArtifactConsistency } from "../../../evaluation/stageContextSelectors/index.js";
+import { readStageContextExpectationFixtureV1 } from "../../../evaluation/stageContextExpectations/index.js";
+import { readV043FullWorkflowLibraryFixture } from "./readV043FullWorkflowLibraryFixture.js";
+function buildFailureResult(input, issues) {
+    return { status: "failed", strategyId: input.strategyId, input, issues };
+}
+async function loadContextArtifactPair(role, capsulePath, auditPath, pairLabel, issues) {
+    const capsuleResult = await readMyDevKitContextCapsuleV1(capsulePath);
+    if (!capsuleResult.ok) {
+        issues.push({
+            code: "CONTEXT_CAPSULE_READ_FAILED",
+            fieldPath: `${pairLabel}.contextCapsule`,
+            message: `Failed to read ContextCapsule for "${pairLabel}": ${capsuleResult.message}`,
+            sourcePath: capsuleResult.sourcePath,
+            details: capsuleResult
+        });
+    }
+    let auditReadOk = false;
+    let auditSourcePath;
+    let auditArtifact;
+    if (auditPath !== undefined) {
+        const auditResult = await readMyDevKitRetrievalAuditRecordV1(auditPath);
+        if (!auditResult.ok) {
+            issues.push({
+                code: "RETRIEVAL_AUDIT_READ_FAILED",
+                fieldPath: `${pairLabel}.retrievalAuditRecord`,
+                message: `Failed to read RetrievalAuditRecord for "${pairLabel}": ${auditResult.message}`,
+                sourcePath: auditResult.sourcePath,
+                details: auditResult
+            });
+        }
+        else {
+            auditReadOk = true;
+            auditSourcePath = auditResult.sourcePath;
+            auditArtifact = auditResult.artifact;
+        }
+    }
+    if (!capsuleResult.ok)
+        return null;
+    const pair = {
+        role,
+        contextCapsuleSourcePath: capsuleResult.sourcePath,
+        contextCapsule: capsuleResult.artifact
+    };
+    if (auditReadOk) {
+        pair.retrievalAuditRecordSourcePath = auditSourcePath;
+        pair.retrievalAuditRecord = auditArtifact;
+    }
+    return pair;
+}
+function validateRole(pair, expectedRole, pairLabel, issues) {
+    if (pair.contextCapsule.request.role !== expectedRole) {
+        const fieldPath = `${pairLabel}.contextCapsule.request.role`;
+        issues.push({
+            code: "CONTEXT_ROLE_MISMATCH",
+            fieldPath,
+            message: `Expected context role "${expectedRole}" but found "${pair.contextCapsule.request.role}" at "${fieldPath}".`
+        });
+    }
+    if (pair.contextCapsule.roleContext.role !== expectedRole) {
+        const fieldPath = `${pairLabel}.contextCapsule.roleContext.role`;
+        issues.push({
+            code: "CONTEXT_ROLE_MISMATCH",
+            fieldPath,
+            message: `Expected context role "${expectedRole}" but found "${pair.contextCapsule.roleContext.role}" at "${fieldPath}".`
+        });
+    }
+    if (pair.retrievalAuditRecord) {
+        if (pair.retrievalAuditRecord.request.role !== expectedRole) {
+            const fieldPath = `${pairLabel}.retrievalAuditRecord.request.role`;
+            issues.push({
+                code: "CONTEXT_ROLE_MISMATCH",
+                fieldPath,
+                message: `Expected context role "${expectedRole}" but found "${pair.retrievalAuditRecord.request.role}" at "${fieldPath}".`
+            });
+        }
+        if (pair.retrievalAuditRecord.roleContext.role !== expectedRole) {
+            const fieldPath = `${pairLabel}.retrievalAuditRecord.roleContext.role`;
+            issues.push({
+                code: "CONTEXT_ROLE_MISMATCH",
+                fieldPath,
+                message: `Expected context role "${expectedRole}" but found "${pair.retrievalAuditRecord.roleContext.role}" at "${fieldPath}".`
+            });
+        }
+    }
+}
+function checkPairConsistency(pair, pairLabel, issues) {
+    if (!pair.retrievalAuditRecord)
+        return;
+    const consistency = checkMyDevKitContextArtifactConsistency(pair.contextCapsule, pair.retrievalAuditRecord);
+    pair.consistency = consistency;
+    if (!consistency.consistent) {
+        for (const consistencyIssue of consistency.issues) {
+            const prefixedFieldPath = `${pairLabel}.${consistencyIssue.fieldPath}`;
+            issues.push({
+                code: "CONTEXT_ARTIFACT_INCONSISTENT",
+                fieldPath: prefixedFieldPath,
+                message: `ContextCapsule and RetrievalAuditRecord are inconsistent at "${prefixedFieldPath}".`,
+                details: consistencyIssue
+            });
+        }
+    }
+}
+function validatePairsInOrder(entries, issues) {
+    for (const entry of entries) {
+        validateRole(entry.pair, entry.role, entry.label, issues);
+        checkPairConsistency(entry.pair, entry.label, issues);
+    }
+}
+export async function loadV043StrategyArtifacts(input) {
+    const issues = [];
+    const expectationsResult = await readStageContextExpectationFixtureV1(input.expectationsPath);
+    if (!expectationsResult.ok) {
+        issues.push({
+            code: "EXPECTATION_READ_FAILED",
+            fieldPath: "expectations",
+            message: `Failed to read stage-context expectation fixture: ${expectationsResult.message}`,
+            sourcePath: expectationsResult.sourcePath,
+            details: expectationsResult
+        });
+    }
+    switch (input.strategyId) {
+        case "architecture-context-only": {
+            const architecture = await loadContextArtifactPair("architecture", input.architectureContextCapsulePath, input.architectureRetrievalAuditRecordPath, "architecture", issues);
+            const entries = [];
+            if (architecture)
+                entries.push({ pair: architecture, role: "architecture", label: "architecture" });
+            validatePairsInOrder(entries, issues);
+            if (issues.length > 0 || !expectationsResult.ok || !architecture) {
+                return buildFailureResult(input, issues);
+            }
+            return {
+                status: "completed",
+                strategyId: input.strategyId,
+                input,
+                expectationsSourcePath: expectationsResult.sourcePath,
+                expectations: expectationsResult.fixture,
+                payload: { architecture },
+                warnings: []
+            };
+        }
+        case "architecture-plus-implementation-refresh": {
+            const architecture = await loadContextArtifactPair("architecture", input.architectureContextCapsulePath, input.architectureRetrievalAuditRecordPath, "architecture", issues);
+            const implementation = await loadContextArtifactPair("implementation", input.implementationContextCapsulePath, input.implementationRetrievalAuditRecordPath, "implementation", issues);
+            const entries = [];
+            if (architecture)
+                entries.push({ pair: architecture, role: "architecture", label: "architecture" });
+            if (implementation)
+                entries.push({ pair: implementation, role: "implementation", label: "implementation" });
+            validatePairsInOrder(entries, issues);
+            if (issues.length > 0 || !expectationsResult.ok || !architecture || !implementation) {
+                return buildFailureResult(input, issues);
+            }
+            return {
+                status: "completed",
+                strategyId: input.strategyId,
+                input,
+                expectationsSourcePath: expectationsResult.sourcePath,
+                expectations: expectationsResult.fixture,
+                payload: { architecture, implementation },
+                warnings: []
+            };
+        }
+        case "architecture-plus-implementation-and-test-refresh": {
+            const architecture = await loadContextArtifactPair("architecture", input.architectureContextCapsulePath, input.architectureRetrievalAuditRecordPath, "architecture", issues);
+            const implementation = await loadContextArtifactPair("implementation", input.implementationContextCapsulePath, input.implementationRetrievalAuditRecordPath, "implementation", issues);
+            const testImplementation = await loadContextArtifactPair("test-implementation", input.testImplementationContextCapsulePath, input.testImplementationRetrievalAuditRecordPath, "testImplementation", issues);
+            const entries = [];
+            if (architecture)
+                entries.push({ pair: architecture, role: "architecture", label: "architecture" });
+            if (implementation)
+                entries.push({ pair: implementation, role: "implementation", label: "implementation" });
+            if (testImplementation) {
+                entries.push({ pair: testImplementation, role: "test-implementation", label: "testImplementation" });
+            }
+            validatePairsInOrder(entries, issues);
+            if (issues.length > 0 || !expectationsResult.ok || !architecture || !implementation || !testImplementation) {
+                return buildFailureResult(input, issues);
+            }
+            return {
+                status: "completed",
+                strategyId: input.strategyId,
+                input,
+                expectationsSourcePath: expectationsResult.sourcePath,
+                expectations: expectationsResult.fixture,
+                payload: { architecture, implementation, testImplementation },
+                warnings: []
+            };
+        }
+        case "full-workflow-library": {
+            const libraryResult = await readV043FullWorkflowLibraryFixture(input.fullWorkflowLibraryFixturePath);
+            if (!libraryResult.ok) {
+                issues.push({
+                    code: "FULL_WORKFLOW_LIBRARY_READ_FAILED",
+                    fieldPath: "fullWorkflowLibrary",
+                    message: `Failed to read full-workflow-library fixture: ${libraryResult.message}`,
+                    sourcePath: libraryResult.sourcePath,
+                    details: libraryResult
+                });
+            }
+            if (issues.length > 0 || !expectationsResult.ok || !libraryResult.ok) {
+                return buildFailureResult(input, issues);
+            }
+            return {
+                status: "completed",
+                strategyId: input.strategyId,
+                input,
+                expectationsSourcePath: expectationsResult.sourcePath,
+                expectations: expectationsResult.fixture,
+                payload: {
+                    fullWorkflowLibrarySourcePath: libraryResult.sourcePath,
+                    fullWorkflowLibrary: libraryResult.fixture
+                },
+                warnings: []
+            };
+        }
+        case "bounded-workflow-instruction-packet": {
+            const packetResult = await readOrchestratorWorkflowInstructionPacketV1(input.workflowInstructionPacketPath);
+            if (!packetResult.ok) {
+                issues.push({
+                    code: "WORKFLOW_PACKET_READ_FAILED",
+                    fieldPath: "workflowInstructionPacket",
+                    message: `Failed to read WorkflowInstructionPacket: ${packetResult.message}`,
+                    sourcePath: packetResult.sourcePath,
+                    details: packetResult
+                });
+            }
+            if (issues.length > 0 || !expectationsResult.ok || !packetResult.ok) {
+                return buildFailureResult(input, issues);
+            }
+            return {
+                status: "completed",
+                strategyId: input.strategyId,
+                input,
+                expectationsSourcePath: expectationsResult.sourcePath,
+                expectations: expectationsResult.fixture,
+                payload: {
+                    workflowInstructionPacketSourcePath: packetResult.sourcePath,
+                    workflowInstructionPacket: packetResult.artifact
+                },
+                warnings: []
+            };
+        }
+        case "combined-bounded-stage-context": {
+            const pairs = [];
+            const entries = [];
+            for (let index = 0; index < input.contextArtifacts.length; index += 1) {
+                const contextArtifact = input.contextArtifacts[index];
+                const pairLabel = `contextArtifacts[${index}]`;
+                const pair = await loadContextArtifactPair(contextArtifact.role, contextArtifact.contextCapsulePath, contextArtifact.retrievalAuditRecordPath, pairLabel, issues);
+                if (pair) {
+                    pairs.push(pair);
+                    entries.push({ pair, role: contextArtifact.role, label: pairLabel });
+                }
+            }
+            validatePairsInOrder(entries, issues);
+            const packetResult = await readOrchestratorWorkflowInstructionPacketV1(input.workflowInstructionPacketPath);
+            if (!packetResult.ok) {
+                issues.push({
+                    code: "WORKFLOW_PACKET_READ_FAILED",
+                    fieldPath: "workflowInstructionPacket",
+                    message: `Failed to read WorkflowInstructionPacket: ${packetResult.message}`,
+                    sourcePath: packetResult.sourcePath,
+                    details: packetResult
+                });
+            }
+            // v0.4.4 Batch 3: producer-readiness bridge inputs -- every one is optional (section
+            // 11.2). Only a supplied-but-unreadable source becomes a load failure; an absent
+            // source is simply left off the payload for the bridge evaluator to treat as
+            // unavailable/not-applicable.
+            let implementationContextPacketSourcePath;
+            let implementationContextPacket;
+            if (input.implementationContextPacketPath !== undefined) {
+                const result = await readImplementationContextPacketV1(input.implementationContextPacketPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "IMPLEMENTATION_CONTEXT_PACKET_READ_FAILED",
+                        fieldPath: "implementationContextPacket",
+                        message: `Failed to read implementation-context packet: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    implementationContextPacketSourcePath = result.sourcePath;
+                    implementationContextPacket = result.artifact;
+                }
+            }
+            let implementationContextRetrievalReportSourcePath;
+            let implementationContextRetrievalReport;
+            if (input.implementationContextRetrievalReportPath !== undefined) {
+                const result = await readImplementationContextRetrievalReportV1(input.implementationContextRetrievalReportPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "IMPLEMENTATION_CONTEXT_RETRIEVAL_REPORT_READ_FAILED",
+                        fieldPath: "implementationContextRetrievalReport",
+                        message: `Failed to read implementation-context retrieval report: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    implementationContextRetrievalReportSourcePath = result.sourcePath;
+                    implementationContextRetrievalReport = result.artifact;
+                }
+            }
+            let testContextPacketSourcePath;
+            let testContextPacket;
+            if (input.testContextPacketPath !== undefined) {
+                const result = await readTestContextPacketV1(input.testContextPacketPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "TEST_CONTEXT_PACKET_READ_FAILED",
+                        fieldPath: "testContextPacket",
+                        message: `Failed to read test-context packet: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    testContextPacketSourcePath = result.sourcePath;
+                    testContextPacket = result.artifact;
+                }
+            }
+            let testContextRetrievalReportSourcePath;
+            let testContextRetrievalReport;
+            if (input.testContextRetrievalReportPath !== undefined) {
+                const result = await readTestContextRetrievalReportV1(input.testContextRetrievalReportPath);
+                if (!result.ok) {
+                    issues.push({
+                        code: "TEST_CONTEXT_RETRIEVAL_REPORT_READ_FAILED",
+                        fieldPath: "testContextRetrievalReport",
+                        message: `Failed to read test-context retrieval report: ${result.message}`,
+                        sourcePath: result.sourcePath,
+                        details: result
+                    });
+                }
+                else {
+                    testContextRetrievalReportSourcePath = result.sourcePath;
+                    testContextRetrievalReport = result.artifact;
+                }
+            }
+            let readiness;
+            if (input.readiness !== undefined) {
+                const readinessResult = validateOrchestratorContextReadinessResultV1(input.readiness, "programmatic-input:readiness");
+                if (!readinessResult.ok) {
+                    issues.push({
+                        code: "READINESS_INPUT_INVALID",
+                        fieldPath: "readiness",
+                        message: `Readiness programmatic input is invalid: ${readinessResult.message}`,
+                        details: readinessResult
+                    });
+                }
+                else {
+                    readiness = readinessResult.artifact;
+                }
+            }
+            if (issues.length > 0 || !expectationsResult.ok || !packetResult.ok || pairs.length !== input.contextArtifacts.length) {
+                return buildFailureResult(input, issues);
+            }
+            const payload = {
+                contextArtifacts: pairs,
+                workflowInstructionPacketSourcePath: packetResult.sourcePath,
+                workflowInstructionPacket: packetResult.artifact
+            };
+            if (implementationContextPacket !== undefined) {
+                payload.implementationContextPacketSourcePath = implementationContextPacketSourcePath;
+                payload.implementationContextPacket = implementationContextPacket;
+            }
+            if (implementationContextRetrievalReport !== undefined) {
+                payload.implementationContextRetrievalReportSourcePath = implementationContextRetrievalReportSourcePath;
+                payload.implementationContextRetrievalReport = implementationContextRetrievalReport;
+            }
+            if (testContextPacket !== undefined) {
+                payload.testContextPacketSourcePath = testContextPacketSourcePath;
+                payload.testContextPacket = testContextPacket;
+            }
+            if (testContextRetrievalReport !== undefined) {
+                payload.testContextRetrievalReportSourcePath = testContextRetrievalReportSourcePath;
+                payload.testContextRetrievalReport = testContextRetrievalReport;
+            }
+            if (readiness !== undefined) {
+                payload.readiness = readiness;
+            }
+            return {
+                status: "completed",
+                strategyId: input.strategyId,
+                input,
+                expectationsSourcePath: expectationsResult.sourcePath,
+                expectations: expectationsResult.fixture,
+                payload,
+                warnings: []
+            };
+        }
+    }
+}

package/dist/src/experiments/plugins/contextStrategyComparison/plugin.js

@@ -3,6 +3,10 @@ import path from "node:path";
 import { runControlledExperiment } from "../../../evaluation/runControlledExperiment.js";
 import { defaultContextStrategyComparisonConfig, validateContextStrategyComparisonConfig, } from "./config.js";
 import { mapLegacyArtifactsToExperimentRun, } from "./resultMapping.js";
+import { resolveV043StrategyInputs } from "./resolveV043StrategyInputs.js";
+import { V043_STAGE_CONTEXT_STRATEGY_IDS } from "./v043StrategyIds.js";
+import { validateV043RunAssuranceConfig } from "./validateV043RunAssuranceConfig.js";
+import { runV043StageContextStrategyWithAssurance } from "./runV043StageContextStrategyWithAssurance.js";
 export const contextStrategyComparisonMetadata = {
     id: "context-strategy-comparison",
     name: "Context Strategy Comparison",
@@ -12,6 +16,9 @@ export const contextStrategyComparisonMetadata = {
     supportedTargets: ["self", "external-local"],
     supportedOutputs: ["json", "html", "plot", "screenshot", "artifact"],
 };
+function isV043StrategyId(value) {
+    return V043_STAGE_CONTEXT_STRATEGY_IDS.includes(value);
+}
 export const contextStrategyComparisonPlugin = {
     metadata: contextStrategyComparisonMetadata,
     defaultConfig: defaultContextStrategyComparisonConfig,
@@ -31,13 +38,41 @@ export const contextStrategyComparisonPlugin = {
         const projectProfiles = readInputArray(context.inputs, "projectProfiles");
         const env = readEnv(context.inputs);
         const startedAt = context.startedAt.toISOString();
+        const selectedStrategyIds = context.config.strategies ?? defaultContextStrategyComparisonConfig.strategies ?? [];
+        const providedV043Inputs = context.config.v043StrategyInputs ?? [];
+        const resolution = resolveV043StrategyInputs(selectedStrategyIds, providedV043Inputs);
+        if (!resolution.ok) {
+            const issuesText = resolution.issues.map((issue) => `${issue.code}:${issue.strategyId}`).join(", ");
+            throw new Error(`Invalid v0.4.3 strategy-input configuration: ${issuesText}`);
+        }
+        const runAssuranceValidation = validateV043RunAssuranceConfig(context.config.v043RunAssurance);
+        if (!runAssuranceValidation.ok) {
+            const issuesText = runAssuranceValidation.issues.map((issue) => `${issue.code}:${issue.fieldPath}`).join(", ");
+            throw new Error(`Invalid v0.4.3 run-assurance configuration: ${issuesText}`);
+        }
+        const runAssuranceConfig = runAssuranceValidation.config;
+        const legacyStrategyIds = selectedStrategyIds.filter((strategyId) => !isV043StrategyId(strategyId));
+        const legacyConfig = { ...context.config, strategies: legacyStrategyIds };
         const legacyArtifacts = await runControlledExperiment({
-            config: context.config,
+            config: legacyConfig,
             cases,
             projectProfiles,
             repoRoot: context.target.targetRoot,
             env,
         });
+        const v043SelectedStrategyIds = selectedStrategyIds.filter(isV043StrategyId);
+        const v043StageContextExecutions = [];
+        const v043StageContextEvaluations = [];
+        const v043StageContextRunAssurance = [];
+        for (const strategyId of v043SelectedStrategyIds) {
+            const input = resolution.inputByStrategyId[strategyId];
+            if (!input)
+                continue;
+            const assurance = await runV043StageContextStrategyWithAssurance(input, runAssuranceConfig);
+            v043StageContextExecutions.push(assurance.primaryExecution);
+            v043StageContextEvaluations.push(assurance.primaryEvaluation);
+            v043StageContextRunAssurance.push(assurance);
+        }
         const completedAt = new Date().toISOString();
         const outDir = context.outputRoot ?? path.resolve(context.toolRoot, context.config.outDir);
         await mkdir(outDir, { recursive: true });
@@ -48,6 +83,9 @@ export const contextStrategyComparisonPlugin = {
             completedAt,
             target: context.target,
             legacyArtifacts,
+            v043StageContextExecutions,
+            v043StageContextEvaluations,
+            v043StageContextRunAssurance,
             pluginResultPath,
         });
         await writeFile(pluginResultPath, `${JSON.stringify(redactLegacyArtifacts(result), null, 2)}\n`, "utf8");

package/dist/src/experiments/plugins/contextStrategyComparison/readV043FullWorkflowLibraryFixture.js

@@ -0,0 +1,162 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+const SCHEMA_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+const FIXTURE_ID_PATTERN = /^FULL-WORKFLOW-LIBRARY-[A-Z0-9]+(?:-[A-Z0-9]+)*-[0-9]{3}$/;
+const REQUIRED_NONEMPTY_ID_ARRAY_FIELDS = [
+    "workflowIds",
+    "stageIds",
+    "commandIds",
+    "ruleIds",
+    "reportContractIds"
+];
+const ALL_ID_ARRAY_FIELDS = [
+    ...REQUIRED_NONEMPTY_ID_ARRAY_FIELDS,
+    "provenanceEvidenceIds"
+];
+function failure(sourcePath, code, message, extra) {
+    return { ok: false, sourcePath, code, message, ...extra };
+}
+function isStringArray(value) {
+    return Array.isArray(value) && value.every((entry) => typeof entry === "string");
+}
+function hasDuplicates(values) {
+    return new Set(values).size !== values.length;
+}
+function validateFullWorkflowLibraryFixture(value, sourcePath) {
+    if (value === null || typeof value !== "object" || Array.isArray(value)) {
+        return failure(sourcePath, "NON_OBJECT_ROOT", "Full-workflow-library fixture must parse to a JSON object at the root.", {
+            expected: "object",
+            actual: value
+        });
+    }
+    const root = value;
+    if (root.schemaVersion === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "schemaVersion is required.", { fieldPath: "schemaVersion" });
+    }
+    if (typeof root.schemaVersion !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "schemaVersion must be a string.", { fieldPath: "schemaVersion" });
+    }
+    if (!SCHEMA_VERSION_PATTERN.test(root.schemaVersion)) {
+        return failure(sourcePath, "INVALID_SCHEMA_VERSION", `schemaVersion "${root.schemaVersion}" does not match x.y.z.`, {
+            fieldPath: "schemaVersion",
+            actual: root.schemaVersion
+        });
+    }
+    const schemaVersionValue = root.schemaVersion;
+    const schemaMajor = Number(schemaVersionValue.split(".")[0]);
+    if (schemaMajor !== 1) {
+        return failure(sourcePath, "UNSUPPORTED_SCHEMA_MAJOR", `schemaVersion major "${schemaMajor}" is not supported.`, {
+            fieldPath: "schemaVersion",
+            actual: schemaVersionValue
+        });
+    }
+    if (root.fixtureId === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "fixtureId is required.", { fieldPath: "fixtureId" });
+    }
+    if (typeof root.fixtureId !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "fixtureId must be a string.", { fieldPath: "fixtureId" });
+    }
+    if (!FIXTURE_ID_PATTERN.test(root.fixtureId)) {
+        return failure(sourcePath, "INVALID_FIXTURE_ID", `fixtureId "${root.fixtureId}" does not match the required pattern.`, {
+            fieldPath: "fixtureId",
+            actual: root.fixtureId
+        });
+    }
+    for (const field of ["title", "description"]) {
+        const fieldValue = root[field];
+        if (fieldValue === undefined) {
+            return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${field} is required.`, { fieldPath: field });
+        }
+        if (typeof fieldValue !== "string") {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${field} must be a string.`, { fieldPath: field });
+        }
+        if (fieldValue.trim().length === 0) {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${field} must be a nonempty string.`, { fieldPath: field });
+        }
+    }
+    for (const field of ALL_ID_ARRAY_FIELDS) {
+        const fieldValue = root[field];
+        if (fieldValue === undefined) {
+            return failure(sourcePath, "MISSING_REQUIRED_FIELD", `${field} is required.`, { fieldPath: field });
+        }
+        if (!isStringArray(fieldValue)) {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${field} must be an array of strings.`, { fieldPath: field });
+        }
+        if (fieldValue.some((entry) => entry.length === 0)) {
+            return failure(sourcePath, "INVALID_FIELD_TYPE", `${field} entries must be nonempty strings.`, { fieldPath: field });
+        }
+    }
+    for (const field of REQUIRED_NONEMPTY_ID_ARRAY_FIELDS) {
+        const fieldValue = root[field];
+        if (fieldValue.length === 0) {
+            return failure(sourcePath, "EMPTY_REQUIRED_ID_SET", `${field} must contain at least one entry.`, { fieldPath: field });
+        }
+    }
+    for (const field of ALL_ID_ARRAY_FIELDS) {
+        const fieldValue = root[field];
+        if (hasDuplicates(fieldValue)) {
+            return failure(sourcePath, "DUPLICATE_ID", `${field} contains duplicate entries.`, { fieldPath: field });
+        }
+    }
+    if (root.rawText === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "rawText is required.", { fieldPath: "rawText" });
+    }
+    if (typeof root.rawText !== "string") {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "rawText must be a string.", { fieldPath: "rawText" });
+    }
+    if (root.rawText.trim().length === 0) {
+        return failure(sourcePath, "EMPTY_RAW_TEXT", "rawText must be a nonempty string.", { fieldPath: "rawText" });
+    }
+    if (root.warnings === undefined) {
+        return failure(sourcePath, "MISSING_REQUIRED_FIELD", "warnings is required.", { fieldPath: "warnings" });
+    }
+    if (!isStringArray(root.warnings)) {
+        return failure(sourcePath, "INVALID_FIELD_TYPE", "warnings must be an array of strings.", { fieldPath: "warnings" });
+    }
+    const fixture = value;
+    return {
+        ok: true,
+        sourcePath,
+        schemaVersion: schemaVersionValue,
+        schemaMajor: 1,
+        fixture,
+        rawFixture: fixture
+    };
+}
+export async function readV043FullWorkflowLibraryFixture(sourcePathInput) {
+    const sourcePath = path.resolve(sourcePathInput);
+    let raw;
+    try {
+        raw = await readFile(sourcePath, "utf8");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return {
+                ok: false,
+                sourcePath,
+                code: "FILE_NOT_FOUND",
+                message: `Full-workflow-library fixture was not found at "${sourcePath}".`
+            };
+        }
+        return {
+            ok: false,
+            sourcePath,
+            code: "UNREADABLE_FILE",
+            message: `Full-workflow-library fixture at "${sourcePath}" could not be read: ${error.message}`
+        };
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(raw);
+    }
+    catch (error) {
+        return {
+            ok: false,
+            sourcePath,
+            code: "MALFORMED_JSON",
+            message: `Full-workflow-library fixture at "${sourcePath}" is not valid JSON: ${error.message}`
+        };
+    }
+    return validateFullWorkflowLibraryFixture(parsed, sourcePath);
+}

package/dist/src/experiments/plugins/contextStrategyComparison/resolveV043StrategyInputs.js

@@ -0,0 +1,43 @@
+import { V043_STAGE_CONTEXT_STRATEGY_IDS } from "./v043StrategyIds.js";
+function isV043StrategyId(value) {
+    return V043_STAGE_CONTEXT_STRATEGY_IDS.includes(value);
+}
+export function resolveV043StrategyInputs(selectedStrategyIds, providedInputs) {
+    const issues = [];
+    const inputByStrategyId = {};
+    const selectedV043Ids = selectedStrategyIds.filter(isV043StrategyId);
+    for (const strategyId of selectedV043Ids) {
+        const matches = providedInputs.filter((input) => input.strategyId === strategyId);
+        if (matches.length === 0) {
+            issues.push({
+                code: "MISSING_STRATEGY_INPUT",
+                strategyId,
+                message: `No strategy input was supplied for selected strategy "${strategyId}".`
+            });
+        }
+        else if (matches.length > 1) {
+            issues.push({
+                code: "DUPLICATE_STRATEGY_INPUT",
+                strategyId,
+                message: `More than one strategy input was supplied for selected strategy "${strategyId}".`
+            });
+        }
+        else {
+            inputByStrategyId[strategyId] = matches[0];
+        }
+    }
+    const selectedV043IdSet = new Set(selectedV043Ids);
+    for (const input of providedInputs) {
+        if (!selectedV043IdSet.has(input.strategyId)) {
+            issues.push({
+                code: "INPUT_STRATEGY_NOT_SELECTED",
+                strategyId: input.strategyId,
+                message: `A strategy input was supplied for "${input.strategyId}", which was not selected.`
+            });
+        }
+    }
+    if (issues.length > 0) {
+        return { ok: false, issues };
+    }
+    return { ok: true, inputByStrategyId };
+}