@dailephd/my-dev-kit-lab 0.6.2 → 0.7.0

package/dist/src/experiments/plugins/contextWindowScaling/config.js

@@ -0,0 +1,84 @@
+import { invalidExperimentConfig, isPlainObject, validExperimentConfig } from "../../config.js";
+import { isValidContextBudgetTokens, STANDARD_CONTEXT_BUDGETS } from "./contextBudget.js";
+const MAX_REPORTED_INVALID_BUDGETS = 5;
+export const defaultContextWindowScalingConfig = {
+    contextBudgets: [...STANDARD_CONTEXT_BUDGETS],
+    kitCommand: "npx @dailephd/my-dev-kit@latest",
+};
+export const contextWindowScalingConfigDefinition = {
+    fields: [
+        {
+            name: "contextBudgets",
+            type: "array",
+            description: "Estimated-context-token budgets (positive safe integers, no duplicates). Defaults to 8192, 16384, 32768, 65536.",
+            defaultValue: [...STANDARD_CONTEXT_BUDGETS],
+        },
+        { name: "kitCommand", type: "string", description: "my-dev-kit command used for my-dev-kit-guided retrieval." },
+    ],
+};
+/** Returns ascending budgets; invalid input is rejected, never repaired or deduplicated. */
+export function validateContextBudgets(value) {
+    if (!Array.isArray(value)) {
+        return { budgets: [], errors: ["contextBudgets must be an array of positive safe integers."] };
+    }
+    if (value.length === 0) {
+        return { budgets: [], errors: ["contextBudgets must not be empty."] };
+    }
+    const errors = [];
+    const invalid = value
+        .map((entry, index) => ({ entry, index }))
+        .filter(({ entry }) => !isValidContextBudgetTokens(entry));
+    for (const { entry, index } of invalid.slice(0, MAX_REPORTED_INVALID_BUDGETS)) {
+        errors.push(`contextBudgets[${index}] must be a positive safe integer (received ${describe(entry)}).`);
+    }
+    if (invalid.length > MAX_REPORTED_INVALID_BUDGETS) {
+        errors.push(`${invalid.length - MAX_REPORTED_INVALID_BUDGETS} additional invalid contextBudgets entries omitted.`);
+    }
+    if (errors.length > 0) {
+        return { budgets: [], errors };
+    }
+    const numbers = value;
+    const duplicates = [...new Set(numbers.filter((entry, index) => numbers.indexOf(entry) !== index))].sort((a, b) => a - b);
+    if (duplicates.length > 0) {
+        return {
+            budgets: [],
+            errors: [`contextBudgets contains duplicate value(s): ${duplicates.slice(0, MAX_REPORTED_INVALID_BUDGETS).join(", ")}.`],
+        };
+    }
+    return { budgets: [...numbers].sort((a, b) => a - b), errors: [] };
+}
+function describe(entry) {
+    if (typeof entry === "number") {
+        return String(entry);
+    }
+    if (typeof entry === "string") {
+        return JSON.stringify(entry.length > 20 ? `${entry.slice(0, 20)}...` : entry);
+    }
+    return typeof entry;
+}
+export function validateContextWindowScalingConfig(config) {
+    if (config !== undefined && !isPlainObject(config)) {
+        return invalidExperimentConfig(["context window scaling config must be an object."]);
+    }
+    const supported = Object.keys(defaultContextWindowScalingConfig);
+    const unsupported = Object.keys(config ?? {}).filter((key) => !supported.includes(key));
+    if (unsupported.length > 0) {
+        return invalidExperimentConfig([
+            `Unsupported context-window-scaling config field(s): ${unsupported.sort().join(", ")}.`,
+        ]);
+    }
+    const errors = [];
+    const kitCommand = config?.kitCommand ?? defaultContextWindowScalingConfig.kitCommand;
+    if (typeof kitCommand !== "string" || !kitCommand.trim()) {
+        errors.push("kitCommand must be a non-empty string.");
+    }
+    let contextBudgets = [...STANDARD_CONTEXT_BUDGETS];
+    if (config?.contextBudgets !== undefined) {
+        const validated = validateContextBudgets(config.contextBudgets);
+        errors.push(...validated.errors);
+        contextBudgets = validated.budgets;
+    }
+    return errors.length > 0
+        ? invalidExperimentConfig(errors)
+        : validExperimentConfig({ contextBudgets, kitCommand: kitCommand });
+}

package/dist/src/experiments/plugins/contextWindowScaling/contextBudget.js

@@ -0,0 +1,43 @@
+export const CONTEXT_BUDGET_8K = 8192;
+export const CONTEXT_BUDGET_16K = 16384;
+export const CONTEXT_BUDGET_32K = 32768;
+export const CONTEXT_BUDGET_64K = 65536;
+export const STANDARD_CONTEXT_BUDGETS = Object.freeze([
+    CONTEXT_BUDGET_8K,
+    CONTEXT_BUDGET_16K,
+    CONTEXT_BUDGET_32K,
+    CONTEXT_BUDGET_64K,
+]);
+export function isValidContextBudgetTokens(value) {
+    return typeof value === "number" && Number.isSafeInteger(value) && value > 0;
+}
+/** Exact boundary fits: estimatedTokens <= budget. */
+export function classifyContextFit(contextEstimatedTokens, contextBudgetTokens) {
+    assertMeasuredTokens(contextEstimatedTokens);
+    assertBudget(contextBudgetTokens);
+    return contextEstimatedTokens <= contextBudgetTokens ? "fits" : "context-too-large";
+}
+/** estimated / budget * 100. Not capped at 100 and not rounded. */
+export function calculateContextBudgetUtilizationPercent(contextEstimatedTokens, contextBudgetTokens) {
+    assertMeasuredTokens(contextEstimatedTokens);
+    assertBudget(contextBudgetTokens);
+    return (contextEstimatedTokens / contextBudgetTokens) * 100;
+}
+export function buildContextBudgetEvidence(contextEstimatedTokens, contextBudgetTokens) {
+    return {
+        contextBudgetTokens,
+        contextEstimatedTokens,
+        contextFitStatus: classifyContextFit(contextEstimatedTokens, contextBudgetTokens),
+        contextBudgetUtilizationPercent: calculateContextBudgetUtilizationPercent(contextEstimatedTokens, contextBudgetTokens),
+    };
+}
+function assertBudget(value) {
+    if (!isValidContextBudgetTokens(value)) {
+        throw new RangeError("Context budget must be a positive safe integer.");
+    }
+}
+function assertMeasuredTokens(value) {
+    if (typeof value !== "number" || !Number.isSafeInteger(value) || value < 0) {
+        throw new RangeError("Estimated context tokens must be a nonnegative safe integer.");
+    }
+}

package/dist/src/experiments/plugins/contextWindowScaling/evaluation.js

@@ -0,0 +1,36 @@
+import path from "node:path";
+import { resolveWithinRoot } from "../../../core/pathSafety.js";
+import { evaluateFakeSide } from "../warmIndexReuse/agentEvaluation.js";
+import { taskOutputSegment } from "../warmIndexReuse/selection.js";
+import { toCorrectnessEvidence } from "./successEvidence.js";
+/**
+ * Reuses the single existing fake-agent pipeline (prompt owner, fake agent, parseAgentAnswer,
+ * classifyAgentRunOutcome, scoreCorrectness) owned by warm-index agent evaluation. The pipeline
+ * derives its prompt from the case and never receives a budget, so the result is identical for
+ * every budget the treatment context fits.
+ */
+export const evaluateTreatmentWithFakeAgent = async (args) => {
+    const side = await evaluateFakeSide({
+        evaluationCase: args.evaluationCase,
+        caseId: args.evaluationCase.id,
+        // The shared pipeline's side ids map to prompt strategies; the guided treatment uses the
+        // my-dev-kit-guided strategy. The side id is internal and is not persisted as a variant.
+        variantId: args.treatment === "raw-full-file" ? "raw-full-file" : "warm-index-reuse",
+        projectProfiles: args.projectProfiles,
+        outDir: resolveWithinRoot(args.outputRoot, path.join("agents", taskOutputSegment(args.evaluationCase.id), args.treatment)),
+        cwd: args.cwd,
+        env: args.env,
+    });
+    return {
+        agentId: "fake-agent",
+        agentStatus: side.status,
+        correctness: toCorrectnessEvidence({
+            available: side.correctness.available,
+            score: side.correctness.score,
+            passed: side.correctness.passed,
+        }),
+        failureReasons: [...side.correctness.failureReasons],
+        warnings: [...side.warnings],
+        errors: [...side.errors],
+    };
+};

package/dist/src/experiments/plugins/contextWindowScaling/execution.js

@@ -0,0 +1,187 @@
+import path from "node:path";
+import { tokenCountMethod } from "../../../core/countTokens.js";
+import { runMyDevKitRetrieval } from "../../../evaluation/runMyDevKitRetrieval.js";
+import { runRawFullFileBaseline } from "../../../evaluation/runRawFullFileBaseline.js";
+import { taskOutputSegment } from "../warmIndexReuse/selection.js";
+import { evaluateTreatmentWithFakeAgent } from "./evaluation.js";
+import { CONTEXT_WINDOW_SCALING_TREATMENT_IDS } from "./metadata.js";
+import { computeRelevantFileEvidence } from "./relevantFiles.js";
+import { buildBudgetCell, UNAVAILABLE_CORRECTNESS } from "./successEvidence.js";
+export const defaultContextWindowScalingDependencies = {
+    constructRawContext: (evaluationCase) => runRawFullFileBaseline(evaluationCase),
+    constructGuidedContext: ({ evaluationCase, kitCommand, outputDir }) => runMyDevKitRetrieval({ evaluationCase, kitCommand, outputDir, requireKit: false }),
+    evaluateTreatment: evaluateTreatmentWithFakeAgent,
+};
+/**
+ * Per case: construct each treatment context once, then evaluate that one context against every
+ * budget. A deterministic evaluation runs at most once per treatment and is shared by the budgets
+ * the context fits. Nothing is truncated, retried, or rebuilt per budget.
+ */
+export async function executeContextWindowScalingCases(args) {
+    const deps = { ...defaultContextWindowScalingDependencies, ...args.dependencies };
+    const results = [];
+    for (const evaluationCase of args.cases) {
+        const treatments = [];
+        for (const variantId of CONTEXT_WINDOW_SCALING_TREATMENT_IDS) {
+            treatments.push(await executeTreatment({ ...args, evaluationCase, variantId, deps }));
+        }
+        results.push({
+            caseId: evaluationCase.id,
+            caseName: evaluationCase.title,
+            benchmarkProject: evaluationCase.benchmarkProject,
+            targetRoot: evaluationCase.targetRoot,
+            taskLocality: evaluationCase.taskLocality ?? null,
+            treatments,
+        });
+    }
+    return results;
+}
+async function executeTreatment(args) {
+    const { evaluationCase, variantId, deps } = args;
+    const constructed = await constructContext(args);
+    const tokens = constructed.context.estimatedTokens;
+    const expectedFiles = evaluationCase.answerKey?.expectedFiles ?? evaluationCase.expectedFiles;
+    const relevantFileEvidence = computeRelevantFileEvidence({
+        expectedFiles,
+        observedFiles: constructed.context.observedFiles,
+    });
+    let evaluation;
+    const anyFits = tokens !== null && args.contextBudgets.some((budget) => tokens <= budget);
+    if (tokens === null) {
+        evaluation = emptyEvaluation("unavailable", "Treatment context is unavailable.");
+    }
+    else if (!anyFits) {
+        evaluation = emptyEvaluation("not-evaluated-no-fitting-budget", "The context is too large for every selected budget.");
+    }
+    else {
+        evaluation = await evaluateOnce(args, deps);
+    }
+    const budgetCells = args.contextBudgets.map((contextBudgetTokens) => buildBudgetCell({
+        contextBudgetTokens,
+        contextEstimatedTokens: tokens,
+        shared: evaluation.status === "evaluated" || evaluation.status === "unavailable" ? evaluation.correctness : null,
+    }));
+    return {
+        variantId,
+        status: treatmentStatus(constructed, budgetCells.map((cell) => cell.contextFitStatus === "fits" && cell.evaluationStatus === "unavailable")),
+        context: constructed.context,
+        evaluation,
+        relevantFileEvidence,
+        budgetCells,
+        errors: constructed.error ? [constructed.error] : [],
+    };
+}
+async function evaluateOnce(args, deps) {
+    try {
+        const result = await deps.evaluateTreatment({
+            evaluationCase: args.evaluationCase,
+            treatment: args.variantId,
+            projectProfiles: args.projectProfiles,
+            outputRoot: args.outputRoot,
+            cwd: args.cwd,
+            env: args.env,
+        });
+        const available = result.correctness.availability === "available";
+        return {
+            status: available ? "evaluated" : "unavailable",
+            agentId: result.agentId,
+            agentStatus: result.agentStatus,
+            evaluationCount: 1,
+            correctness: result.correctness,
+            failureReasons: result.failureReasons,
+            warnings: [...result.warnings, ...result.errors],
+            reason: available ? null : `Deterministic evaluation was not scoreable (agent status ${result.agentStatus}).`,
+        };
+    }
+    catch (error) {
+        return {
+            ...emptyEvaluation("unavailable", error instanceof Error ? error.message : String(error)),
+            evaluationCount: 1,
+        };
+    }
+}
+function emptyEvaluation(status, reason) {
+    return {
+        status,
+        agentId: null,
+        agentStatus: null,
+        evaluationCount: 0,
+        correctness: { ...UNAVAILABLE_CORRECTNESS },
+        failureReasons: [],
+        warnings: [],
+        reason,
+    };
+}
+function treatmentStatus(constructed, fittingCellUnavailable) {
+    if (constructed.error)
+        return "failed";
+    if (constructed.skipped)
+        return "skipped";
+    return fittingCellUnavailable.some(Boolean) ? "partial" : "completed";
+}
+async function constructContext(args) {
+    const { evaluationCase, variantId, deps } = args;
+    try {
+        if (variantId === "raw-full-file") {
+            const raw = await deps.constructRawContext(evaluationCase);
+            return {
+                skipped: false,
+                error: null,
+                context: {
+                    status: "available",
+                    characterCount: raw.totalChars,
+                    estimatedTokens: raw.totalEstimatedTokens,
+                    tokenCountMethod: raw.tokenCountMethod,
+                    observedFiles: [...raw.filesIncluded],
+                    warnings: [],
+                    reason: null,
+                },
+            };
+        }
+        const guided = await deps.constructGuidedContext({
+            evaluationCase,
+            kitCommand: args.kitCommand,
+            outputDir: path.join(args.outputRoot, "guided", taskOutputSegment(evaluationCase.id)),
+        });
+        if (guided.skipped) {
+            return {
+                skipped: true,
+                error: null,
+                context: unavailableContext(guided.warnings, "my-dev-kit-guided retrieval was skipped and produced no context."),
+            };
+        }
+        return {
+            skipped: false,
+            error: null,
+            context: {
+                status: "available",
+                characterCount: guided.totalChars,
+                estimatedTokens: guided.totalEstimatedTokens,
+                tokenCountMethod: guided.tokenCountMethod,
+                observedFiles: [...guided.filesRead],
+                warnings: [...guided.warnings],
+                reason: null,
+            },
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            skipped: false,
+            error: { code: "context-construction-failed", message },
+            context: unavailableContext([], message),
+        };
+    }
+}
+function unavailableContext(warnings, reason) {
+    return {
+        status: "unavailable",
+        characterCount: null,
+        estimatedTokens: null,
+        tokenCountMethod: null,
+        observedFiles: null,
+        warnings: [...warnings],
+        reason,
+    };
+}
+export { tokenCountMethod as CONTEXT_WINDOW_SCALING_TOKEN_COUNT_METHOD };

package/dist/src/experiments/plugins/contextWindowScaling/executionArtifact.js

@@ -0,0 +1,15 @@
+export const CONTEXT_WINDOW_SCALING_EXECUTION_ARTIFACT_FILE = "context-window-scaling-execution.json";
+export const CONTEXT_WINDOW_SCALING_EXECUTION_SCHEMA_VERSION = "my-dev-kit-lab-context-window-scaling-execution-v1";
+export function buildContextWindowScalingExecutionArtifact(args) {
+    return {
+        schemaVersion: CONTEXT_WINDOW_SCALING_EXECUTION_SCHEMA_VERSION,
+        runId: args.runId,
+        pluginId: args.pluginId,
+        pluginSchemaVersion: args.pluginSchemaVersion,
+        startedAt: args.startedAt,
+        completedAt: args.completedAt,
+        estimator: { tokenCountMethod: args.tokenCountMethod },
+        contextBudgets: [...args.contextBudgets],
+        cases: structuredClone([...args.cases]),
+    };
+}

package/dist/src/experiments/plugins/contextWindowScaling/executionArtifactReader.js

@@ -0,0 +1,186 @@
+import { validateContextBudgets } from "./config.js";
+import { CONTEXT_WINDOW_SCALING_EXECUTION_SCHEMA_VERSION, } from "./executionArtifact.js";
+import { CONTEXT_WINDOW_SCALING_PLUGIN_ID, CONTEXT_WINDOW_SCALING_TREATMENT_IDS } from "./metadata.js";
+const MAX_REPORTED_PROBLEMS = 8;
+const RUN_STATUSES = ["completed", "partial", "failed", "skipped"];
+const AVAILABILITY = ["available", "unavailable"];
+const EVALUATION_STATUSES = ["evaluated", "not-evaluated-no-fitting-budget", "unavailable"];
+const RELEVANT_STATUSES = ["available", "unavailable", "not-applicable"];
+const FIT_STATUSES = ["fits", "context-too-large", "unavailable"];
+const CELL_EVALUATION_STATUSES = ["evaluated", "not-evaluated-context-too-large", "unavailable"];
+const SUCCESS_REASONS = ["correctness-pass", "correctness-fail", "context-too-large", "evaluation-unavailable", "context-unavailable"];
+const isObj = (v) => typeof v === "object" && v !== null && !Array.isArray(v);
+const isStr = (v) => typeof v === "string";
+const isStrOrNull = (v) => v === null || typeof v === "string";
+const isCount = (v) => typeof v === "number" && Number.isSafeInteger(v) && v >= 0;
+const isCountOrNull = (v) => v === null || isCount(v);
+const isNumOrNull = (v) => v === null || (typeof v === "number" && Number.isFinite(v));
+const isStrArray = (v) => Array.isArray(v) && v.every((item) => typeof item === "string");
+const isOneOf = (v, allowed) => typeof v === "string" && allowed.includes(v);
+/**
+ * Structural validator for the persisted V1 execution artifact. It checks only what aggregation and
+ * plotting need (closed enums, types, budget/cell agreement); it never repairs or coerces values.
+ * Throws one Error listing bounded problems; returns the input, typed, when valid.
+ */
+export function parseContextWindowScalingExecutionArtifact(value) {
+    if (!isObj(value)) {
+        throw new Error("Invalid context-window-scaling execution artifact: expected a JSON object.");
+    }
+    if (value.schemaVersion !== CONTEXT_WINDOW_SCALING_EXECUTION_SCHEMA_VERSION) {
+        throw new Error(`Invalid context-window-scaling execution artifact: unsupported schemaVersion ${JSON.stringify(value.schemaVersion)}; expected ${CONTEXT_WINDOW_SCALING_EXECUTION_SCHEMA_VERSION}.`);
+    }
+    const problems = [];
+    const fail = (message) => {
+        problems.push(message);
+    };
+    const checkCorrectness = (correctness, at) => {
+        if (!isObj(correctness) ||
+            !isOneOf(correctness.availability, AVAILABILITY) ||
+            !isNumOrNull(correctness.score) ||
+            !(correctness.pass === null || typeof correctness.pass === "boolean")) {
+            fail(`${at} is malformed.`);
+        }
+    };
+    for (const field of ["runId", "pluginSchemaVersion", "startedAt", "completedAt"]) {
+        if (!isStr(value[field]))
+            fail(`${field} must be a string.`);
+    }
+    if (value.pluginId !== CONTEXT_WINDOW_SCALING_PLUGIN_ID)
+        fail(`pluginId must be ${CONTEXT_WINDOW_SCALING_PLUGIN_ID}.`);
+    if (!isObj(value.estimator) || !isStr(value.estimator.tokenCountMethod))
+        fail("estimator.tokenCountMethod must be a string.");
+    let budgets = [];
+    const budgetCheck = validateContextBudgets(value.contextBudgets);
+    if (budgetCheck.errors.length > 0) {
+        fail(`contextBudgets: ${budgetCheck.errors.join(" ")}`);
+    }
+    else if (budgetCheck.budgets.some((budget, index) => budget !== value.contextBudgets[index])) {
+        fail("contextBudgets must be in ascending order.");
+    }
+    else {
+        budgets = budgetCheck.budgets;
+    }
+    const cases = value.cases;
+    if (!Array.isArray(cases) || cases.length === 0) {
+        fail("cases must be a non-empty array.");
+    }
+    else {
+        cases.forEach((caseEvidence, caseIndex) => {
+            const at = `cases[${caseIndex}]`;
+            if (!isObj(caseEvidence))
+                return fail(`${at} must be an object.`);
+            for (const field of ["caseId", "caseName", "benchmarkProject", "targetRoot"]) {
+                if (!isStr(caseEvidence[field]))
+                    fail(`${at}.${field} must be a string.`);
+            }
+            if (!isStrOrNull(caseEvidence.taskLocality))
+                fail(`${at}.taskLocality must be a string or null.`);
+            const treatments = caseEvidence.treatments;
+            if (!Array.isArray(treatments))
+                return fail(`${at}.treatments must be an array.`);
+            const ids = treatments.map((t) => (isObj(t) ? t.variantId : undefined));
+            if (ids.length !== CONTEXT_WINDOW_SCALING_TREATMENT_IDS.length ||
+                CONTEXT_WINDOW_SCALING_TREATMENT_IDS.some((id) => ids.filter((x) => x === id).length !== 1)) {
+                fail(`${at}.treatments must contain exactly ${CONTEXT_WINDOW_SCALING_TREATMENT_IDS.join(" and ")}.`);
+            }
+            treatments.forEach((treatment, treatmentIndex) => {
+                const tat = `${at}.treatments[${treatmentIndex}]`;
+                if (!isObj(treatment))
+                    return fail(`${tat} must be an object.`);
+                if (!isOneOf(treatment.status, RUN_STATUSES))
+                    fail(`${tat}.status is not a known status.`);
+                const context = treatment.context;
+                if (!isObj(context)) {
+                    fail(`${tat}.context must be an object.`);
+                }
+                else {
+                    if (!isOneOf(context.status, AVAILABILITY))
+                        fail(`${tat}.context.status is not a known status.`);
+                    if (!isCountOrNull(context.characterCount) || !isCountOrNull(context.estimatedTokens)) {
+                        fail(`${tat}.context counts must be nonnegative integers or null.`);
+                    }
+                    if (!isStrOrNull(context.tokenCountMethod) || !isStrOrNull(context.reason))
+                        fail(`${tat}.context strings must be strings or null.`);
+                    if (!(context.observedFiles === null || isStrArray(context.observedFiles)) || !isStrArray(context.warnings)) {
+                        fail(`${tat}.context file/warning lists are malformed.`);
+                    }
+                    if (context.status === "available" && context.estimatedTokens === null)
+                        fail(`${tat}.context is available without estimatedTokens.`);
+                }
+                const evaluation = treatment.evaluation;
+                if (!isObj(evaluation)) {
+                    fail(`${tat}.evaluation must be an object.`);
+                }
+                else {
+                    if (!isOneOf(evaluation.status, EVALUATION_STATUSES))
+                        fail(`${tat}.evaluation.status is not a known status.`);
+                    if (!(evaluation.agentId === null || evaluation.agentId === "fake-agent"))
+                        fail(`${tat}.evaluation.agentId must be fake-agent or null.`);
+                    if (!isStrOrNull(evaluation.agentStatus) || !isStrOrNull(evaluation.reason))
+                        fail(`${tat}.evaluation strings must be strings or null.`);
+                    if (!isCount(evaluation.evaluationCount))
+                        fail(`${tat}.evaluation.evaluationCount must be a nonnegative integer.`);
+                    if (!isStrArray(evaluation.failureReasons) || !isStrArray(evaluation.warnings))
+                        fail(`${tat}.evaluation lists must be string arrays.`);
+                    checkCorrectness(evaluation.correctness, `${tat}.evaluation.correctness`);
+                }
+                const relevant = treatment.relevantFileEvidence;
+                if (!isObj(relevant)) {
+                    fail(`${tat}.relevantFileEvidence must be an object.`);
+                }
+                else {
+                    if (!isOneOf(relevant.status, RELEVANT_STATUSES))
+                        fail(`${tat}.relevantFileEvidence.status is not a known status.`);
+                    if (!isStrArray(relevant.expectedRelevantFiles) || !isStrArray(relevant.omittedRelevantFiles)) {
+                        fail(`${tat}.relevantFileEvidence file lists must be string arrays.`);
+                    }
+                    if (!isCount(relevant.expectedRelevantFileCount))
+                        fail(`${tat}.relevantFileEvidence.expectedRelevantFileCount must be a nonnegative integer.`);
+                    if (!isCountOrNull(relevant.observedExpectedFileCount) || !isCountOrNull(relevant.omittedRelevantFileCount)) {
+                        fail(`${tat}.relevantFileEvidence counts must be nonnegative integers or null.`);
+                    }
+                    if (!isStrOrNull(relevant.reason))
+                        fail(`${tat}.relevantFileEvidence.reason must be a string or null.`);
+                }
+                const cells = treatment.budgetCells;
+                if (!Array.isArray(cells)) {
+                    fail(`${tat}.budgetCells must be an array.`);
+                }
+                else {
+                    const cellBudgets = cells.map((cell) => (isObj(cell) ? cell.contextBudgetTokens : undefined));
+                    if (budgets.length > 0 && (cells.length !== budgets.length || budgets.some((b) => cellBudgets.filter((x) => x === b).length !== 1))) {
+                        fail(`${tat}.budgetCells do not match contextBudgets.`);
+                    }
+                    cells.forEach((cell, cellIndex) => {
+                        const cat = `${tat}.budgetCells[${cellIndex}]`;
+                        if (!isObj(cell))
+                            return fail(`${cat} must be an object.`);
+                        if (!isOneOf(cell.contextFitStatus, FIT_STATUSES))
+                            fail(`${cat}.contextFitStatus is not a known status.`);
+                        if (!isNumOrNull(cell.contextBudgetUtilizationPercent))
+                            fail(`${cat}.contextBudgetUtilizationPercent must be a number or null.`);
+                        if (!isOneOf(cell.evaluationStatus, CELL_EVALUATION_STATUSES))
+                            fail(`${cat}.evaluationStatus is not a known status.`);
+                        checkCorrectness(cell.correctness, `${cat}.correctness`);
+                        const success = cell.successEvidence;
+                        if (!isObj(success) ||
+                            !isOneOf(success.status, AVAILABILITY) ||
+                            !(success.success === null || typeof success.success === "boolean") ||
+                            !isOneOf(success.reason, SUCCESS_REASONS)) {
+                            fail(`${cat}.successEvidence is malformed.`);
+                        }
+                    });
+                }
+                if (!Array.isArray(treatment.errors) || !treatment.errors.every((e) => isObj(e) && isStr(e.code) && isStr(e.message))) {
+                    fail(`${tat}.errors must be an array of { code, message }.`);
+                }
+            });
+        });
+    }
+    if (problems.length > 0) {
+        const shown = problems.slice(0, MAX_REPORTED_PROBLEMS);
+        const extra = problems.length - shown.length;
+        throw new Error(`Invalid context-window-scaling execution artifact: ${shown.join(" ")}${extra > 0 ? ` (${extra} more problem(s) omitted.)` : ""}`);
+    }
+    return value;
+}

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

@@ -0,0 +1,14 @@
+export * from "./config.js";
+export * from "./cliBudgets.js";
+export * from "./contextBudget.js";
+export * from "./evaluation.js";
+export * from "./execution.js";
+export * from "./executionArtifact.js";
+export * from "./executionArtifactReader.js";
+export * from "./metadata.js";
+export * from "./metrics.js";
+export * from "./plugin.js";
+export * from "./projectProfile.js";
+export * from "./relevantFiles.js";
+export * from "./successEvidence.js";
+export * from "./types.js";

package/dist/src/experiments/plugins/contextWindowScaling/metadata.js

@@ -0,0 +1,12 @@
+export const CONTEXT_WINDOW_SCALING_PLUGIN_ID = "context-window-scaling";
+/** Stable strategy IDs shared with existing plugins; budget is never part of variant identity. */
+export const CONTEXT_WINDOW_SCALING_TREATMENT_IDS = ["raw-full-file", "my-dev-kit-guided"];
+export const contextWindowScalingMetadata = {
+    id: CONTEXT_WINDOW_SCALING_PLUGIN_ID,
+    name: "Context Window Scaling",
+    description: "Measure raw-full-file and my-dev-kit-guided strategies under increasing deterministic estimated-context-token budgets.",
+    schemaVersion: "1.0.0",
+    status: "experimental",
+    supportedTargets: ["self"],
+    supportedOutputs: ["json", "text", "html", "plot"],
+};