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

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

@@ -0,0 +1,112 @@
+import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
+import { ArtifactValidationError, arrayFieldPath, joinFieldPath, optionalField, optionalString, 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);
+    const result = {
+        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"))
+    };
+    if (optionalField(obj, "manifestSchemaVersion") !== undefined) {
+        result.manifestSchemaVersion = optionalString(ctx, obj.manifestSchemaVersion, joinFieldPath(fieldPath, "manifestSchemaVersion"));
+    }
+    if (optionalField(obj, "projectRoot") !== undefined) {
+        result.projectRoot = optionalString(ctx, obj.projectRoot, joinFieldPath(fieldPath, "projectRoot"));
+    }
+    return result;
+}
+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/evaluation/upstreamArtifacts/validateSupplementalContextDocumentV1.js

@@ -0,0 +1,148 @@
+import { makeFailure } from "./runtimeValidation.js";
+import { parseSupplementalContextText } from "./supplementalContextTextParser.js";
+import { REQUIRED_METADATA_BY_DOCUMENT_KIND, REQUIRED_SECTIONS_BY_DOCUMENT_KIND, ROLE_BY_DOCUMENT_KIND, SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR, SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR, VALID_ADEQUACY_VALUES, VALID_DECLARED_STATUSES, VALID_FRESHNESS_VALUES, VALID_REPOSITORY_SCOPES, VALID_TRUNCATION_VALUES, isRetrievalReportKind, isTestKind } from "./supplementalContextTypes.js";
+const SCHEMA_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+$/;
+function supportedMajorForKind(kind) {
+    return isRetrievalReportKind(kind)
+        ? SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR
+        : SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR;
+}
+function literalOrFail(artifactKind, sourcePath, fieldPath, value, allowed, errorCode = "INVALID_LITERAL_VALUE") {
+    if (allowed.includes(value))
+        return value;
+    return {
+        ok: false,
+        artifactKind,
+        sourcePath,
+        code: errorCode,
+        message: `Field "${fieldPath}" in artifact "${artifactKind}" at "${sourcePath}" has invalid value "${value}". Expected one of: ${allowed.join(", ")}.`,
+        fieldPath,
+        expected: allowed.join(" | "),
+        actual: value
+    };
+}
+function isFailure(value) {
+    return typeof value === "object" && value !== null && value.ok === false;
+}
+export function validateSupplementalContextDocumentV1(artifactKind, expectedKind, text, sourcePath) {
+    const parsed = parseSupplementalContextText(text);
+    if (parsed.metadataOrder.length === 0 && parsed.sectionOrder.length === 0) {
+        return makeFailure(artifactKind, sourcePath, "MALFORMED_TEXT_ARTIFACT", `Artifact "${artifactKind}" at "${sourcePath}" contains no recognizable "Key: value" metadata or "## Heading" sections.`);
+    }
+    // Kind/role identity is checked before general required-metadata/section completeness so
+    // that feeding one document kind's file to another kind's reader is reported as a
+    // structural identity mismatch (DOCUMENT_KIND_MISMATCH / DOCUMENT_ROLE_MISMATCH) rather
+    // than as an incidental "missing metadata key" from the wrong kind's required-field list.
+    const declaredKind = parsed.metadata["Document kind"];
+    if (declaredKind !== expectedKind) {
+        return makeFailure(artifactKind, sourcePath, "DOCUMENT_KIND_MISMATCH", `Artifact "${artifactKind}" at "${sourcePath}" declares document kind "${declaredKind}" but this reader expects "${expectedKind}".`, "Document kind", expectedKind, declaredKind);
+    }
+    const expectedRole = ROLE_BY_DOCUMENT_KIND[expectedKind];
+    const declaredRole = parsed.metadata["Role"];
+    if (declaredRole !== expectedRole) {
+        return makeFailure(artifactKind, sourcePath, "DOCUMENT_ROLE_MISMATCH", `Artifact "${artifactKind}" at "${sourcePath}" declares role "${declaredRole}" but this reader expects "${expectedRole}".`, "Role", expectedRole, declaredRole);
+    }
+    const requiredMetadata = REQUIRED_METADATA_BY_DOCUMENT_KIND[expectedKind];
+    for (const key of requiredMetadata) {
+        if (!(key in parsed.metadata)) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_METADATA", `Artifact "${artifactKind}" at "${sourcePath}" is missing required metadata key "${key}".`, key, "present");
+        }
+    }
+    const requiredSections = REQUIRED_SECTIONS_BY_DOCUMENT_KIND[expectedKind];
+    for (const heading of requiredSections) {
+        if (!(heading in parsed.sections)) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_SECTION", `Artifact "${artifactKind}" at "${sourcePath}" is missing required section heading "## ${heading}".`, heading, "present");
+        }
+    }
+    const schemaVersion = parsed.metadata["Schema version"];
+    if (!SCHEMA_VERSION_PATTERN.test(schemaVersion)) {
+        return makeFailure(artifactKind, sourcePath, "INVALID_SCHEMA_VERSION", `Artifact "${artifactKind}" at "${sourcePath}" has an invalid "Schema version": expected strict "x.y.z" semantic version.`, "Schema version", "^[0-9]+\\.[0-9]+\\.[0-9]+$", schemaVersion);
+    }
+    const major = Number(schemaVersion.split(".")[0]);
+    const supportedMajor = supportedMajorForKind(expectedKind);
+    if (major !== supportedMajor) {
+        return makeFailure(artifactKind, sourcePath, "UNSUPPORTED_SCHEMA_MAJOR", `Artifact "${artifactKind}" at "${sourcePath}" has unsupported schema major "${major}" in "Schema version": supported major is ${supportedMajor}.`, "Schema version", String(supportedMajor), schemaVersion);
+    }
+    const status = literalOrFail(artifactKind, sourcePath, "Status", parsed.metadata["Status"], VALID_DECLARED_STATUSES, "UNKNOWN_STATUS_VALUE");
+    if (isFailure(status))
+        return status;
+    const repositoryScope = literalOrFail(artifactKind, sourcePath, "Repository scope", parsed.metadata["Repository scope"], VALID_REPOSITORY_SCOPES);
+    if (isFailure(repositoryScope))
+        return repositoryScope;
+    const freshness = literalOrFail(artifactKind, sourcePath, "Freshness", parsed.metadata["Freshness"], VALID_FRESHNESS_VALUES);
+    if (isFailure(freshness))
+        return freshness;
+    const adequacy = literalOrFail(artifactKind, sourcePath, "Adequacy", parsed.metadata["Adequacy"], VALID_ADEQUACY_VALUES);
+    if (isFailure(adequacy))
+        return adequacy;
+    const requiredEvidenceTruncated = literalOrFail(artifactKind, sourcePath, "Required evidence truncated", parsed.metadata["Required evidence truncated"], VALID_TRUNCATION_VALUES);
+    if (isFailure(requiredEvidenceTruncated))
+        return requiredEvidenceTruncated;
+    const indexIdentity = parsed.metadata["Index identity"];
+    if (!indexIdentity || indexIdentity.length === 0) {
+        return makeFailure(artifactKind, sourcePath, "MISSING_CANONICAL_IDENTITY", `Artifact "${artifactKind}" at "${sourcePath}" is missing a non-empty canonical "Index identity".`, "Index identity", "present");
+    }
+    const document = {
+        documentKind: expectedKind,
+        role: expectedRole,
+        schemaVersion,
+        schemaMajor: 1,
+        status,
+        repositoryScope,
+        freshness,
+        adequacy,
+        requiredEvidenceTruncated,
+        contextCapsuleSchemaVersion: parsed.metadata["Context capsule schema version"],
+        retrievalAuditSchemaVersion: parsed.metadata["Retrieval audit schema version"],
+        toolName: parsed.metadata["Tool name"],
+        toolVersion: parsed.metadata["Tool version"],
+        indexIdentity,
+        rawMetadata: parsed.metadata,
+        sections: parsed.sections,
+        sectionOrder: parsed.sectionOrder,
+        metadataOrder: parsed.metadataOrder,
+        warnings: []
+    };
+    if (isRetrievalReportKind(expectedKind)) {
+        document.requestSchemaVersion = parsed.metadata["Request schema version"];
+        const fullFileFallbackUsed = literalOrFail(artifactKind, sourcePath, "Full-file fallback used", parsed.metadata["Full-file fallback used"], VALID_TRUNCATION_VALUES);
+        if (isFailure(fullFileFallbackUsed))
+            return fullFileFallbackUsed;
+        document.fullFileFallbackUsed = fullFileFallbackUsed;
+        const determinismChecked = literalOrFail(artifactKind, sourcePath, "Determinism checked", parsed.metadata["Determinism checked"], VALID_TRUNCATION_VALUES);
+        if (isFailure(determinismChecked))
+            return determinismChecked;
+        document.determinismChecked = determinismChecked;
+    }
+    if (isTestKind(expectedKind)) {
+        const responsibilityMappingsTruncated = literalOrFail(artifactKind, sourcePath, "Responsibility mappings truncated", parsed.metadata["Responsibility mappings truncated"], VALID_TRUNCATION_VALUES);
+        if (isFailure(responsibilityMappingsTruncated))
+            return responsibilityMappingsTruncated;
+        document.responsibilityMappingsTruncated = responsibilityMappingsTruncated;
+        // Preserved verbatim, never validated against the orchestrator's internal
+        // CriticalResponsibilityMappingState enum -- see supplementalContextTypes.ts.
+        const criticalStatus = parsed.metadata["Critical responsibility mapping status"];
+        if (!criticalStatus || criticalStatus.length === 0) {
+            return makeFailure(artifactKind, sourcePath, "MISSING_REQUIRED_METADATA", `Artifact "${artifactKind}" at "${sourcePath}" is missing a non-empty "Critical responsibility mapping status".`, "Critical responsibility mapping status", "present");
+        }
+        document.criticalResponsibilityMappingStatus = criticalStatus;
+    }
+    if (parsed.duplicateMetadataKeys.length > 0) {
+        document.warnings.push(`Duplicate metadata keys were ignored (first occurrence kept): ${parsed.duplicateMetadataKeys.join(", ")}.`);
+    }
+    if (parsed.duplicateSectionHeadings.length > 0) {
+        document.warnings.push(`Duplicate section headings were ignored (first occurrence kept): ${parsed.duplicateSectionHeadings.join(", ")}.`);
+    }
+    if (parsed.emptyMetadataKeys.length > 0) {
+        document.warnings.push(`Metadata keys had empty values: ${parsed.emptyMetadataKeys.join(", ")}.`);
+    }
+    return {
+        ok: true,
+        artifactKind,
+        sourcePath,
+        schemaVersion,
+        schemaMajor: 1,
+        artifact: document,
+        rawArtifact: { metadata: parsed.metadata, sections: parsed.sections }
+    };
+}

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";