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

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

@@ -21,6 +21,9 @@ export function mapLegacyArtifactsToExperimentRun(args) {
         warnings,
         failures,
         legacyArtifacts: args.legacyArtifacts,
+        v043StageContextExecutions: args.v043StageContextExecutions,
+        v043StageContextEvaluations: args.v043StageContextEvaluations,
+        v043StageContextRunAssurance: args.v043StageContextRunAssurance,
         metadata: {
             pluginName: "Context Strategy Comparison",
             pluginSchemaVersion: "1.0.0",

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

@@ -0,0 +1,205 @@
+import { captureTargetSnapshot, compareTargetSnapshots } from "../../../evaluation/targetImmutability/index.js";
+import { calculateStageContextDeterminism } from "../../../evaluation/stageContextDeterminism/index.js";
+import { buildProducerReadinessBridgeInputFromCombinedPayload, evaluateProducerReadinessBridge, evaluateV043StageContextExecution } from "../../../evaluation/stageContextMetrics/index.js";
+import { executeV043StageContextStrategy } from "./executeV043StageContextStrategy.js";
+async function buildRunWithTargetImmutability(targetConfig, input) {
+    if (targetConfig === undefined) {
+        const execution = await executeV043StageContextStrategy(input);
+        return {
+            execution,
+            targetImmutability: {
+                availability: "unavailable",
+                comparison: null,
+                reason: "Target immutability configuration was not supplied for this strategy run."
+            }
+        };
+    }
+    const beforeResult = await captureTargetSnapshot(targetConfig);
+    const execution = await executeV043StageContextStrategy(input);
+    const afterResult = await captureTargetSnapshot(targetConfig);
+    if (!beforeResult.ok && !afterResult.ok) {
+        return {
+            execution,
+            targetImmutability: {
+                availability: "unavailable",
+                comparison: null,
+                reason: "Target immutability could not be evaluated because a target snapshot failed.",
+                beforeFailure: beforeResult,
+                afterFailure: afterResult
+            }
+        };
+    }
+    if (!beforeResult.ok) {
+        return {
+            execution,
+            targetImmutability: {
+                availability: "unavailable",
+                comparison: null,
+                reason: "Target immutability could not be evaluated because a target snapshot failed.",
+                beforeFailure: beforeResult
+            }
+        };
+    }
+    if (!afterResult.ok) {
+        return {
+            execution,
+            targetImmutability: {
+                availability: "unavailable",
+                comparison: null,
+                reason: "Target immutability could not be evaluated because a target snapshot failed.",
+                afterFailure: afterResult
+            }
+        };
+    }
+    const comparison = compareTargetSnapshots(beforeResult.snapshot, afterResult.snapshot);
+    return {
+        execution,
+        targetImmutability: { availability: "available", comparison, reason: null }
+    };
+}
+// v0.4.4 Batch 3: computed exactly once per run, immediately after execution, from the
+// already-loaded execution payload -- never rereads artifacts, never reruns the strategy.
+function buildProducerReadinessBridgeResult(execution) {
+    if (execution.status !== "completed" || execution.strategyId !== "combined-bounded-stage-context")
+        return null;
+    const payload = execution.payload;
+    const bridgeInput = buildProducerReadinessBridgeInputFromCombinedPayload(payload, execution.expectations);
+    return evaluateProducerReadinessBridge(bridgeInput);
+}
+function computeStatus(issues, config) {
+    if (issues.length > 0)
+        return "failed";
+    const anyCheckApplies = config.targetImmutability !== undefined || config.repeatCount > 1;
+    return anyCheckApplies ? "passed" : "not-applicable";
+}
+export async function runV043StageContextStrategyWithAssurance(input, config) {
+    const runRecords = [];
+    const determinismCandidates = [];
+    const issues = [];
+    let primaryExecution;
+    let primaryEvaluation;
+    let primaryProducerReadinessBridge = null;
+    try {
+        for (let runNumber = 1; runNumber <= config.repeatCount; runNumber += 1) {
+            const { execution, targetImmutability } = await buildRunWithTargetImmutability(config.targetImmutability, input);
+            const evaluation = evaluateV043StageContextExecution(execution, { targetImmutability });
+            const producerReadinessBridge = buildProducerReadinessBridgeResult(execution);
+            if (runNumber === 1) {
+                primaryExecution = execution;
+                primaryEvaluation = evaluation;
+                primaryProducerReadinessBridge = producerReadinessBridge;
+            }
+            runRecords.push({
+                runNumber,
+                executionStatus: execution.status,
+                evaluationStatus: evaluation.status,
+                targetImmutability,
+                producerReadinessBridge
+            });
+            determinismCandidates.push({
+                runNumber,
+                value: { execution, evaluation, targetImmutability, producerReadinessBridge }
+            });
+            if (execution.status !== "completed") {
+                issues.push({
+                    code: "EXECUTION_NOT_COMPLETED",
+                    runNumber,
+                    fieldPath: `runs[${runNumber}].execution.status`,
+                    message: "Strategy execution did not complete successfully."
+                });
+            }
+            if (evaluation.status !== "completed") {
+                issues.push({
+                    code: "EVALUATION_NOT_COMPLETED",
+                    runNumber,
+                    fieldPath: `runs[${runNumber}].evaluation.status`,
+                    message: "Stage-context evaluation did not complete successfully."
+                });
+            }
+            if (config.targetImmutability !== undefined && targetImmutability.availability === "unavailable") {
+                issues.push({
+                    code: "TARGET_SNAPSHOT_UNAVAILABLE",
+                    runNumber,
+                    fieldPath: `runs[${runNumber}].targetImmutability`,
+                    message: "Target immutability assurance is unavailable for this run."
+                });
+            }
+            if (targetImmutability.availability === "available" && targetImmutability.comparison.status === "mutated") {
+                for (const mutation of targetImmutability.comparison.mutations) {
+                    issues.push({
+                        code: "TARGET_MUTATION_DETECTED",
+                        runNumber,
+                        fieldPath: `runs[${runNumber}].targetImmutability.${mutation.fieldPath}`,
+                        message: `Target mutation detected at "${mutation.fieldPath}".`
+                    });
+                }
+            }
+        }
+        const determinism = calculateStageContextDeterminism(determinismCandidates);
+        if (config.repeatCount > 1 && determinism.availability === "unavailable") {
+            issues.push({
+                code: "DETERMINISM_UNAVAILABLE",
+                runNumber: null,
+                fieldPath: "determinism",
+                message: "Repeated-run determinism could not be evaluated."
+            });
+        }
+        if (determinism.availability === "available" && determinism.deterministic === false) {
+            for (const mismatchRunNumber of determinism.mismatchRunNumbers) {
+                issues.push({
+                    code: "NONDETERMINISTIC_RESULT",
+                    runNumber: mismatchRunNumber,
+                    fieldPath: `determinism.runs[${mismatchRunNumber}]`,
+                    message: `Run ${mismatchRunNumber} differs from the baseline run.`
+                });
+            }
+        }
+        return {
+            strategyId: input.strategyId,
+            status: computeStatus(issues, config),
+            repeatCount: config.repeatCount,
+            primaryExecution: primaryExecution,
+            primaryEvaluation: primaryEvaluation,
+            primaryProducerReadinessBridge,
+            runRecords,
+            determinism,
+            issues
+        };
+    }
+    catch {
+        const fallbackExecution = primaryExecution ?? { status: "failed", strategyId: null, input, issues: [] };
+        const fallbackEvaluation = primaryEvaluation ?? {
+            status: "failed",
+            strategyId: null,
+            executionStatus: "failed",
+            reason: "Unexpected v0.4.3 stage-context run-assurance failure."
+        };
+        const fallbackDeterminism = {
+            availability: "unavailable",
+            repeatCount: config.repeatCount,
+            deterministic: null,
+            baselineSha256: null,
+            runDigests: [],
+            mismatchRunNumbers: [],
+            reason: "Unexpected v0.4.3 stage-context run-assurance failure prevented determinism evaluation."
+        };
+        return {
+            strategyId: input.strategyId,
+            status: "failed",
+            repeatCount: config.repeatCount,
+            primaryExecution: fallbackExecution,
+            primaryEvaluation: fallbackEvaluation,
+            primaryProducerReadinessBridge,
+            runRecords,
+            determinism: fallbackDeterminism,
+            issues: [
+                {
+                    code: "UNEXPECTED_ASSURANCE_ERROR",
+                    runNumber: null,
+                    fieldPath: "assurance",
+                    message: "Unexpected v0.4.3 stage-context run-assurance failure."
+                }
+            ]
+        };
+    }
+}

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,13 @@
+export const EXISTING_CONTEXT_STRATEGY_IDS = ["raw-full-file", "my-dev-kit-guided"];
+export const V043_STAGE_CONTEXT_STRATEGY_IDS = [
+    "architecture-context-only",
+    "architecture-plus-implementation-refresh",
+    "architecture-plus-implementation-and-test-refresh",
+    "full-workflow-library",
+    "bounded-workflow-instruction-packet",
+    "combined-bounded-stage-context"
+];
+export const CONTEXT_STRATEGY_IDS_WITH_V043 = [
+    ...EXISTING_CONTEXT_STRATEGY_IDS,
+    ...V043_STAGE_CONTEXT_STRATEGY_IDS
+];

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

@@ -0,0 +1 @@
+export {};

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

@@ -0,0 +1,59 @@
+import { validateTargetImmutabilityConfig } from "../../../evaluation/targetImmutability/index.js";
+const ALLOWED_KEYS = ["repeatCount", "targetImmutability"];
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function validateV043RunAssuranceConfig(value) {
+    if (value === undefined) {
+        return { ok: true, config: { repeatCount: 1 } };
+    }
+    if (!isPlainObject(value)) {
+        return {
+            ok: false,
+            issues: [{ code: "NON_OBJECT_CONFIG", fieldPath: "", message: "v0.4.3 run-assurance config must be an object." }]
+        };
+    }
+    const root = value;
+    const issues = [];
+    for (const key of Object.keys(root)) {
+        if (!ALLOWED_KEYS.includes(key)) {
+            issues.push({ code: "UNKNOWN_CONFIG_FIELD", fieldPath: key, message: `"${key}" is not a recognized field.` });
+        }
+    }
+    let repeatCount = 1;
+    if (root.repeatCount !== undefined) {
+        const candidate = root.repeatCount;
+        if (typeof candidate !== "number" || !Number.isInteger(candidate) || candidate < 1 || candidate > 10) {
+            issues.push({
+                code: "INVALID_REPEAT_COUNT",
+                fieldPath: "repeatCount",
+                message: "repeatCount must be an integer from 1 through 10."
+            });
+        }
+        else {
+            repeatCount = candidate;
+        }
+    }
+    let targetImmutability;
+    if (root.targetImmutability !== undefined) {
+        const result = validateTargetImmutabilityConfig(root.targetImmutability);
+        if (!result.ok) {
+            issues.push({
+                code: "INVALID_TARGET_IMMUTABILITY_CONFIG",
+                fieldPath: "targetImmutability",
+                message: "targetImmutability configuration is invalid.",
+                details: result.issues
+            });
+        }
+        else {
+            targetImmutability = result.config;
+        }
+    }
+    if (issues.length > 0) {
+        return { ok: false, issues };
+    }
+    return {
+        ok: true,
+        config: targetImmutability !== undefined ? { repeatCount, targetImmutability } : { repeatCount }
+    };
+}

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

@@ -0,0 +1,266 @@
+import { V043_STAGE_CONTEXT_STRATEGY_IDS } from "./v043StrategyIds.js";
+const CONTEXT_ROLE_VALUES = ["architecture", "implementation", "test-implementation"];
+const COMBINED_ENTRY_ALLOWED_KEYS = ["role", "contextCapsulePath", "retrievalAuditRecordPath"];
+const STRATEGY_CONTRACTS = {
+    "architecture-context-only": {
+        fields: [
+            { name: "expectationsPath", kind: "required-path" },
+            { name: "architectureContextCapsulePath", kind: "required-path" },
+            { name: "architectureRetrievalAuditRecordPath", kind: "optional-path" }
+        ]
+    },
+    "architecture-plus-implementation-refresh": {
+        fields: [
+            { name: "expectationsPath", kind: "required-path" },
+            { name: "architectureContextCapsulePath", kind: "required-path" },
+            { name: "architectureRetrievalAuditRecordPath", kind: "optional-path" },
+            { name: "implementationContextCapsulePath", kind: "required-path" },
+            { name: "implementationRetrievalAuditRecordPath", kind: "optional-path" }
+        ]
+    },
+    "architecture-plus-implementation-and-test-refresh": {
+        fields: [
+            { name: "expectationsPath", kind: "required-path" },
+            { name: "architectureContextCapsulePath", kind: "required-path" },
+            { name: "architectureRetrievalAuditRecordPath", kind: "optional-path" },
+            { name: "implementationContextCapsulePath", kind: "required-path" },
+            { name: "implementationRetrievalAuditRecordPath", kind: "optional-path" },
+            { name: "testImplementationContextCapsulePath", kind: "required-path" },
+            { name: "testImplementationRetrievalAuditRecordPath", kind: "optional-path" }
+        ]
+    },
+    "full-workflow-library": {
+        fields: [
+            { name: "expectationsPath", kind: "required-path" },
+            { name: "fullWorkflowLibraryFixturePath", kind: "required-path" }
+        ]
+    },
+    "bounded-workflow-instruction-packet": {
+        fields: [
+            { name: "expectationsPath", kind: "required-path" },
+            { name: "workflowInstructionPacketPath", kind: "required-path" }
+        ]
+    },
+    "combined-bounded-stage-context": {
+        fields: [
+            { name: "expectationsPath", kind: "required-path" },
+            { name: "contextArtifacts", kind: "required-array" },
+            { name: "workflowInstructionPacketPath", kind: "required-path" },
+            { name: "implementationContextPacketPath", kind: "optional-path" },
+            { name: "implementationContextRetrievalReportPath", kind: "optional-path" },
+            { name: "testContextPacketPath", kind: "optional-path" },
+            { name: "testContextRetrievalReportPath", kind: "optional-path" },
+            { name: "readiness", kind: "optional-object" }
+        ]
+    }
+};
+function isPlainObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+export function validateV043StrategyInput(value) {
+    if (!isPlainObject(value)) {
+        return {
+            ok: false,
+            issues: [{ code: "NON_OBJECT_INPUT", fieldPath: "", message: "Strategy input must be an object." }]
+        };
+    }
+    const root = value;
+    const issues = [];
+    let strategyId;
+    if (root.strategyId === undefined) {
+        issues.push({ code: "MISSING_REQUIRED_FIELD", fieldPath: "strategyId", message: "strategyId is required." });
+    }
+    else if (typeof root.strategyId !== "string") {
+        issues.push({ code: "INVALID_FIELD_TYPE", fieldPath: "strategyId", message: "strategyId must be a string." });
+    }
+    else if (!V043_STAGE_CONTEXT_STRATEGY_IDS.includes(root.strategyId)) {
+        issues.push({
+            code: "INVALID_STRATEGY_ID",
+            fieldPath: "strategyId",
+            message: `strategyId "${root.strategyId}" is not a valid v0.4.3 stage-context strategy id.`
+        });
+    }
+    else {
+        strategyId = root.strategyId;
+    }
+    if (strategyId === undefined) {
+        return { ok: false, issues };
+    }
+    const contract = STRATEGY_CONTRACTS[strategyId];
+    const allowedKeys = ["strategyId", ...contract.fields.map((field) => field.name)];
+    for (const key of Object.keys(root)) {
+        if (!allowedKeys.includes(key)) {
+            issues.push({
+                code: "UNKNOWN_INPUT_FIELD",
+                fieldPath: key,
+                message: `"${key}" is not a recognized field for strategy "${strategyId}".`
+            });
+        }
+    }
+    for (const field of contract.fields) {
+        if (field.kind !== "optional-path" && field.kind !== "optional-object" && root[field.name] === undefined) {
+            issues.push({
+                code: "MISSING_REQUIRED_FIELD",
+                fieldPath: field.name,
+                message: `"${field.name}" is required for strategy "${strategyId}".`
+            });
+        }
+    }
+    for (const field of contract.fields) {
+        const fieldValue = root[field.name];
+        if (fieldValue === undefined)
+            continue;
+        if (field.kind === "required-array") {
+            if (!Array.isArray(fieldValue)) {
+                issues.push({
+                    code: "INVALID_FIELD_TYPE",
+                    fieldPath: field.name,
+                    message: `"${field.name}" must be an array.`
+                });
+            }
+        }
+        else if (field.kind === "optional-object") {
+            if (!isPlainObject(fieldValue)) {
+                issues.push({
+                    code: "INVALID_FIELD_TYPE",
+                    fieldPath: field.name,
+                    message: `"${field.name}" must be an object.`
+                });
+            }
+        }
+        else if (typeof fieldValue !== "string") {
+            issues.push({
+                code: "INVALID_FIELD_TYPE",
+                fieldPath: field.name,
+                message: `"${field.name}" must be a string.`
+            });
+        }
+    }
+    for (const field of contract.fields) {
+        if (field.kind === "required-array" || field.kind === "optional-object")
+            continue;
+        const fieldValue = root[field.name];
+        if (typeof fieldValue === "string" && fieldValue.length === 0) {
+            issues.push({ code: "EMPTY_PATH", fieldPath: field.name, message: `"${field.name}" must not be empty.` });
+        }
+    }
+    if (strategyId === "combined-bounded-stage-context" && Array.isArray(root.contextArtifacts)) {
+        const contextArtifacts = root.contextArtifacts;
+        if (contextArtifacts.length === 0) {
+            issues.push({
+                code: "EMPTY_CONTEXT_ARTIFACT_SET",
+                fieldPath: "contextArtifacts",
+                message: "contextArtifacts must contain at least one entry."
+            });
+        }
+        else if (contextArtifacts.length > 3) {
+            issues.push({
+                code: "TOO_MANY_CONTEXT_ARTIFACTS",
+                fieldPath: "contextArtifacts",
+                message: "contextArtifacts must contain at most three entries."
+            });
+        }
+        for (let index = 0; index < contextArtifacts.length; index += 1) {
+            const entry = contextArtifacts[index];
+            if (!isPlainObject(entry)) {
+                issues.push({
+                    code: "INVALID_FIELD_TYPE",
+                    fieldPath: `contextArtifacts[${index}]`,
+                    message: `contextArtifacts[${index}] must be an object.`
+                });
+                continue;
+            }
+            for (const key of Object.keys(entry)) {
+                if (!COMBINED_ENTRY_ALLOWED_KEYS.includes(key)) {
+                    issues.push({
+                        code: "UNKNOWN_INPUT_FIELD",
+                        fieldPath: `contextArtifacts[${index}].${key}`,
+                        message: `"${key}" is not a recognized field for a combined context artifact entry.`
+                    });
+                }
+            }
+        }
+        for (let index = 0; index < contextArtifacts.length; index += 1) {
+            const entry = contextArtifacts[index];
+            if (!isPlainObject(entry))
+                continue;
+            if (entry.role === undefined) {
+                issues.push({
+                    code: "MISSING_REQUIRED_FIELD",
+                    fieldPath: `contextArtifacts[${index}].role`,
+                    message: `contextArtifacts[${index}].role is required.`
+                });
+            }
+            if (entry.contextCapsulePath === undefined) {
+                issues.push({
+                    code: "MISSING_REQUIRED_FIELD",
+                    fieldPath: `contextArtifacts[${index}].contextCapsulePath`,
+                    message: `contextArtifacts[${index}].contextCapsulePath is required.`
+                });
+            }
+        }
+        for (let index = 0; index < contextArtifacts.length; index += 1) {
+            const entry = contextArtifacts[index];
+            if (!isPlainObject(entry))
+                continue;
+            if (entry.role !== undefined && (typeof entry.role !== "string" || !CONTEXT_ROLE_VALUES.includes(entry.role))) {
+                issues.push({
+                    code: "INVALID_CONTEXT_ROLE",
+                    fieldPath: `contextArtifacts[${index}].role`,
+                    message: `contextArtifacts[${index}].role "${entry.role}" is not a valid context role.`
+                });
+            }
+            if (entry.contextCapsulePath !== undefined && typeof entry.contextCapsulePath !== "string") {
+                issues.push({
+                    code: "INVALID_FIELD_TYPE",
+                    fieldPath: `contextArtifacts[${index}].contextCapsulePath`,
+                    message: `contextArtifacts[${index}].contextCapsulePath must be a string.`
+                });
+            }
+            if (entry.retrievalAuditRecordPath !== undefined && typeof entry.retrievalAuditRecordPath !== "string") {
+                issues.push({
+                    code: "INVALID_FIELD_TYPE",
+                    fieldPath: `contextArtifacts[${index}].retrievalAuditRecordPath`,
+                    message: `contextArtifacts[${index}].retrievalAuditRecordPath must be a string.`
+                });
+            }
+        }
+        for (let index = 0; index < contextArtifacts.length; index += 1) {
+            const entry = contextArtifacts[index];
+            if (!isPlainObject(entry))
+                continue;
+            if (typeof entry.contextCapsulePath === "string" && entry.contextCapsulePath.length === 0) {
+                issues.push({
+                    code: "EMPTY_PATH",
+                    fieldPath: `contextArtifacts[${index}].contextCapsulePath`,
+                    message: `contextArtifacts[${index}].contextCapsulePath must not be empty.`
+                });
+            }
+            if (typeof entry.retrievalAuditRecordPath === "string" && entry.retrievalAuditRecordPath.length === 0) {
+                issues.push({
+                    code: "EMPTY_PATH",
+                    fieldPath: `contextArtifacts[${index}].retrievalAuditRecordPath`,
+                    message: `contextArtifacts[${index}].retrievalAuditRecordPath must not be empty.`
+                });
+            }
+        }
+        const seenRoles = new Set();
+        for (let index = 0; index < contextArtifacts.length; index += 1) {
+            const entry = contextArtifacts[index];
+            if (!isPlainObject(entry) || typeof entry.role !== "string")
+                continue;
+            if (seenRoles.has(entry.role)) {
+                issues.push({
+                    code: "DUPLICATE_CONTEXT_ROLE",
+                    fieldPath: `contextArtifacts[${index}].role`,
+                    message: `contextArtifacts[${index}].role "${entry.role}" is duplicated.`
+                });
+            }
+            seenRoles.add(entry.role);
+        }
+    }
+    if (issues.length > 0) {
+        return { ok: false, issues };
+    }
+    return { ok: true, input: value };
+}