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

package/dist/src/evaluation/upstreamArtifacts/validateMyDevKitRetrievalAuditRecordV1.js

@@ -0,0 +1,105 @@
+import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
+import { ArtifactValidationError, arrayFieldPath, joinFieldPath, requiredArray, requiredField, requiredLiteral, requiredObject, requiredRecord, requiredScalarLike, requiredString, requiredStringArray } from "./runtimeValidation.js";
+import { validateBudgetSummary, validateContextAdequacyStatement, validateContextCapsuleRequest, validateFreshnessSummary, validateFullFileFallbackSummary, validateProvenanceRecord, validateResponsibilityMappingSummary, validateRoleAdequacyStatement, validateRoleContextSummary, validateTruncationSummary } from "./validateMyDevKitContextCapsuleV1.js";
+const ARTIFACT_KIND = "my-dev-kit-retrieval-audit-record-v1";
+const AUDIT_STEP_STATUSES = ["ok", "skipped", "failed"];
+function validateContextCapsuleTool(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    return {
+        name: requiredString(ctx, requiredField(ctx, obj, "name", joinFieldPath(fieldPath, "name")), joinFieldPath(fieldPath, "name")),
+        version: requiredString(ctx, requiredField(ctx, obj, "version", joinFieldPath(fieldPath, "version")), joinFieldPath(fieldPath, "version"))
+    };
+}
+function validateRetrievalAuditRecordIndex(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    return {
+        indexPath: requiredString(ctx, requiredField(ctx, obj, "indexPath", joinFieldPath(fieldPath, "indexPath")), joinFieldPath(fieldPath, "indexPath")),
+        manifestPath: requiredString(ctx, requiredField(ctx, obj, "manifestPath", joinFieldPath(fieldPath, "manifestPath")), joinFieldPath(fieldPath, "manifestPath"))
+    };
+}
+function validateAuditStepRecord(ctx, value, fieldPath) {
+    const obj = requiredRecord(ctx, value, fieldPath);
+    const result = {};
+    for (const [key, val] of Object.entries(obj)) {
+        result[key] = requiredScalarLike(ctx, val, joinFieldPath(fieldPath, key));
+    }
+    return result;
+}
+function validateAuditStep(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    return {
+        id: requiredString(ctx, requiredField(ctx, obj, "id", joinFieldPath(fieldPath, "id")), joinFieldPath(fieldPath, "id")),
+        kind: requiredString(ctx, requiredField(ctx, obj, "kind", joinFieldPath(fieldPath, "kind")), joinFieldPath(fieldPath, "kind")),
+        description: requiredString(ctx, requiredField(ctx, obj, "description", joinFieldPath(fieldPath, "description")), joinFieldPath(fieldPath, "description")),
+        inputs: validateAuditStepRecord(ctx, requiredField(ctx, obj, "inputs", joinFieldPath(fieldPath, "inputs")), joinFieldPath(fieldPath, "inputs")),
+        outputs: validateAuditStepRecord(ctx, requiredField(ctx, obj, "outputs", joinFieldPath(fieldPath, "outputs")), joinFieldPath(fieldPath, "outputs")),
+        status: requiredLiteral(ctx, requiredField(ctx, obj, "status", joinFieldPath(fieldPath, "status")), joinFieldPath(fieldPath, "status"), AUDIT_STEP_STATUSES),
+        warnings: requiredStringArray(ctx, requiredField(ctx, obj, "warnings", joinFieldPath(fieldPath, "warnings")), joinFieldPath(fieldPath, "warnings"))
+    };
+}
+function validateFullFileReadRecommendation(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const continuationValue = requiredField(ctx, obj, "continuationOrExpansionAttempted", joinFieldPath(fieldPath, "continuationOrExpansionAttempted"));
+    let continuationOrExpansionAttempted;
+    if (continuationValue === "unavailable") {
+        continuationOrExpansionAttempted = "unavailable";
+    }
+    else if (typeof continuationValue === "boolean") {
+        continuationOrExpansionAttempted = continuationValue;
+    }
+    else {
+        return requiredLiteral(ctx, continuationValue, joinFieldPath(fieldPath, "continuationOrExpansionAttempted"), ["unavailable"]);
+    }
+    return {
+        filePath: requiredString(ctx, requiredField(ctx, obj, "filePath", joinFieldPath(fieldPath, "filePath")), joinFieldPath(fieldPath, "filePath")),
+        reason: requiredString(ctx, requiredField(ctx, obj, "reason", joinFieldPath(fieldPath, "reason")), joinFieldPath(fieldPath, "reason")),
+        missingContext: requiredString(ctx, requiredField(ctx, obj, "missingContext", joinFieldPath(fieldPath, "missingContext")), joinFieldPath(fieldPath, "missingContext")),
+        continuationOrExpansionAttempted
+    };
+}
+export function validateMyDevKitRetrievalAuditRecordV1(value, sourcePath) {
+    const ctx = { artifactKind: ARTIFACT_KIND, sourcePath };
+    try {
+        const schemaVersionResult = parseSupportedMajorOneSchemaVersion(requiredField(ctx, value, "schemaVersion", "schemaVersion"), ARTIFACT_KIND, sourcePath);
+        if ("ok" in schemaVersionResult)
+            return schemaVersionResult;
+        const record = {
+            schemaVersion: requiredString(ctx, value.schemaVersion, "schemaVersion"),
+            generatedAt: requiredString(ctx, requiredField(ctx, value, "generatedAt", "generatedAt"), "generatedAt"),
+            tool: validateContextCapsuleTool(ctx, requiredField(ctx, value, "tool", "tool"), "tool"),
+            request: validateContextCapsuleRequest(ctx, requiredField(ctx, value, "request", "request"), "request"),
+            index: validateRetrievalAuditRecordIndex(ctx, requiredField(ctx, value, "index", "index"), "index"),
+            steps: requiredArray(ctx, requiredField(ctx, value, "steps", "steps"), "steps").map((item, i) => validateAuditStep(ctx, item, arrayFieldPath("steps", i))),
+            fallbacks: requiredStringArray(ctx, requiredField(ctx, value, "fallbacks", "fallbacks"), "fallbacks"),
+            fullFileReadRecommendations: requiredArray(ctx, requiredField(ctx, value, "fullFileReadRecommendations", "fullFileReadRecommendations"), "fullFileReadRecommendations").map((item, i) => validateFullFileReadRecommendation(ctx, item, arrayFieldPath("fullFileReadRecommendations", i))),
+            warnings: requiredStringArray(ctx, requiredField(ctx, value, "warnings", "warnings"), "warnings"),
+            contextAdequacy: validateContextAdequacyStatement(ctx, requiredField(ctx, value, "contextAdequacy", "contextAdequacy"), "contextAdequacy"),
+            roleContext: validateRoleContextSummary(ctx, requiredField(ctx, value, "roleContext", "roleContext"), "roleContext"),
+            responsibilityMappings: validateResponsibilityMappingSummary(ctx, requiredField(ctx, value, "responsibilityMappings", "responsibilityMappings"), "responsibilityMappings"),
+            roleAdequacy: validateRoleAdequacyStatement(ctx, requiredField(ctx, value, "roleAdequacy", "roleAdequacy"), "roleAdequacy"),
+            freshness: validateFreshnessSummary(ctx, requiredField(ctx, value, "freshness", "freshness"), "freshness"),
+            budget: validateBudgetSummary(ctx, requiredField(ctx, value, "budget", "budget"), "budget"),
+            truncation: validateTruncationSummary(ctx, requiredField(ctx, value, "truncation", "truncation"), "truncation"),
+            fullFileFallback: validateFullFileFallbackSummary(ctx, requiredField(ctx, value, "fullFileFallback", "fullFileFallback"), "fullFileFallback"),
+            provenance: requiredArray(ctx, requiredField(ctx, value, "provenance", "provenance"), "provenance").map((item, i) => validateProvenanceRecord(ctx, item, arrayFieldPath("provenance", i)))
+        };
+        // The record above exists only to walk and type-check every field. Per the exact
+        // upstream-mirror contract, the returned artifact is always the original parsed
+        // reference, not a rebuilt object.
+        void record;
+        return {
+            ok: true,
+            artifactKind: ARTIFACT_KIND,
+            sourcePath,
+            schemaVersion: value.schemaVersion,
+            schemaMajor: 1,
+            artifact: value,
+            rawArtifact: value
+        };
+    }
+    catch (error) {
+        if (error instanceof ArtifactValidationError)
+            return error.failure;
+        throw error;
+    }
+}

package/dist/src/evaluation/upstreamArtifacts/validateOrchestratorWorkflowInstructionPacketV1.js

@@ -0,0 +1,235 @@
+import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
+import { ArtifactValidationError, arrayFieldPath, joinFieldPath, requiredArray, requiredBoolean, requiredField, requiredLiteral, requiredNullableNumber, requiredNumber, requiredObject, requiredRecord, requiredString, requiredStringArray } from "./runtimeValidation.js";
+const ARTIFACT_KIND = "orchestrator-workflow-instruction-packet-v1";
+const COMMAND_SIDE_EFFECTS = ["read-only", "writes-workspace", "modifies-project", "external-state"];
+const PACKET_INCLUSIONS = ["required", "optional"];
+const PACKET_ADEQUACY_STATUSES = ["adequate", "inadequate"];
+const BUDGET_LIMIT_NAMES = ["maxCommands", "maxRules", "maxRuleDepth", "maxEntryCharacters", "maxTotalCharacters"];
+function validatePrimaryEntry(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    const reqStr = (key) => requiredString(ctx, req(key), joinFieldPath(fieldPath, key));
+    const reqStrArr = (key) => requiredStringArray(ctx, req(key), joinFieldPath(fieldPath, key));
+    return {
+        id: reqStr("id"),
+        kind: requiredLiteral(ctx, req("kind"), joinFieldPath(fieldPath, "kind"), ["stage"]),
+        title: reqStr("title"),
+        description: reqStr("description"),
+        workflowRef: reqStr("workflowRef"),
+        stageName: reqStr("stageName"),
+        commandRefs: reqStrArr("commandRefs"),
+        ruleRefs: reqStrArr("ruleRefs"),
+        optionalCommandRefs: reqStrArr("optionalCommandRefs"),
+        optionalRuleRefs: reqStrArr("optionalRuleRefs"),
+        reportContractRef: reqStr("reportContractRef"),
+        taskInstructions: reqStr("taskInstructions"),
+        validationRequirements: reqStrArr("validationRequirements"),
+        stopConditions: reqStrArr("stopConditions")
+    };
+}
+function validateResolvedCommandEntry(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    const reqStr = (key) => requiredString(ctx, req(key), joinFieldPath(fieldPath, key));
+    return {
+        id: reqStr("id"),
+        kind: requiredLiteral(ctx, req("kind"), joinFieldPath(fieldPath, "kind"), ["command"]),
+        title: reqStr("title"),
+        description: reqStr("description"),
+        owner: reqStr("owner"),
+        command: reqStr("command"),
+        purpose: reqStr("purpose"),
+        sideEffect: requiredLiteral(ctx, req("sideEffect"), joinFieldPath(fieldPath, "sideEffect"), COMMAND_SIDE_EFFECTS),
+        included: requiredLiteral(ctx, req("included"), joinFieldPath(fieldPath, "included"), PACKET_INCLUSIONS)
+    };
+}
+function validateResolvedRuleEntry(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    const reqStr = (key) => requiredString(ctx, req(key), joinFieldPath(fieldPath, key));
+    return {
+        id: reqStr("id"),
+        kind: requiredLiteral(ctx, req("kind"), joinFieldPath(fieldPath, "kind"), ["rule"]),
+        title: reqStr("title"),
+        description: reqStr("description"),
+        category: reqStr("category"),
+        instruction: reqStr("instruction"),
+        ruleRefs: requiredStringArray(ctx, req("ruleRefs"), joinFieldPath(fieldPath, "ruleRefs")),
+        included: requiredLiteral(ctx, req("included"), joinFieldPath(fieldPath, "included"), PACKET_INCLUSIONS),
+        depth: requiredNumber(ctx, req("depth"), joinFieldPath(fieldPath, "depth"))
+    };
+}
+function validateReportContract(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    const reqStr = (key) => requiredString(ctx, req(key), joinFieldPath(fieldPath, key));
+    return {
+        id: reqStr("id"),
+        kind: requiredLiteral(ctx, req("kind"), joinFieldPath(fieldPath, "kind"), ["report-contract"]),
+        title: reqStr("title"),
+        description: reqStr("description"),
+        artifactKind: reqStr("artifactKind"),
+        purpose: reqStr("purpose"),
+        requiredOutputCategory: reqStr("requiredOutputCategory")
+    };
+}
+function validateResolutionProvenanceEntry(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    const reqStr = (key) => requiredString(ctx, req(key), joinFieldPath(fieldPath, key));
+    return {
+        rootWorkflowId: reqStr("rootWorkflowId"),
+        rootStageId: reqStr("rootStageId"),
+        sourceEntryId: reqStr("sourceEntryId"),
+        referenceField: reqStr("referenceField"),
+        referencedEntryId: reqStr("referencedEntryId"),
+        inclusionReason: reqStr("inclusionReason"),
+        depth: requiredNumber(ctx, req("depth"), joinFieldPath(fieldPath, "depth"))
+    };
+}
+function validateBudgetFinding(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    return {
+        limitName: requiredLiteral(ctx, req("limitName"), joinFieldPath(fieldPath, "limitName"), BUDGET_LIMIT_NAMES),
+        declaredLimit: requiredNullableNumber(ctx, req("declaredLimit"), joinFieldPath(fieldPath, "declaredLimit")),
+        used: requiredNumber(ctx, req("used"), joinFieldPath(fieldPath, "used")),
+        available: requiredNullableNumber(ctx, req("available"), joinFieldPath(fieldPath, "available")),
+        overLimit: requiredBoolean(ctx, req("overLimit"), joinFieldPath(fieldPath, "overLimit")),
+        amountExceeded: requiredNumber(ctx, req("amountExceeded"), joinFieldPath(fieldPath, "amountExceeded")),
+        affectedEntryIds: requiredStringArray(ctx, req("affectedEntryIds"), joinFieldPath(fieldPath, "affectedEntryIds"))
+    };
+}
+function validateInstructionBudgetAccounting(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    const perEntryObj = requiredRecord(ctx, req("perEntryCharacters"), joinFieldPath(fieldPath, "perEntryCharacters"));
+    const perEntryCharacters = {};
+    for (const [key, val] of Object.entries(perEntryObj)) {
+        perEntryCharacters[key] = requiredNumber(ctx, val, joinFieldPath(joinFieldPath(fieldPath, "perEntryCharacters"), key));
+    }
+    return {
+        findings: requiredArray(ctx, req("findings"), joinFieldPath(fieldPath, "findings")).map((item, i) => validateBudgetFinding(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "findings"), i))),
+        overLimit: requiredBoolean(ctx, req("overLimit"), joinFieldPath(fieldPath, "overLimit")),
+        adequate: requiredBoolean(ctx, req("adequate"), joinFieldPath(fieldPath, "adequate")),
+        totalCharacters: requiredNumber(ctx, req("totalCharacters"), joinFieldPath(fieldPath, "totalCharacters")),
+        perEntryCharacters
+    };
+}
+function validateTruncationRecord(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    return {
+        rootOptionalEntryId: requiredString(ctx, req("rootOptionalEntryId"), joinFieldPath(fieldPath, "rootOptionalEntryId")),
+        affectedEntryIds: requiredStringArray(ctx, req("affectedEntryIds"), joinFieldPath(fieldPath, "affectedEntryIds")),
+        limitingField: requiredLiteral(ctx, req("limitingField"), joinFieldPath(fieldPath, "limitingField"), BUDGET_LIMIT_NAMES),
+        declaredLimit: requiredNullableNumber(ctx, req("declaredLimit"), joinFieldPath(fieldPath, "declaredLimit")),
+        usedBefore: requiredNumber(ctx, req("usedBefore"), joinFieldPath(fieldPath, "usedBefore")),
+        attemptedAfter: requiredNumber(ctx, req("attemptedAfter"), joinFieldPath(fieldPath, "attemptedAfter")),
+        reason: requiredString(ctx, req("reason"), joinFieldPath(fieldPath, "reason"))
+    };
+}
+function validatePacketTruncation(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    return {
+        truncated: requiredBoolean(ctx, req("truncated"), joinFieldPath(fieldPath, "truncated")),
+        records: requiredArray(ctx, req("records"), joinFieldPath(fieldPath, "records")).map((item, i) => validateTruncationRecord(ctx, item, arrayFieldPath(joinFieldPath(fieldPath, "records"), i))),
+        droppedOptionalCommandIds: requiredStringArray(ctx, req("droppedOptionalCommandIds"), joinFieldPath(fieldPath, "droppedOptionalCommandIds")),
+        droppedOptionalRuleIds: requiredStringArray(ctx, req("droppedOptionalRuleIds"), joinFieldPath(fieldPath, "droppedOptionalRuleIds")),
+        droppedOptionalDependencyIds: requiredStringArray(ctx, req("droppedOptionalDependencyIds"), joinFieldPath(fieldPath, "droppedOptionalDependencyIds")),
+        warnings: requiredStringArray(ctx, req("warnings"), joinFieldPath(fieldPath, "warnings"))
+    };
+}
+function validatePacketAdequacy(ctx, value, fieldPath) {
+    const obj = requiredObject(ctx, value, fieldPath);
+    const req = (key) => requiredField(ctx, obj, key, joinFieldPath(fieldPath, key));
+    return {
+        status: requiredLiteral(ctx, req("status"), joinFieldPath(fieldPath, "status"), PACKET_ADEQUACY_STATUSES),
+        reasons: requiredStringArray(ctx, req("reasons"), joinFieldPath(fieldPath, "reasons")),
+        requiredContentComplete: requiredBoolean(ctx, req("requiredContentComplete"), joinFieldPath(fieldPath, "requiredContentComplete")),
+        requiredBudgetSatisfied: requiredBoolean(ctx, req("requiredBudgetSatisfied"), joinFieldPath(fieldPath, "requiredBudgetSatisfied")),
+        optionalContentDropped: requiredBoolean(ctx, req("optionalContentDropped"), joinFieldPath(fieldPath, "optionalContentDropped")),
+        affectedEntryIds: requiredStringArray(ctx, req("affectedEntryIds"), joinFieldPath(fieldPath, "affectedEntryIds"))
+    };
+}
+function findDuplicates(ids) {
+    const seen = new Set();
+    const dupes = new Set();
+    for (const id of ids) {
+        if (seen.has(id))
+            dupes.add(id);
+        seen.add(id);
+    }
+    return [...dupes];
+}
+export function validateOrchestratorWorkflowInstructionPacketV1(value, sourcePath) {
+    const ctx = { artifactKind: ARTIFACT_KIND, sourcePath };
+    try {
+        const schemaVersionResult = parseSupportedMajorOneSchemaVersion(requiredField(ctx, value, "schemaVersion", "schemaVersion"), ARTIFACT_KIND, sourcePath);
+        if ("ok" in schemaVersionResult)
+            return schemaVersionResult;
+        const resolvedCommands = requiredArray(ctx, requiredField(ctx, value, "resolvedCommands", "resolvedCommands"), "resolvedCommands").map((item, i) => validateResolvedCommandEntry(ctx, item, arrayFieldPath("resolvedCommands", i)));
+        const dupCommandIds = findDuplicates(resolvedCommands.map((c) => c.id));
+        if (dupCommandIds.length > 0) {
+            return {
+                ok: false,
+                artifactKind: ARTIFACT_KIND,
+                sourcePath,
+                code: "DUPLICATE_RESOLVED_COMMAND_ID",
+                message: `Artifact "${ARTIFACT_KIND}" at "${sourcePath}" has duplicate resolvedCommands[].id value(s): ${dupCommandIds.join(", ")}.`,
+                fieldPath: "resolvedCommands",
+                actual: dupCommandIds
+            };
+        }
+        const resolvedRules = requiredArray(ctx, requiredField(ctx, value, "resolvedRules", "resolvedRules"), "resolvedRules").map((item, i) => validateResolvedRuleEntry(ctx, item, arrayFieldPath("resolvedRules", i)));
+        const dupRuleIds = findDuplicates(resolvedRules.map((r) => r.id));
+        if (dupRuleIds.length > 0) {
+            return {
+                ok: false,
+                artifactKind: ARTIFACT_KIND,
+                sourcePath,
+                code: "DUPLICATE_RESOLVED_RULE_ID",
+                message: `Artifact "${ARTIFACT_KIND}" at "${sourcePath}" has duplicate resolvedRules[].id value(s): ${dupRuleIds.join(", ")}.`,
+                fieldPath: "resolvedRules",
+                actual: dupRuleIds
+            };
+        }
+        const packet = {
+            schemaVersion: requiredString(ctx, value.schemaVersion, "schemaVersion"),
+            catalogSchemaVersion: requiredString(ctx, requiredField(ctx, value, "catalogSchemaVersion", "catalogSchemaVersion"), "catalogSchemaVersion"),
+            catalogVersion: requiredString(ctx, requiredField(ctx, value, "catalogVersion", "catalogVersion"), "catalogVersion"),
+            workflowId: requiredString(ctx, requiredField(ctx, value, "workflowId", "workflowId"), "workflowId"),
+            stageId: requiredString(ctx, requiredField(ctx, value, "stageId", "stageId"), "stageId"),
+            primaryEntry: validatePrimaryEntry(ctx, requiredField(ctx, value, "primaryEntry", "primaryEntry"), "primaryEntry"),
+            resolvedCommands,
+            resolvedRules,
+            reportContract: validateReportContract(ctx, requiredField(ctx, value, "reportContract", "reportContract"), "reportContract"),
+            validationRequirements: requiredStringArray(ctx, requiredField(ctx, value, "validationRequirements", "validationRequirements"), "validationRequirements"),
+            stopConditions: requiredStringArray(ctx, requiredField(ctx, value, "stopConditions", "stopConditions"), "stopConditions"),
+            resolutionProvenance: requiredArray(ctx, requiredField(ctx, value, "resolutionProvenance", "resolutionProvenance"), "resolutionProvenance").map((item, i) => validateResolutionProvenanceEntry(ctx, item, arrayFieldPath("resolutionProvenance", i))),
+            budget: validateInstructionBudgetAccounting(ctx, requiredField(ctx, value, "budget", "budget"), "budget"),
+            truncation: validatePacketTruncation(ctx, requiredField(ctx, value, "truncation", "truncation"), "truncation"),
+            adequacy: validatePacketAdequacy(ctx, requiredField(ctx, value, "adequacy", "adequacy"), "adequacy"),
+            unresolvedReferences: requiredStringArray(ctx, requiredField(ctx, value, "unresolvedReferences", "unresolvedReferences"), "unresolvedReferences"),
+            warnings: requiredStringArray(ctx, requiredField(ctx, value, "warnings", "warnings"), "warnings")
+        };
+        // The record above exists only to walk and type-check every field. The returned
+        // artifact is always the original parsed reference, never a rebuilt object.
+        void packet;
+        return {
+            ok: true,
+            artifactKind: ARTIFACT_KIND,
+            sourcePath,
+            schemaVersion: value.schemaVersion,
+            schemaMajor: 1,
+            artifact: value,
+            rawArtifact: value
+        };
+    }
+    catch (error) {
+        if (error instanceof ArtifactValidationError)
+            return error.failure;
+        throw error;
+    }
+}

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

@@ -0,0 +1,46 @@
+import { loadV043StrategyArtifacts } from "./loadV043StrategyArtifacts.js";
+import { V043_STAGE_CONTEXT_STRATEGY_IDS } from "./v043StrategyIds.js";
+import { validateV043StrategyInput } from "./validateV043StrategyInput.js";
+function extractValidStrategyId(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return null;
+    const strategyId = value.strategyId;
+    if (typeof strategyId === "string" && V043_STAGE_CONTEXT_STRATEGY_IDS.includes(strategyId)) {
+        return strategyId;
+    }
+    return null;
+}
+export async function executeV043StageContextStrategy(value) {
+    const validation = validateV043StrategyInput(value);
+    if (!validation.ok) {
+        const issues = validation.issues.map((issue) => ({
+            code: "INVALID_STRATEGY_INPUT",
+            fieldPath: issue.fieldPath,
+            message: issue.message,
+            details: issue
+        }));
+        return {
+            status: "invalid-input",
+            strategyId: extractValidStrategyId(value),
+            input: value,
+            issues
+        };
+    }
+    try {
+        return await loadV043StrategyArtifacts(validation.input);
+    }
+    catch {
+        return {
+            status: "failed",
+            strategyId: extractValidStrategyId(value),
+            input: value,
+            issues: [
+                {
+                    code: "UNEXPECTED_EXECUTION_ERROR",
+                    fieldPath: "execution",
+                    message: "Unexpected v0.4.3 stage-context strategy execution failure."
+                }
+            ]
+        };
+    }
+}

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

@@ -1,3 +1,12 @@
 export * from "./config.js";
 export * from "./plugin.js";
 export * from "./resultMapping.js";
+export * from "./v043FullWorkflowLibraryFixture.js";
+export { readV043FullWorkflowLibraryFixture } from "./readV043FullWorkflowLibraryFixture.js";
+export * from "./v043StrategyExecutionTypes.js";
+export { executeV043StageContextStrategy } from "./executeV043StageContextStrategy.js";
+export * from "./resolveV043StrategyInputs.js";
+export { evaluateV043StageContextExecution } from "../../../evaluation/stageContextMetrics/index.js";
+export * from "./v043RunAssuranceTypes.js";
+export { validateV043RunAssuranceConfig } from "./validateV043RunAssuranceConfig.js";
+export { runV043StageContextStrategyWithAssurance } from "./runV043StageContextStrategyWithAssurance.js";