@dailephd/my-dev-kit-lab 0.7.1 → 0.7.2

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

@@ -0,0 +1,128 @@
+import path from "node:path";
+import { redactPrivatePaths } from "./localSubjectErrors.js";
+/** Value used wherever a durable external-local artifact would otherwise show a machine-local path. */
+export const EXTERNAL_LOCAL_REDACTED_VALUE = "[redacted]";
+const REDACTED_FILE_TEXT = "<redacted file>";
+/** One opaque placeholder per file: counts stay exact and an empty list still means "no files". */
+export function redactedFileList(count) {
+    return Array.from({ length: count }, (_, index) => `<redacted file ${index + 1}>`);
+}
+/** Replaces known repository-relative paths (longest first) and private roots inside free text. */
+export function redactKnownPaths(text, knownFiles, privateRoots = []) {
+    let redacted = redactPrivatePaths(text, privateRoots);
+    for (const file of [...knownFiles].sort((left, right) => right.length - left.length)) {
+        if (file.length === 0)
+            continue;
+        // Native tool errors on Windows may spell a repository-relative path with backslashes.
+        for (const variant of new Set([file, file.replace(/\//g, "\\")]))
+            redacted = redacted.split(variant).join(REDACTED_FILE_TEXT);
+    }
+    return redacted;
+}
+function redactStrings(value, redact) {
+    if (typeof value === "string")
+        return redact(value);
+    if (Array.isArray(value))
+        return value.map((entry) => redactStrings(entry, redact));
+    if (value && typeof value === "object") {
+        return Object.fromEntries(Object.entries(value).map(([key, nested]) => [key, redactStrings(nested, redact)]));
+    }
+    return value;
+}
+/**
+ * Projects execution evidence for durable persistence of an external-local run. File identity lists become
+ * placeholder lists of the same length (with an explicit per-treatment flag) and every free-text field has known
+ * repository paths and private roots replaced. Scientific numbers, statuses and identifiers are untouched.
+ */
+export function projectEvidenceForExternalLocalPersistence(evidence, privacy) {
+    const redact = (text) => redactKnownPaths(text, privacy.knownFiles, privacy.privateRoots);
+    return evidence.map((caseEvidence) => {
+        const cloned = structuredClone(caseEvidence);
+        return {
+            ...redactStrings(cloned, redact),
+            treatments: cloned.treatments.map((treatment) => {
+                const safe = redactStrings(treatment, redact);
+                return {
+                    ...safe,
+                    context: {
+                        ...safe.context,
+                        observedFiles: treatment.context.observedFiles === null ? null : redactedFileList(treatment.context.observedFiles.length),
+                    },
+                    relevantFileEvidence: {
+                        ...safe.relevantFileEvidence,
+                        expectedRelevantFiles: redactedFileList(treatment.relevantFileEvidence.expectedRelevantFiles.length),
+                        omittedRelevantFiles: redactedFileList(treatment.relevantFileEvidence.omittedRelevantFiles.length),
+                    },
+                    fileIdentityRedaction: "redacted",
+                };
+            }),
+        };
+    });
+}
+/** Durable target identity for an external-local run: logical identity and Git identity, no filesystem facts. */
+export function projectExternalLocalTarget(manifest) {
+    return {
+        kind: "external-local",
+        targetRoot: manifest.logicalTargetRoot,
+        toolRoot: EXTERNAL_LOCAL_REDACTED_VALUE,
+        packageName: null,
+        packageVersion: null,
+        hasPackageJson: false,
+        hasLockfile: false,
+        branch: manifest.repository.branch,
+        commit: manifest.repository.commit,
+        hasGit: true,
+        isSelf: false,
+        privacyProjection: "external-local-redacted",
+    };
+}
+/** Replaces target and machine-local metadata of a run before any report is serialized. */
+export function projectRunForExternalLocalPersistence(run, target) {
+    const metadata = { ...(run.metadata ?? {}) };
+    if ("outputRoot" in metadata)
+        metadata.outputRoot = EXTERNAL_LOCAL_REDACTED_VALUE;
+    if (typeof metadata.executionArtifactPath === "string")
+        metadata.executionArtifactPath = path.basename(metadata.executionArtifactPath);
+    return { ...run, target, metadata: metadata };
+}
+const GENERIC_ISSUE_TEXT = {
+    WORK_ROOT_INSIDE_TARGET: "the output directory must be outside the local subject repository",
+    BEFORE_SNAPSHOT_FAILED: "the target snapshot before execution could not be captured",
+    AFTER_SNAPSHOT_FAILED: "the target snapshot after execution could not be captured",
+    SCRATCH_CLEANUP_FAILED: "the private scratch could not be removed",
+    GUIDED_EXCLUSION_LIMIT: "the guided-index exclusions exceeded the safe limit",
+    GUIDED_EXCLUSION_UNREPRESENTABLE: "the guided-index exclusions could not be expressed exactly",
+};
+/**
+ * Safe, persistable description of a local-subject execution failure: issue codes, case and treatment identifiers,
+ * error codes and mutation kinds only. Repository file names, mutation identifiers and the full comparison are
+ * never included.
+ */
+export function describeLocalSubjectFailureForPersistence(error) {
+    const parts = [];
+    const seen = new Set();
+    for (const issue of error.issues) {
+        if (seen.has(issue.code))
+            continue;
+        seen.add(issue.code);
+        if (issue.code === "EXECUTION_FAILED") {
+            const details = [];
+            for (const caseEvidence of error.caseEvidence ?? []) {
+                for (const treatment of caseEvidence.treatments) {
+                    if (treatment.status === "failed" || treatment.errors.length > 0) {
+                        details.push(`case ${caseEvidence.caseId} treatment ${treatment.variantId}: ${treatment.errors.map((entry) => entry.code).join(", ") || "failed"}`);
+                    }
+                }
+            }
+            parts.push(details.length > 0 ? `execution failed (${details.join("; ")})` : "execution failed before completing (details withheld)");
+        }
+        else if (issue.code === "TARGET_MUTATED") {
+            const kinds = [...new Set((error.immutability?.mutations ?? []).map((mutation) => mutation.kind))].sort();
+            parts.push(`the target changed during execution${kinds.length > 0 ? ` (${kinds.join(", ")})` : ""}; it was not restored`);
+        }
+        else {
+            parts.push(GENERIC_ISSUE_TEXT[issue.code] ?? `issue ${issue.code}`);
+        }
+    }
+    return `Local subject execution failed (${error.code}): ${parts.join("; ")}.`;
+}

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

@@ -0,0 +1,85 @@
+import { realpath as nativeRealpath } from "node:fs";
+import { lstat, mkdir, mkdtemp, rm } from "node:fs/promises";
+import path from "node:path";
+import { promisify } from "node:util";
+import { relativeWithinRoot } from "../../../core/pathSafety.js";
+import { LocalSubjectExecutionError } from "./localSubjectErrors.js";
+const realpath = promisify(nativeRealpath.native);
+export const defaultPrivateScratchIo = {
+    removeDirectory: (directory) => rm(directory, { recursive: true, force: true }),
+};
+/** Physical path of a path that may not exist yet: realpath of the deepest existing ancestor plus the remainder. */
+async function resolvePhysicalPath(candidate) {
+    const resolved = path.resolve(candidate);
+    const remainder = [];
+    let current = resolved;
+    for (;;) {
+        try {
+            const physical = await realpath(current);
+            return remainder.length === 0 ? physical : path.join(physical, ...remainder.reverse());
+        }
+        catch (error) {
+            const code = error.code;
+            const parent = path.dirname(current);
+            if ((code !== "ENOENT" && code !== "ENOTDIR") || parent === current)
+                return resolved;
+            remainder.push(path.basename(current));
+            current = parent;
+        }
+    }
+}
+function isSameOrInside(root, candidate) {
+    try {
+        relativeWithinRoot(root, candidate);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/** True when both paths resolve to the same physical directory (follows links; case-insensitive on Windows). */
+export async function isSamePhysicalDirectory(left, right) {
+    const [physicalLeft, physicalRight] = await Promise.all([resolvePhysicalPath(left), resolvePhysicalPath(right)]);
+    return path.relative(physicalLeft, physicalRight) === "";
+}
+/** Rejects a Lab-owned work root that equals or lies inside the target. Performs no writes. */
+export async function assertWorkRootOutsideTarget(workRoot, targetRoot) {
+    const physicalTarget = await resolvePhysicalPath(targetRoot);
+    const physicalWorkRoot = await resolvePhysicalPath(workRoot);
+    if (isSameOrInside(physicalTarget, physicalWorkRoot)) {
+        throw new LocalSubjectExecutionError([
+            { code: "WORK_ROOT_INSIDE_TARGET", message: "the Lab work root must be outside the local subject repository." },
+        ]);
+    }
+}
+/** Creates a short run-owned private scratch directory under the work root and re-verifies it is outside the target. */
+export async function createPrivateScratch(workRoot, targetRoot) {
+    await mkdir(path.resolve(workRoot), { recursive: true });
+    const scratchPath = await mkdtemp(path.join(await realpath(path.resolve(workRoot)), "s-"));
+    if (isSameOrInside(await resolvePhysicalPath(targetRoot), await resolvePhysicalPath(scratchPath))) {
+        await rm(scratchPath, { recursive: true, force: true });
+        throw new LocalSubjectExecutionError([
+            { code: "WORK_ROOT_INSIDE_TARGET", message: "the private scratch directory resolved inside the local subject repository." },
+        ]);
+    }
+    return { path: scratchPath };
+}
+/**
+ * Removes the scratch and verifies it is gone. Returns a failure description instead of throwing so the caller can
+ * keep the primary error; never retries and never sleeps.
+ */
+export async function removePrivateScratch(scratch, io = defaultPrivateScratchIo) {
+    try {
+        await io.removeDirectory(scratch.path);
+    }
+    catch (error) {
+        return `private scratch could not be removed: ${error instanceof Error ? error.message : String(error)}`;
+    }
+    try {
+        await lstat(scratch.path);
+        return "private scratch still exists after removal.";
+    }
+    catch (error) {
+        return error.code === "ENOENT" ? null : "private scratch state could not be verified after removal.";
+    }
+}

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

@@ -4,9 +4,9 @@ export const CONTEXT_WINDOW_SCALING_TREATMENT_IDS = ["raw-full-file", "my-dev-ki
 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, over the bundled fixed scaling corpus or caller-supplied deterministic synthetic repositories (--synthetic-config).",
+    description: "Measure raw-full-file and my-dev-kit-guided strategies under increasing deterministic estimated-context-token budgets, over the bundled fixed scaling corpus, caller-supplied deterministic synthetic repositories (--synthetic-config), or an explicitly selected local Git repository (--target with --local-subject-config). Operational context-fit measurement only; it does not measure retrieval precision, recall, or ranking quality.",
     schemaVersion: "1.0.0",
     status: "experimental",
-    supportedTargets: ["self"],
+    supportedTargets: ["self", "external-local"],
     supportedOutputs: ["json", "text", "html", "plot"],
 };

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

@@ -2,6 +2,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { tokenCountMethod } from "../../../core/countTokens.js";
 import { resolveWithinRoot } from "../../../core/pathSafety.js";
+import { serializeLocalRepositorySubjectManifest, } from "../../../evaluation/localRepositorySubject/index.js";
 import { summarizeExperimentRun } from "../../results.js";
 import { aggregateStatus } from "../warmIndexReuse/execution.js";
 import { contextWindowScalingConfigDefinition, defaultContextWindowScalingConfig, validateContextWindowScalingConfig, } from "./config.js";
@@ -9,7 +10,13 @@ import { executeContextWindowScalingCases, } from "./execution.js";
 import { buildContextWindowScalingExecutionArtifact, CONTEXT_WINDOW_SCALING_EXECUTION_ARTIFACT_FILE, } from "./executionArtifact.js";
 import { CONTEXT_WINDOW_SCALING_TREATMENT_IDS, contextWindowScalingMetadata } from "./metadata.js";
 import { aggregateContextWindowScaling, toAggregateExperimentMetrics, toOutcomeBudgetMetrics, } from "./metrics.js";
+import { LocalSubjectExecutionError } from "./localSubjectErrors.js";
+import { executeLocalRepositorySubjectContextWindowScaling } from "./localSubjectExecution.js";
+import { describeLocalSubjectFailureForPersistence, projectEvidenceForExternalLocalPersistence, projectExternalLocalTarget, redactKnownPaths, } from "./localSubjectPrivacy.js";
+import { isSamePhysicalDirectory } from "./localSubjectScratch.js";
 import { resolveScalingProjectProfiles } from "./projectProfile.js";
+/** Privacy-safe Batch 1 manifest persisted beside the execution artifact for external-local runs. */
+export const LOCAL_REPOSITORY_SUBJECT_MANIFEST_FILE = "local-repository-subject-manifest.json";
 const VARIANTS = [
     {
         id: "raw-full-file",
@@ -31,6 +38,14 @@ export const contextWindowScalingPlugin = {
     validateConfig: validateContextWindowScalingConfig,
     async run(context) {
         const startedAt = context.startedAt.toISOString();
+        const localSubject = readLocalSubjectInput(context.inputs);
+        if (localSubject)
+            return runLocalSubject(context, localSubject, startedAt);
+        if (context.target.kind === "external-local") {
+            // Never fall back to the legacy raw/guided path against an external repository: it is neither
+            // ignore-aware nor symlink-aware and writes artifacts it must not.
+            throw new Error("External-local context-window-scaling targets require a loaded local repository subject (--local-subject-config).");
+        }
         const cases = readCasesInput(context.inputs);
         const projectProfiles = resolveScalingProjectProfiles(cases, readProjectProfilesInput(context.inputs));
         const outDir = context.outputRoot ?? path.resolve(context.toolRoot, "lab-output", "context-window-scaling");
@@ -72,6 +87,84 @@ export const contextWindowScalingPlugin = {
         return result.summary ?? summarizeExperimentRun(result);
     },
 };
+function readLocalSubjectInput(inputs) {
+    const value = inputs?.localSubject;
+    return value && typeof value === "object" ? value : undefined;
+}
+/**
+ * External-local path: the Batch 2 safe seam owns execution, immutability and scratch cleanup; this function only
+ * projects the privacy-lean result for persistence and feeds the same artifact and run builders as the legacy path.
+ */
+async function runLocalSubject(context, subject, startedAt) {
+    if (context.target.isSelf || context.target.kind !== "external-local") {
+        throw new Error("Local-repository subject mode requires an external-local target.");
+    }
+    if (!(await isSamePhysicalDirectory(context.target.targetRoot, subject.repositoryRoot))) {
+        throw new Error("The selected --target is not the repository the local subject was loaded from.");
+    }
+    const outDir = context.outputRoot;
+    if (!outDir)
+        throw new Error("Local-repository subject mode requires an experiment output directory.");
+    const knownFiles = [
+        ...subject.eligibleFiles,
+        ...subject.runtimeSafetyExclusions.gitIgnoredFiles,
+        ...subject.runtimeSafetyExclusions.oversizedFiles,
+    ];
+    const privateRoots = [subject.repositoryRoot, context.target.targetRoot, outDir, context.toolRoot];
+    let localResult;
+    try {
+        localResult = await executeLocalRepositorySubjectContextWindowScaling({
+            subject,
+            contextBudgets: context.config.contextBudgets,
+            kitCommand: context.config.kitCommand,
+            workRoot: outDir,
+            env: readEnvInput(context.inputs),
+            dependencies: readDependenciesInput(context.inputs),
+        });
+    }
+    catch (error) {
+        if (error instanceof LocalSubjectExecutionError)
+            throw new Error(describeLocalSubjectFailureForPersistence(error));
+        throw new Error(redactKnownPaths(error instanceof Error ? error.message : String(error), knownFiles, privateRoots));
+    }
+    const startedAtIso = startedAt;
+    const evidence = projectEvidenceForExternalLocalPersistence(localResult.caseEvidence, { knownFiles, privateRoots });
+    await mkdir(outDir, { recursive: true });
+    const completedAt = new Date().toISOString();
+    const artifact = buildContextWindowScalingExecutionArtifact({
+        runId: context.runId,
+        pluginId: contextWindowScalingMetadata.id,
+        pluginSchemaVersion: contextWindowScalingMetadata.schemaVersion,
+        startedAt: startedAtIso,
+        completedAt,
+        tokenCountMethod,
+        contextBudgets: context.config.contextBudgets,
+        cases: evidence,
+    });
+    const artifactPath = resolveWithinRoot(outDir, CONTEXT_WINDOW_SCALING_EXECUTION_ARTIFACT_FILE);
+    await writeFile(artifactPath, `${JSON.stringify(artifact, null, 2)}
+`, "utf8");
+    const manifestPath = resolveWithinRoot(outDir, LOCAL_REPOSITORY_SUBJECT_MANIFEST_FILE);
+    await writeFile(manifestPath, serializeLocalRepositorySubjectManifest(subject.manifest), "utf8");
+    const run = mapExecutionToRun({
+        runId: context.runId,
+        startedAt: startedAtIso,
+        completedAt,
+        target: projectExternalLocalTarget(subject.manifest),
+        contextBudgets: context.config.contextBudgets,
+        executionEvidence: evidence,
+        artifactPath,
+    });
+    run.artifacts.push({
+        id: "local-repository-subject-manifest",
+        label: "Privacy-safe local repository subject manifest",
+        path: manifestPath,
+        kind: "artifact",
+        mimeType: "application/json",
+        description: "Subject identity, Git commit, safety policy and aggregate inventory counts; no paths, source text or file lists.",
+    });
+    return run;
+}
 export function mapExecutionToRun(args) {
     const cases = args.executionEvidence.map((caseEvidence) => ({
         id: caseEvidence.caseId,

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

@@ -1,12 +1,7 @@
 import path from "node:path";
 import { calculateProjectComplexityScore, computeProjectComplexityMetrics, PROJECT_COMPLEXITY_FORMULA, } from "../../../evaluation/projectComplexity.js";
 import { buildProjectFileTree } from "../../../evaluation/projectFileTree.js";
-/**
- * The fixed scaling project has no entry in the shared benchmark-project-profiles contract. The
- * existing prompt owner requires a profile per case, so a missing one is derived in memory from
- * the existing file-tree and complexity owners. Supplied profiles always win; nothing is written.
- */
-export function resolveScalingProjectProfiles(cases, supplied) {
+export function resolveScalingProjectProfiles(cases, supplied, options = {}) {
     const profiles = [...supplied];
     const known = new Set(profiles.map((profile) => profile.projectId));
     for (const evaluationCase of cases) {
@@ -14,13 +9,13 @@ export function resolveScalingProjectProfiles(cases, supplied) {
         if (known.has(profileId))
             continue;
         known.add(profileId);
-        profiles.push(deriveProfile(profileId, evaluationCase, cases));
+        profiles.push(deriveProfile(profileId, evaluationCase, cases, options));
     }
     return profiles;
 }
-function deriveProfile(profileId, evaluationCase, cases) {
+function deriveProfile(profileId, evaluationCase, cases, options) {
     const siblings = cases.filter((candidate) => (candidate.projectProfileRef ?? candidate.benchmarkProject) === profileId);
-    const fileTree = buildProjectFileTree(evaluationCase.absoluteTargetRoot);
+    const fileTree = buildProjectFileTree(evaluationCase.absoluteTargetRoot, options.eligibleFiles === undefined ? {} : { allowedRelativeFiles: options.eligibleFiles });
     const average = (values) => (values.length === 0 ? 0 : values.reduce((a, b) => a + b, 0) / values.length);
     const complexityMetrics = computeProjectComplexityMetrics(evaluationCase.absoluteTargetRoot, fileTree, {
         taskCount: siblings.length,

package/dist/src/report/experiments/renderPluginExperimentReportHtml.js

@@ -3,6 +3,7 @@ import { renderWarmIndexReuseHtml } from "./renderWarmIndexReuseHtml.js";
 import { renderIncrementalChangeStalenessHtml } from "./renderIncrementalChangeStalenessHtml.js";
 import { renderContextWindowScalingHtml } from "./renderContextWindowScalingHtml.js";
 export function renderPluginExperimentReportHtml(report) {
+    const redactedTarget = report.target.privacyProjection === "external-local-redacted";
     return `<!DOCTYPE html>
 <html lang="en">
 <head>
@@ -49,10 +50,10 @@ export function renderPluginExperimentReportHtml(report) {
         ["Mode", report.target.mode],
         ["Tool root", report.target.toolRoot],
         ["Target root", report.target.targetRoot],
-        ["Target package", report.target.packageName ? `${report.target.packageName}@${report.target.packageVersion ?? "unknown"}` : "unavailable"],
+        ["Target package", redactedTarget ? "redacted" : report.target.packageName ? `${report.target.packageName}@${report.target.packageVersion ?? "unknown"}` : "unavailable"],
         ["Target branch/commit", report.target.hasGit ? `${report.target.branch ?? "unknown"} / ${report.target.commit ?? "unknown"}` : "unavailable"],
-        ["Has package.json", String(report.target.hasPackageJson)],
-        ["Has lockfile", String(report.target.hasLockfile)],
+        ["Has package.json", redactedTarget ? "redacted" : String(report.target.hasPackageJson)],
+        ["Has lockfile", redactedTarget ? "redacted" : String(report.target.hasLockfile)],
         ["Output root", report.metadata.outputRoot ?? "unavailable"],
     ])}
   </section>

package/dist/src/report/experiments/writePluginExperimentReports.js

@@ -17,13 +17,19 @@ export async function writePluginExperimentReports(args) {
         textPath: resolveWithinRoot(outDir, "report.txt"),
     };
     await mkdir(outputPaths.outDir, { recursive: true });
-    const report = buildPluginExperimentReport({
+    const builtReport = buildPluginExperimentReport({
         run: args.run,
         plugin: args.plugin,
         outputRoot: outputPaths.outDir,
         generatedAt: args.generatedAt,
     });
-    await writeFile(outputPaths.jsonPath, `${JSON.stringify({ report, outputPaths }, null, 2)}\n`, "utf8");
+    const report = args.redactOutputRoot
+        ? { ...builtReport, metadata: { ...builtReport.metadata, outputRoot: "[redacted]" } }
+        : builtReport;
+    const serializedPaths = args.redactOutputRoot
+        ? { outDir: "[redacted]", jsonPath: "report.json", htmlPath: "report.html", textPath: "report.txt" }
+        : outputPaths;
+    await writeFile(outputPaths.jsonPath, `${JSON.stringify({ report, outputPaths: serializedPaths }, null, 2)}\n`, "utf8");
     await writeFile(outputPaths.htmlPath, renderPluginExperimentReportHtml(report), "utf8");
     await writeFile(outputPaths.textPath, renderPluginExperimentReportText(report), "utf8");
     return { report, outputPaths };

package/docs/METRICS.md

@@ -622,6 +622,8 @@ The report artifact schema is `my-dev-kit-lab-context-window-scaling-report-v1`.
 
 **Synthetic-repository runs (v0.7.1).** The synthetic input introduces no new scientific metric: fit, utilization, correctness, success, and omitted-relevant-file semantics, the execution artifact schema, the report schema, and the plot set are identical to the bundled-corpus run. Each generated repository's `synthetic-repository-manifest.json` records generation evidence (per-file byte length, character count, SHA-256, generated-content estimated tokens, aggregate totals, and `repositoryContentIdentity`); these are reproducibility measurements, not context-window outcome metrics. The raw-full-file treatment context is measured by the existing baseline, which adds file headers and separators, so its estimated tokens differ from the manifest's generated-content estimate. Retrieval precision/recall remains v0.8.0 scope.
 
+**Local-repository runs (v0.7.2).** Running over an explicitly selected local Git repository introduces no new scientific metric: fit, utilization, correctness, success, and omitted-relevant-file semantics, the execution artifact and report schemas, and the plot set are the same. In this mode file identity lists are replaced by numbered placeholders (`<redacted file N>`) with the same length as the real list, and each treatment carries `fileIdentityRedaction: "redacted"`; a placeholder is a withheld identity, not an empty result, and an empty list or `null` keeps its usual meaning. Operational compatibility with a repository, the 1 MiB file-size limit, and the Git-ignore exclusions are safety policy, not quality measures: they do not imply retrieval precision, recall, ranking quality, or a retrieval winner.
+
 There is no composite score, winner, or ranking. Budgets are experiment thresholds, not assertions about actual provider context-window capacities. See [COMMANDS.md](COMMANDS.md), [WORKFLOWS.md](WORKFLOWS.md), and [ARCHITECTURE.md](ARCHITECTURE.md).
 
 ## Incremental-change and staleness evidence (v0.6.2)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dailephd/my-dev-kit-lab",
-  "version": "0.7.1",
+  "version": "0.7.2",
   "type": "module",
   "description": "Evidence, benchmark, and evaluation companion for my-dev-kit.",
   "bin": {