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

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

@@ -0,0 +1,247 @@
+// Lab-owned bounded plain-object adapter for the frozen my-dev-kit-orchestrator
+// ContextReadinessResult (commit bc08a05d3b52a629e7e4504372af199c324c4ae4,
+// src/instructions/contextReadiness.ts). At the frozen commit, readiness is never
+// serialized to a stable file artifact -- `check`/`export` only render it as formatted
+// text (src/commands/check.ts, src/commands/export.ts). This adapter therefore
+// validates and normalizes a plain object (as constructed by a caller that already has
+// an in-memory readiness result -- e.g. a future integration or a test fixture), rather
+// than parsing a file. It never imports orchestrator runtime code and never
+// recomputes/reevaluates readiness, producer parity, or issue prioritization -- it only
+// preserves what is already declared on the object.
+import { makeFailure } from "./runtimeValidation.js";
+import { VALID_ADEQUACY_VALUES, VALID_FRESHNESS_VALUES, VALID_TRUNCATION_VALUES } from "./supplementalContextTypes.js";
+const ARTIFACT_KIND = "orchestrator-context-readiness-result-v1";
+export const READINESS_DECISIONS = ["not-required", "ready", "refresh-required"];
+export const READINESS_CLASSIFICATIONS = [
+    "not-required",
+    "ready",
+    "missing",
+    "template",
+    "partial",
+    "malformed",
+    "unsupported-schema",
+    "incompatible",
+    "source-reference-missing",
+    "source-reference-unreadable",
+    "source-evidence-malformed",
+    "source-evidence-unsupported-schema",
+    "role-mismatch",
+    "repository-scope-mismatch",
+    "repository-identity-incomplete",
+    "index-identity-incomplete",
+    "index-identity-mismatch",
+    "freshness-unknown",
+    "stale",
+    "adequacy-unknown",
+    "inadequate",
+    "conflict",
+    "required-evidence-truncated",
+    "required-evidence-incomplete",
+    "provenance-missing",
+    "test-strategy-missing",
+    "test-responsibility-invalid",
+    "test-responsibility-criticality-unknown",
+    "responsibility-mappings-truncated",
+    "critical-responsibilities-unmapped"
+];
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function fail(sourceLabel, code, message, fieldPath) {
+    return makeFailure(ARTIFACT_KIND, sourceLabel, code, message, fieldPath);
+}
+function requireEnum(value, allowed, fieldPath, sourceLabel, errorCode) {
+    if (typeof value !== "string" || !allowed.includes(value)) {
+        return fail(sourceLabel, errorCode, `Field "${fieldPath}" must be one of: ${allowed.join(", ")}. Received: ${JSON.stringify(value)}.`, fieldPath);
+    }
+    return value;
+}
+function isReadinessIssue(value) {
+    if (!isPlainObject(value))
+        return false;
+    return (typeof value.code === "string" &&
+        (value.severity === "error" || value.severity === "warning") &&
+        typeof value.message === "string" &&
+        typeof value.priority === "number" &&
+        typeof value.correctiveAction === "string" &&
+        typeof value.evidenceTarget === "string" &&
+        typeof value.stageId === "string" &&
+        (value.contextKind === "implementation" || value.contextKind === "test"));
+}
+function isBlockerSummary(value) {
+    if (!isPlainObject(value))
+        return false;
+    return ((value.contextKind === "implementation" || value.contextKind === "test") &&
+        typeof value.primaryCode === "string" &&
+        typeof value.primaryReason === "string" &&
+        typeof value.correctiveAction === "string" &&
+        typeof value.evidenceTarget === "string" &&
+        Array.isArray(value.blockingIssueCodes) &&
+        value.blockingIssueCodes.every((c) => typeof c === "string") &&
+        Array.isArray(value.supportingIssueCodes) &&
+        value.supportingIssueCodes.every((c) => typeof c === "string"));
+}
+export function validateOrchestratorContextReadinessResultV1(input, sourceLabel) {
+    if (!isPlainObject(input)) {
+        return fail(sourceLabel, "MALFORMED_TEXT_ARTIFACT", `Readiness input at "${sourceLabel}" must be a plain object.`);
+    }
+    const schemaVersion = input["schemaVersion"];
+    if (typeof schemaVersion !== "string" || schemaVersion.length === 0) {
+        return fail(sourceLabel, "MISSING_REQUIRED_FIELD", `Readiness input at "${sourceLabel}" is missing "schemaVersion".`, "schemaVersion");
+    }
+    const kind = requireEnum(input["kind"], ["implementation", "test"], "kind", sourceLabel, "MISSING_REQUIRED_FIELD");
+    if (typeof kind !== "string")
+        return kind;
+    const roleAllowed = ["implementation", "test-implementation"];
+    const role = requireEnum(input["role"], roleAllowed, "role", sourceLabel, "MISSING_REQUIRED_FIELD");
+    if (typeof role !== "string")
+        return role;
+    const expectedRole = kind === "implementation" ? "implementation" : "test-implementation";
+    if (role !== expectedRole) {
+        return fail(sourceLabel, "DOCUMENT_ROLE_MISMATCH", `Readiness input at "${sourceLabel}" declares kind "${kind}" with role "${role}", but role must be "${expectedRole}" for that kind.`, "role");
+    }
+    const decision = requireEnum(input["decision"], READINESS_DECISIONS, "decision", sourceLabel, "UNKNOWN_READINESS_DECISION");
+    if (typeof decision !== "string")
+        return decision;
+    const classification = requireEnum(input["classification"], READINESS_CLASSIFICATIONS, "classification", sourceLabel, "INVALID_LITERAL_VALUE");
+    if (typeof classification !== "string")
+        return classification;
+    const stageId = input["stageId"];
+    if (typeof stageId !== "string" || stageId.length === 0) {
+        return fail(sourceLabel, "MISSING_REQUIRED_FIELD", `Readiness input at "${sourceLabel}" is missing "stageId".`, "stageId");
+    }
+    const packetPath = input["packetPath"];
+    const reportPath = input["reportPath"];
+    if (typeof packetPath !== "string" || typeof reportPath !== "string") {
+        return fail(sourceLabel, "MISSING_REQUIRED_FIELD", `Readiness input at "${sourceLabel}" must declare string "packetPath" and "reportPath".`);
+    }
+    const issuesRaw = input["issues"];
+    if (!Array.isArray(issuesRaw) || !issuesRaw.every(isReadinessIssue)) {
+        return fail(sourceLabel, "MALFORMED_ISSUE_STRUCTURE", `Readiness input at "${sourceLabel}" has a malformed "issues" array.`, "issues");
+    }
+    const issues = issuesRaw;
+    const warningsRaw = input["warnings"];
+    if (!Array.isArray(warningsRaw) || !warningsRaw.every((w) => typeof w === "string")) {
+        return fail(sourceLabel, "INVALID_FIELD_TYPE", `Readiness input at "${sourceLabel}" must declare a string array "warnings".`, "warnings");
+    }
+    const blockingIssueCodesRaw = input["blockingIssueCodes"];
+    if (!Array.isArray(blockingIssueCodesRaw) || !blockingIssueCodesRaw.every((c) => typeof c === "string")) {
+        return fail(sourceLabel, "INVALID_FIELD_TYPE", `Readiness input at "${sourceLabel}" must declare a string array "blockingIssueCodes".`, "blockingIssueCodes");
+    }
+    let primaryIssue;
+    if (input["primaryIssue"] !== undefined) {
+        if (!isReadinessIssue(input["primaryIssue"])) {
+            return fail(sourceLabel, "MALFORMED_ISSUE_STRUCTURE", `Readiness input at "${sourceLabel}" has a malformed "primaryIssue".`, "primaryIssue");
+        }
+        primaryIssue = input["primaryIssue"];
+    }
+    let blockerSummary;
+    if (input["blockerSummary"] !== undefined) {
+        if (!isBlockerSummary(input["blockerSummary"])) {
+            return fail(sourceLabel, "MALFORMED_ISSUE_STRUCTURE", `Readiness input at "${sourceLabel}" has a malformed "blockerSummary".`, "blockerSummary");
+        }
+        blockerSummary = input["blockerSummary"];
+    }
+    const affectedResponsibilityIdsRaw = input["affectedResponsibilityIds"];
+    if (!Array.isArray(affectedResponsibilityIdsRaw) || !affectedResponsibilityIdsRaw.every((id) => typeof id === "string")) {
+        return fail(sourceLabel, "INVALID_FIELD_TYPE", `Readiness input at "${sourceLabel}" must declare a string array "affectedResponsibilityIds".`, "affectedResponsibilityIds");
+    }
+    const evaluatedFreshness = requireEnum(input["evaluatedFreshness"], VALID_FRESHNESS_VALUES, "evaluatedFreshness", sourceLabel, "MISSING_REQUIRED_FIELD");
+    if (typeof evaluatedFreshness !== "string")
+        return evaluatedFreshness;
+    const evaluatedAdequacy = requireEnum(input["evaluatedAdequacy"], VALID_ADEQUACY_VALUES, "evaluatedAdequacy", sourceLabel, "MISSING_REQUIRED_FIELD");
+    if (typeof evaluatedAdequacy !== "string")
+        return evaluatedAdequacy;
+    const requiredEvidenceTruncated = requireEnum(input["requiredEvidenceTruncated"], VALID_TRUNCATION_VALUES, "requiredEvidenceTruncated", sourceLabel, "MISSING_REQUIRED_FIELD");
+    if (typeof requiredEvidenceTruncated !== "string")
+        return requiredEvidenceTruncated;
+    let declaredFreshness;
+    if (input["declaredFreshness"] !== undefined) {
+        const v = requireEnum(input["declaredFreshness"], VALID_FRESHNESS_VALUES, "declaredFreshness", sourceLabel, "INVALID_LITERAL_VALUE");
+        if (typeof v !== "string")
+            return v;
+        declaredFreshness = v;
+    }
+    let declaredAdequacy;
+    if (input["declaredAdequacy"] !== undefined) {
+        const v = requireEnum(input["declaredAdequacy"], VALID_ADEQUACY_VALUES, "declaredAdequacy", sourceLabel, "INVALID_LITERAL_VALUE");
+        if (typeof v !== "string")
+            return v;
+        declaredAdequacy = v;
+    }
+    let responsibilityMappingsTruncated;
+    if (input["responsibilityMappingsTruncated"] !== undefined) {
+        const v = requireEnum(input["responsibilityMappingsTruncated"], VALID_TRUNCATION_VALUES, "responsibilityMappingsTruncated", sourceLabel, "INVALID_LITERAL_VALUE");
+        if (typeof v !== "string")
+            return v;
+        responsibilityMappingsTruncated = v;
+    }
+    const readyWithAssumptions = input["readyWithAssumptions"];
+    if (typeof readyWithAssumptions !== "boolean") {
+        return fail(sourceLabel, "INVALID_FIELD_TYPE", `Readiness input at "${sourceLabel}" must declare boolean "readyWithAssumptions".`, "readyWithAssumptions");
+    }
+    const provenanceSummary = input["provenanceSummary"];
+    if (typeof provenanceSummary !== "string") {
+        return fail(sourceLabel, "MISSING_REQUIRED_FIELD", `Readiness input at "${sourceLabel}" is missing string "provenanceSummary".`, "provenanceSummary");
+    }
+    const indexIdentity = input["indexIdentity"];
+    if (indexIdentity !== undefined && (typeof indexIdentity !== "string" || indexIdentity.length === 0)) {
+        return fail(sourceLabel, "MISSING_CANONICAL_IDENTITY", `Readiness input at "${sourceLabel}" declares a non-string or empty "indexIdentity".`, "indexIdentity");
+    }
+    const sourceCapsulePath = input["sourceCapsulePath"];
+    const sourceAuditPath = input["sourceAuditPath"];
+    if (sourceCapsulePath !== undefined && typeof sourceCapsulePath !== "string") {
+        return fail(sourceLabel, "INVALID_FIELD_TYPE", `Readiness input at "${sourceLabel}" has non-string "sourceCapsulePath".`, "sourceCapsulePath");
+    }
+    if (sourceAuditPath !== undefined && typeof sourceAuditPath !== "string") {
+        return fail(sourceLabel, "INVALID_FIELD_TYPE", `Readiness input at "${sourceLabel}" has non-string "sourceAuditPath".`, "sourceAuditPath");
+    }
+    const artifact = {
+        schemaVersion,
+        kind,
+        role,
+        decision,
+        classification,
+        stageId,
+        packetPath,
+        reportPath,
+        sourceCapsulePath: sourceCapsulePath,
+        sourceAuditPath: sourceAuditPath,
+        issues,
+        warnings: warningsRaw,
+        blockingIssueCodes: blockingIssueCodesRaw,
+        primaryIssue,
+        blockerSummary,
+        affectedResponsibilityIds: affectedResponsibilityIdsRaw,
+        declaredFreshness,
+        evaluatedFreshness,
+        declaredAdequacy,
+        evaluatedAdequacy,
+        requiredEvidenceTruncated,
+        responsibilityMappingsTruncated,
+        indexIdentity: indexIdentity,
+        readyWithAssumptions,
+        provenanceSummary
+    };
+    return {
+        ok: true,
+        artifactKind: ARTIFACT_KIND,
+        sourcePath: sourceLabel,
+        schemaVersion,
+        schemaMajor: 1,
+        artifact,
+        rawArtifact: input
+    };
+}
+export function checkSupplementalReadinessIdentityConsistency(document, readiness) {
+    if (readiness.indexIdentity === undefined)
+        return null;
+    if (document.indexIdentity === readiness.indexIdentity)
+        return null;
+    return {
+        code: "INCOMPATIBLE_ARTIFACT_IDENTITY",
+        message: `Supplemental document index identity "${document.indexIdentity}" does not match readiness result index identity "${readiness.indexIdentity}".`,
+        documentIndexIdentity: document.indexIdentity,
+        readinessIndexIdentity: readiness.indexIdentity
+    };
+}

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

@@ -0,0 +1,9 @@
+import { readTextArtifactFile } from "./readSupplementalContextTextFile.js";
+import { validateSupplementalContextDocumentV1 } from "./validateSupplementalContextDocumentV1.js";
+const ARTIFACT_KIND = "orchestrator-implementation-context-packet-v1";
+export async function readImplementationContextPacketV1(sourcePath) {
+    const loaded = await readTextArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateSupplementalContextDocumentV1(ARTIFACT_KIND, "implementation-context-packet", loaded.text, loaded.sourcePath);
+}

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

@@ -0,0 +1,9 @@
+import { readTextArtifactFile } from "./readSupplementalContextTextFile.js";
+import { validateSupplementalContextDocumentV1 } from "./validateSupplementalContextDocumentV1.js";
+const ARTIFACT_KIND = "orchestrator-implementation-context-retrieval-report-v1";
+export async function readImplementationContextRetrievalReportV1(sourcePath) {
+    const loaded = await readTextArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateSupplementalContextDocumentV1(ARTIFACT_KIND, "implementation-context-retrieval-report", loaded.text, loaded.sourcePath);
+}

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

@@ -0,0 +1,29 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+export async function readTextArtifactFile(artifactKind, sourcePathInput) {
+    const sourcePath = path.resolve(sourcePathInput);
+    let text;
+    try {
+        text = await readFile(sourcePath, "utf8");
+    }
+    catch (error) {
+        const code = error.code;
+        if (code === "ENOENT") {
+            return {
+                ok: false,
+                artifactKind,
+                sourcePath,
+                code: "FILE_NOT_FOUND",
+                message: `Artifact "${artifactKind}" file was not found at "${sourcePath}".`
+            };
+        }
+        return {
+            ok: false,
+            artifactKind,
+            sourcePath,
+            code: "UNREADABLE_FILE",
+            message: `Artifact "${artifactKind}" file at "${sourcePath}" could not be read: ${error.message}`
+        };
+    }
+    return { ok: true, sourcePath, text };
+}

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

@@ -0,0 +1,9 @@
+import { readTextArtifactFile } from "./readSupplementalContextTextFile.js";
+import { validateSupplementalContextDocumentV1 } from "./validateSupplementalContextDocumentV1.js";
+const ARTIFACT_KIND = "orchestrator-test-context-packet-v1";
+export async function readTestContextPacketV1(sourcePath) {
+    const loaded = await readTextArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateSupplementalContextDocumentV1(ARTIFACT_KIND, "test-context-packet", loaded.text, loaded.sourcePath);
+}

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

@@ -0,0 +1,9 @@
+import { readTextArtifactFile } from "./readSupplementalContextTextFile.js";
+import { validateSupplementalContextDocumentV1 } from "./validateSupplementalContextDocumentV1.js";
+const ARTIFACT_KIND = "orchestrator-test-context-retrieval-report-v1";
+export async function readTestContextRetrievalReportV1(sourcePath) {
+    const loaded = await readTextArtifactFile(ARTIFACT_KIND, sourcePath);
+    if (!loaded.ok)
+        return loaded;
+    return validateSupplementalContextDocumentV1(ARTIFACT_KIND, "test-context-retrieval-report", loaded.text, loaded.sourcePath);
+}

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

@@ -0,0 +1,75 @@
+// Deterministic line-based parser for the frozen my-dev-kit-orchestrator supplemental
+// repository-context document format (commit bc08a05d3b52a629e7e4504372af199c324c4ae4,
+// src/instructions/supplementalContextParser.ts): "Key: value" metadata lines before the
+// first "## " heading, then "## Heading" sections running to the next heading or EOF.
+// Independently re-derived from the frozen contract for the lab's own read-only boundary;
+// never imports orchestrator runtime code. Structural classification only -- never
+// evaluates whether a declared value is true.
+const METADATA_LINE_RE = /^([A-Za-z][A-Za-z0-9 -]*): (.*)$/;
+const SECTION_HEADING_RE = /^## (.+)$/;
+export function parseSupplementalContextText(text) {
+    const lines = text.split(/\r\n|\n/);
+    const metadata = {};
+    const metadataOrder = [];
+    const duplicateMetadataKeys = [];
+    const emptyMetadataKeys = [];
+    let i = 0;
+    for (; i < lines.length; i++) {
+        const line = lines[i];
+        if (SECTION_HEADING_RE.test(line))
+            break;
+        const match = line.match(METADATA_LINE_RE);
+        if (!match)
+            continue;
+        const key = match[1];
+        const value = match[2].trim();
+        if (Object.prototype.hasOwnProperty.call(metadata, key)) {
+            duplicateMetadataKeys.push(key);
+            continue;
+        }
+        if (value.length === 0) {
+            emptyMetadataKeys.push(key);
+        }
+        metadata[key] = value;
+        metadataOrder.push(key);
+    }
+    const sections = {};
+    const sectionOrder = [];
+    const duplicateSectionHeadings = [];
+    let currentHeading = null;
+    let currentLines = [];
+    const flush = () => {
+        if (currentHeading === null)
+            return;
+        const content = currentLines.join("\n").trim();
+        if (Object.prototype.hasOwnProperty.call(sections, currentHeading)) {
+            duplicateSectionHeadings.push(currentHeading);
+        }
+        else {
+            sections[currentHeading] = content;
+            sectionOrder.push(currentHeading);
+        }
+    };
+    for (; i < lines.length; i++) {
+        const line = lines[i];
+        const headingMatch = line.match(SECTION_HEADING_RE);
+        if (headingMatch) {
+            flush();
+            currentHeading = headingMatch[1].trim();
+            currentLines = [];
+        }
+        else if (currentHeading !== null) {
+            currentLines.push(line);
+        }
+    }
+    flush();
+    return {
+        metadata,
+        metadataOrder,
+        sections,
+        sectionOrder,
+        duplicateMetadataKeys,
+        emptyMetadataKeys,
+        duplicateSectionHeadings
+    };
+}

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

@@ -0,0 +1,152 @@
+// Lab-owned structural mirror of the frozen my-dev-kit-orchestrator supplemental
+// repository-context document vocabulary (commit bc08a05d3b52a629e7e4504372af199c324c4ae4,
+// src/instructions/supplementalContextTypes.ts). The lab never imports orchestrator
+// runtime code; this file only restates the frozen vocabulary needed to validate and
+// preserve documents the orchestrator already writes.
+export const SUPPLEMENTAL_CONTEXT_PACKET_SCHEMA_SUPPORTED_MAJOR = 1;
+export const SUPPLEMENTAL_CONTEXT_RETRIEVAL_REPORT_SCHEMA_SUPPORTED_MAJOR = 1;
+export const ROLE_BY_DOCUMENT_KIND = {
+    "implementation-context-packet": "implementation",
+    "implementation-context-retrieval-report": "implementation",
+    "test-context-packet": "test-implementation",
+    "test-context-retrieval-report": "test-implementation"
+};
+export function isRetrievalReportKind(kind) {
+    return kind === "implementation-context-retrieval-report" || kind === "test-context-retrieval-report";
+}
+export function isTestKind(kind) {
+    return kind === "test-context-packet" || kind === "test-context-retrieval-report";
+}
+const COMMON_PACKET_METADATA = [
+    "Schema version",
+    "Document kind",
+    "Role",
+    "Status",
+    "Repository scope",
+    "Freshness",
+    "Adequacy",
+    "Required evidence truncated",
+    "Context capsule schema version",
+    "Retrieval audit schema version",
+    "Tool name",
+    "Tool version",
+    "Index identity"
+];
+const COMMON_REPORT_METADATA = [
+    "Schema version",
+    "Document kind",
+    "Role",
+    "Status",
+    "Repository scope",
+    "Request schema version",
+    "Context capsule schema version",
+    "Retrieval audit schema version",
+    "Tool name",
+    "Tool version",
+    "Index identity",
+    "Freshness",
+    "Adequacy",
+    "Required evidence truncated",
+    "Full-file fallback used",
+    "Determinism checked"
+];
+const TEST_ONLY_METADATA = ["Responsibility mappings truncated", "Critical responsibility mapping status"];
+export const REQUIRED_METADATA_BY_DOCUMENT_KIND = {
+    "implementation-context-packet": COMMON_PACKET_METADATA,
+    "implementation-context-retrieval-report": COMMON_REPORT_METADATA,
+    "test-context-packet": [...COMMON_PACKET_METADATA, ...TEST_ONLY_METADATA],
+    "test-context-retrieval-report": [...COMMON_REPORT_METADATA, ...TEST_ONLY_METADATA]
+};
+export const REQUIRED_SECTIONS_BY_DOCUMENT_KIND = {
+    "implementation-context-packet": [
+        "Focus",
+        "Selected owners",
+        "Dependencies",
+        "Contracts",
+        "Validators",
+        "Constants",
+        "Errors",
+        "Schemas",
+        "Callers and callees",
+        "Closest tests",
+        "Test infrastructure",
+        "Test commands",
+        "Unresolved items",
+        "Budget and truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Assumptions",
+        "Notes"
+    ],
+    "implementation-context-retrieval-report": [
+        "Retrieval request",
+        "Command record",
+        "Focus selection",
+        "Candidate and owner selection",
+        "Evidence groups",
+        "Unresolved evidence",
+        "Adequacy evaluation",
+        "Freshness classification",
+        "Budget",
+        "Truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Warnings",
+        "Determinism",
+        "Assumptions",
+        "Notes"
+    ],
+    "test-context-packet": [
+        "Changed surface",
+        "Production owners",
+        "Production contracts",
+        "Validators",
+        "Constants",
+        "Errors",
+        "Schemas",
+        "Closest tests",
+        "Test infrastructure",
+        "Test commands",
+        "Test responsibilities",
+        "Responsibility mappings",
+        "Reusable test helpers",
+        "Oracle evidence",
+        "Unresolved items",
+        "Budget and truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Assumptions",
+        "Notes"
+    ],
+    "test-context-retrieval-report": [
+        "Retrieval request",
+        "Command record",
+        "Changed-surface selection",
+        "Production-owner selection",
+        "Test-infrastructure discovery",
+        "Test-command discovery",
+        "Responsibility mapping",
+        "Criticality overlay",
+        "Adequacy evaluation",
+        "Freshness classification",
+        "Budget",
+        "Truncation",
+        "Full-file fallback",
+        "Provenance",
+        "Warnings",
+        "Determinism",
+        "Assumptions",
+        "Notes"
+    ]
+};
+export const VALID_REPOSITORY_SCOPES = ["single-repository", "source-target"];
+export const VALID_DECLARED_STATUSES = ["template", "populated"];
+export const VALID_FRESHNESS_VALUES = ["fresh", "stale", "unknown"];
+export const VALID_ADEQUACY_VALUES = [
+    "sufficient",
+    "sufficient-with-assumptions",
+    "insufficient",
+    "conflict",
+    "unknown"
+];
+export const VALID_TRUNCATION_VALUES = ["yes", "no", "unknown"];

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

@@ -1,5 +1,5 @@
 import { parseSupportedMajorOneSchemaVersion } from "./schemaVersion.js";
-import { ArtifactValidationError, arrayFieldPath, joinFieldPath, requiredArray, requiredField, requiredLiteral, requiredObject, requiredRecord, requiredScalarLike, requiredString, requiredStringArray } from "./runtimeValidation.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"];
@@ -12,10 +12,17 @@ function validateContextCapsuleTool(ctx, value, fieldPath) {
 }
 function validateRetrievalAuditRecordIndex(ctx, value, fieldPath) {
     const obj = requiredObject(ctx, value, fieldPath);
-    return {
+    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);