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

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

@@ -0,0 +1,108 @@
+// Render-time formatting only; the JSON report keeps exact unrounded values.
+// Rule: percent values use 2 decimals plus "%", correctness scores use 4 decimals, null is "unavailable".
+export function formatContextWindowScalingPercent(value) {
+    return value === null ? "unavailable" : `${value.toFixed(2)}%`;
+}
+export function formatContextWindowScalingScore(value) {
+    return value === null ? "unavailable" : value.toFixed(4);
+}
+export function formatContextWindowScalingCount(value) {
+    return value === null ? "unavailable" : String(value);
+}
+function clean(value) {
+    return String(value).replace(/[\u0000-\u001f\u007f]/g, " ");
+}
+function row(parts) {
+    return `- ${parts.map(([label, value]) => `${label}: ${clean(value)}`).join(" | ")}`;
+}
+/** Lines for the "Context Window Scaling" section; every value comes from the report model. */
+export function renderContextWindowScalingTextLines(section) {
+    const lines = [];
+    lines.push(`Schema: ${clean(section.schemaVersion)}`);
+    lines.push(`Budgets (estimated context tokens): ${section.budgets.join(", ")}`);
+    lines.push(`Treatments: ${section.treatments.join(", ")}`);
+    lines.push(`Token Count Method: ${clean(section.tokenCountMethod ?? "unavailable")}`);
+    lines.push("Run Summary:");
+    const summary = section.runSummary;
+    for (const [label, value] of Object.entries(summary)) {
+        lines.push(`${label}: ${value}`);
+    }
+    lines.push("Budget Summary (one row per budget and treatment):");
+    for (const s of section.budgetTreatmentSummaries) {
+        lines.push(row([
+            ["Budget", s.contextBudgetTokens],
+            ["Treatment", s.variantId],
+            ["Cells", s.totalCellCount],
+            ["Fits", s.fitCount],
+            ["Too Large", s.contextTooLargeCount],
+            ["Context Unavailable", s.contextUnavailableCount],
+            ["Success", s.successfulCellCount],
+            ["Not Successful", s.notSuccessfulCellCount],
+            ["Success Unavailable", s.successEvidenceUnavailableCount],
+            ["Success Rate", formatContextWindowScalingPercent(s.successRatePercent)],
+            ["Correctness Available", s.correctnessAvailableCount],
+            ["Mean Correctness", formatContextWindowScalingScore(s.meanCorrectnessScore)],
+            ["Mean Utilization", formatContextWindowScalingPercent(s.meanContextBudgetUtilizationPercent)],
+            ["Min Utilization", formatContextWindowScalingPercent(s.minContextBudgetUtilizationPercent)],
+            ["Max Utilization", formatContextWindowScalingPercent(s.maxContextBudgetUtilizationPercent)],
+        ]));
+    }
+    lines.push("Case Context Evidence (one row per case and treatment; context does not vary by budget):");
+    for (const c of section.caseTreatmentContexts) {
+        lines.push(row([
+            ["Case", c.caseId],
+            ["Treatment", c.variantId],
+            ["Context", c.contextStatus],
+            ["Characters", formatContextWindowScalingCount(c.characterCount)],
+            ["Estimated Tokens", formatContextWindowScalingCount(c.estimatedTokens)],
+            ["Token Method", c.tokenCountMethod ?? "unavailable"],
+            ["Observed Files", formatContextWindowScalingCount(c.observedFileCount)],
+            ["Relevant File Evidence", c.relevantFileStatus],
+            ["Expected Relevant Files", c.expectedRelevantFileCount],
+            ["Observed Expected Files", formatContextWindowScalingCount(c.observedExpectedFileCount)],
+            ["Omitted Relevant Files", formatContextWindowScalingCount(c.omittedRelevantFileCount)],
+        ]));
+    }
+    lines.push("Omitted Relevant Files (benchmark-expected files not observed in the treatment context):");
+    lines.push(row([
+        ["Evidence Available", section.relevantFileSummary.relevantFileEvidenceAvailableCount],
+        ["Unavailable", section.relevantFileSummary.relevantFileEvidenceUnavailableCount],
+        ["Not Applicable", section.relevantFileSummary.relevantFileEvidenceNotApplicableCount],
+        ["Total Omitted", section.relevantFileSummary.totalOmittedRelevantFileCount],
+    ]));
+    for (const c of section.caseTreatmentContexts) {
+        if (c.relevantFileStatus === "available" && (c.omittedRelevantFileCount ?? 0) > 0) {
+            const list = c.omittedRelevantFiles;
+            lines.push(`${clean(c.caseId)} / ${c.variantId}: omitted ${list.totalCount}; displayed ${list.displayedCount} of ${list.totalCount}; omitted from display ${list.omittedCount}; truncated ${list.truncated ? "yes" : "no"}`);
+            for (const file of list.items) {
+                lines.push(`  - ${clean(file)}`);
+            }
+        }
+        else if (c.relevantFileStatus !== "available" && c.relevantFileReason) {
+            lines.push(`${clean(c.caseId)} / ${c.variantId}: ${c.relevantFileStatus} (${clean(c.relevantFileReason)})`);
+        }
+    }
+    lines.push("Per-Case Budget Matrix (one row per case, treatment, and budget):");
+    for (const cell of section.caseBudgetCells) {
+        lines.push(row([
+            ["Case", cell.caseId],
+            ["Treatment", cell.variantId],
+            ["Budget", cell.contextBudgetTokens],
+            ["Estimated Context Tokens", formatContextWindowScalingCount(cell.contextEstimatedTokens)],
+            ["Fit", cell.contextFitStatus],
+            ["Utilization", formatContextWindowScalingPercent(cell.contextBudgetUtilizationPercent)],
+            ["Evaluation", cell.evaluationStatus],
+            ["Correctness", cell.correctness.availability],
+            ["Correctness Score", formatContextWindowScalingScore(cell.correctness.score)],
+            ["Correctness Pass", cell.correctness.pass === null ? "unavailable" : cell.correctness.pass],
+            ["Success Evidence", cell.successEvidence.status],
+            ["Success", cell.successEvidence.success === null ? "unavailable" : cell.successEvidence.success],
+            ["Success Reason", cell.successEvidence.reason],
+        ]));
+    }
+    lines.push("Interpretation And Limitations:");
+    for (const item of section.interpretation) {
+        lines.push(`- ${clean(item)}`);
+    }
+    return lines;
+}

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

@@ -3,8 +3,12 @@
 // calculation beyond formatting an already-persisted number.
 import { STALE_RISK_CLASSIFICATION_EXPLANATIONS } from "./buildIncrementalChangeStalenessReport.js";
 import { REINDEX_RECOMMENDATION_EXPLANATIONS } from "./buildWarmIndexReuseReport.js";
+import { isV2ReportSection } from "./buildIncrementalChangeStalenessReportV2.js";
+import { renderIncrementalChangeStalenessHtmlV2 } from "./renderIncrementalChangeStalenessHtmlV2.js";
 const MAX_DISPLAY_ITEMS = 20;
 export function renderIncrementalChangeStalenessHtml(section) {
+    if (section !== null && isV2ReportSection(section))
+        return renderIncrementalChangeStalenessHtmlV2(section);
     if (section === null) {
         return `<section>
     <h2>Incremental-Change And Staleness Evidence</h2>

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

@@ -0,0 +1,111 @@
+// v0.6.3 -- V2 HTML section for the incremental-change-staleness plugin report. Renders the same persisted
+// facts as the text renderer through the shared row builders; every persisted string is HTML-escaped.
+import { COMPARISON_PRESENTATION_ORDER, EVIDENCE_FAMILY_NOTE, SCENARIO_SUMMARY_ROWS, TREATMENT_PRESENTATION_ORDER, affectedNeighborhoodSummary, comparisonBlock, treatmentBlock } from "./incrementalChangeStalenessReportRowsV2.js";
+const MAX_DISPLAY_ITEMS = 20;
+export function renderIncrementalChangeStalenessHtmlV2(section) {
+    return `<section>
+    <h2>Incremental-Change And Staleness Evidence</h2>
+    <p class="muted">Scoped experimental evidence: results are limited to the executed scenarios below. Full refresh is a comparison reference, not a declared best treatment.</p>
+    ${table(["Field", "Value"], SCENARIO_SUMMARY_ROWS(section.summary))}
+    ${section.scenarios.map(renderScenario).join("\n")}
+    <h3>Limitations</h3>
+    ${list(section.limitations)}
+  </section>`;
+}
+function renderScenario(scenario) {
+    const lifecycle = scenario.lifecycle;
+    const affected = affectedNeighborhoodSummary(scenario);
+    return `<h3>Scenario: ${escapeHtml(scenario.scenarioId)}</h3>
+    <h4>Scenario Definition</h4>
+    ${table(["Field", "Value"], [
+        ["Scenario ID", scenario.scenarioId],
+        ["Category", scenario.category],
+        ["Benchmark project", scenario.benchmarkProjectId],
+        ["Base case", scenario.baseCaseId],
+        ["Answer policy", scenario.answerPolicy],
+        ["Query", scenario.query ?? "unavailable"],
+        ["Status", scenario.status],
+        ["Failure reason", scenario.failureReason ?? "not applicable"]
+    ])}
+    <p>Expected files:</p>
+    ${boundedList(scenario.expectedFiles)}
+    <p>Expected symbols:</p>
+    ${boundedList(scenario.expectedSymbols)}
+    <h4>Lifecycle Integrity</h4>
+    ${lifecycle
+        ? `${table(["Field", "Value"], [
+            ["my-dev-kit version", lifecycle.myDevKitVersion ?? "unavailable"],
+            ["Index invocations (total)", String(lifecycle.totalIndexInvocationCount)],
+            ["Freshness assessments (total)", String(lifecycle.totalFreshnessAssessmentCount)],
+            ...Object.entries(lifecycle.preMutationEquivalence).map(([id, result]) => [`Pre-mutation equivalence (${id} vs stale-index reference)`, result]),
+            ...Object.entries(lifecycle.postMutationEquivalence).map(([id, result]) => [`Post-mutation equivalence (${id} vs stale-index reference)`, result])
+        ])}<p>Controlled file paths:</p>${boundedList(lifecycle.controlledFilePaths)}<p>Source roots:</p>${boundedList(lifecycle.sourceRoots)}`
+        : "<p>Not available for this scenario.</p>"}
+    <h4>Affected-Neighborhood Evidence (Changed Baseline Neighborhood Relative To The Task)</h4>
+    ${affected.state === "none"
+        ? "<p>Not available.</p>"
+        : affected.state === "inconsistent"
+            ? "<p>inconsistent persisted evidence</p>"
+            : `${table(["Field", "Value"], affected.rows)}<p>${escapeHtml(affected.explanation)}</p>`}
+    <p class="muted">${escapeHtml(EVIDENCE_FAMILY_NOTE)}</p>
+    ${scenario.treatments.length === 0
+        ? "<h4>Treatments</h4><p>Not produced: the scenario failed before any treatment evidence existed.</p>"
+        : TREATMENT_PRESENTATION_ORDER.map((entry) => renderTreatment(scenario, entry)).join("\n")}
+    <h4>Reference Comparisons (Against The Full-Refresh Reference)</h4>
+    ${COMPARISON_PRESENTATION_ORDER.map((entry) => renderComparison(scenario, entry)).join("\n")}`;
+}
+function renderTreatment(scenario, entry) {
+    const block = treatmentBlock(scenario, entry.id, entry.label);
+    const title = `${block.label} Treatment (${entry.id})`;
+    if (!block.available)
+        return `<h4>${escapeHtml(title)}</h4><p>Not available.</p>`;
+    return `<h4>${escapeHtml(title)}</h4>
+    ${table(["Field", "Value"], block.rows)}
+    <p><strong>Refresh Execution</strong> (upstream evidence of what my-dev-kit actually did)</p>
+    ${table(["Field", "Value"], block.refreshRows)}
+    ${block.fallbackStatement ? `<p class="fallback"><strong>${escapeHtml(block.fallbackStatement)}</strong></p>` : ""}
+    ${block.forcedNeighborSample ? `<p>Forced-neighbor sample:</p>${boundedList(block.forcedNeighborSample)}` : ""}
+    <p>Files read:</p>
+    ${boundedList(block.filesRead)}
+    <p>Required files:</p>
+    ${boundedList(block.requiredFiles)}
+    <p>Observed files:</p>
+    ${boundedList(block.observedFiles)}
+    <p>Missing files:</p>
+    ${boundedList(block.missingFiles)}`;
+}
+function renderComparison(scenario, entry) {
+    const block = comparisonBlock(scenario, entry);
+    if (!block.available)
+        return `<h5>${escapeHtml(block.label)}</h5><p>Not available.</p>`;
+    return `<h5>${escapeHtml(block.label)}</h5>
+    ${table(["Field", "Value"], block.rows)}
+    <p>Reason codes:</p>
+    ${list(block.reasonCodes)}
+    <p>${escapeHtml(block.explanation)}</p>`;
+}
+function boundedList(items) {
+    if (items.length === 0)
+        return "<p>none</p>";
+    const shown = items.slice(0, MAX_DISPLAY_ITEMS);
+    const omitted = items.length - shown.length;
+    return `${list(shown)}${omitted > 0 ? `<p class="muted">... ${omitted} more</p>` : ""}`;
+}
+function list(items) {
+    if (items.length === 0)
+        return "<ul><li>none</li></ul>";
+    return `<ul>${items.map((item) => `<li>${escapeHtml(item)}</li>`).join("")}</ul>`;
+}
+function table(headers, rows) {
+    return `<table><thead><tr>${headers.map((header) => `<th>${escapeHtml(header)}</th>`).join("")}</tr></thead><tbody>${rows
+        .map((row) => `<tr>${row.map((cell) => `<td>${escapeHtml(cell)}</td>`).join("")}</tr>`)
+        .join("")}</tbody></table>`;
+}
+function escapeHtml(value) {
+    return String(value ?? "")
+        .replaceAll("&", "&amp;")
+        .replaceAll("<", "&lt;")
+        .replaceAll(">", "&gt;")
+        .replaceAll('"', "&quot;")
+        .replaceAll("'", "&#39;");
+}

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

@@ -0,0 +1,96 @@
+// v0.6.3 -- V2 text section for the incremental-change-staleness plugin report. Renders only persisted
+// V2 report-model fields (via the shared row builders); no recomputation. Lists are bounded.
+import { COMPARISON_PRESENTATION_ORDER, EVIDENCE_FAMILY_NOTE, SCENARIO_SUMMARY_ROWS, TREATMENT_PRESENTATION_ORDER, affectedNeighborhoodSummary, comparisonBlock, treatmentBlock } from "./incrementalChangeStalenessReportRowsV2.js";
+function renderScenario(lines, scenario, h) {
+    h.pushSection(lines, `Scenario: ${scenario.scenarioId}`);
+    lines.push(h.fieldLine("Category", scenario.category));
+    lines.push(h.fieldLine("Status", scenario.status));
+    lines.push(h.fieldLine("Failure Reason", scenario.failureReason));
+    lines.push(h.fieldLine("Benchmark Project", scenario.benchmarkProjectId));
+    lines.push(h.fieldLine("Base Case", scenario.baseCaseId));
+    lines.push(h.fieldLine("Answer Policy", scenario.answerPolicy));
+    lines.push(h.fieldLine("Query", scenario.query));
+    h.pushBoundedStringList(lines, "Expected Files", scenario.expectedFiles);
+    h.pushBoundedStringList(lines, "Expected Symbols", scenario.expectedSymbols);
+    h.pushSection(lines, "Lifecycle");
+    const lifecycle = scenario.lifecycle;
+    if (!lifecycle) {
+        lines.push("Not available.");
+    }
+    else {
+        lines.push(h.fieldLine("my-dev-kit Version", lifecycle.myDevKitVersion));
+        lines.push(h.fieldLine("Index Invocations (total)", lifecycle.totalIndexInvocationCount));
+        lines.push(h.fieldLine("Freshness Assessments (total)", lifecycle.totalFreshnessAssessmentCount));
+        for (const [treatmentId, result] of Object.entries(lifecycle.preMutationEquivalence)) {
+            lines.push(h.fieldLine(`Pre-Mutation Equivalence (${treatmentId} vs stale-index reference)`, result));
+        }
+        for (const [treatmentId, result] of Object.entries(lifecycle.postMutationEquivalence)) {
+            lines.push(h.fieldLine(`Post-Mutation Equivalence (${treatmentId} vs stale-index reference)`, result));
+        }
+        h.pushBoundedStringList(lines, "Controlled File Paths", lifecycle.controlledFilePaths);
+        h.pushBoundedStringList(lines, "Source Roots", lifecycle.sourceRoots);
+    }
+    h.pushSection(lines, "Affected-Neighborhood Evidence (changed baseline neighborhood relative to the task)");
+    const affected = affectedNeighborhoodSummary(scenario);
+    if (affected.state === "none") {
+        lines.push("Not available.");
+    }
+    else if (affected.state === "inconsistent") {
+        lines.push("inconsistent persisted evidence");
+    }
+    else {
+        for (const [label, value] of affected.rows)
+            lines.push(h.fieldLine(label, value));
+        lines.push(h.fieldLine("Reindex Recommendation Explanation", affected.explanation));
+    }
+    lines.push(EVIDENCE_FAMILY_NOTE);
+    if (scenario.treatments.length === 0) {
+        h.pushSection(lines, "Treatments");
+        lines.push("Not produced: the scenario failed before any treatment evidence existed.");
+    }
+    else {
+        for (const entry of TREATMENT_PRESENTATION_ORDER) {
+            const block = treatmentBlock(scenario, entry.id, entry.label);
+            h.pushSection(lines, `${block.label} Treatment (${entry.id})`);
+            if (!block.available) {
+                lines.push("Not available.");
+                continue;
+            }
+            for (const [label, value] of block.rows)
+                lines.push(h.fieldLine(label, value));
+            lines.push("Refresh Execution (upstream evidence of what my-dev-kit actually did):");
+            for (const [label, value] of block.refreshRows)
+                lines.push(h.fieldLine(label, value));
+            if (block.fallbackStatement)
+                lines.push(block.fallbackStatement);
+            if (block.forcedNeighborSample)
+                h.pushBoundedStringList(lines, "Forced-Neighbor Sample", block.forcedNeighborSample);
+            h.pushBoundedStringList(lines, "Files Read", block.filesRead);
+            h.pushBoundedStringList(lines, "Required Files", block.requiredFiles);
+            h.pushBoundedStringList(lines, "Observed Files", block.observedFiles);
+            h.pushBoundedStringList(lines, "Missing Files", block.missingFiles);
+        }
+    }
+    h.pushSection(lines, "Reference Comparisons (against the full-refresh reference)");
+    for (const entry of COMPARISON_PRESENTATION_ORDER) {
+        const block = comparisonBlock(scenario, entry);
+        lines.push(block.label);
+        if (!block.available) {
+            lines.push("Not available.");
+            continue;
+        }
+        for (const [label, value] of block.rows)
+            lines.push(h.fieldLine(label, value));
+        h.pushDashList(lines, block.reasonCodes);
+        lines.push(block.explanation);
+    }
+}
+export function renderIncrementalChangeStalenessSectionV2(lines, section, h) {
+    h.pushSection(lines, "Summary");
+    for (const [label, value] of SCENARIO_SUMMARY_ROWS(section.summary))
+        lines.push(h.fieldLine(label, value));
+    for (const scenario of section.scenarios)
+        renderScenario(lines, scenario, h);
+    h.pushSection(lines, "Limitations");
+    h.pushDashList(lines, section.limitations);
+}

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

@@ -1,6 +1,7 @@
 import { renderContextStrategyComparisonV043Html } from "./renderContextStrategyComparisonV043Html.js";
 import { renderWarmIndexReuseHtml } from "./renderWarmIndexReuseHtml.js";
 import { renderIncrementalChangeStalenessHtml } from "./renderIncrementalChangeStalenessHtml.js";
+import { renderContextWindowScalingHtml } from "./renderContextWindowScalingHtml.js";
 export function renderPluginExperimentReportHtml(report) {
     return `<!DOCTYPE html>
 <html lang="en">
@@ -102,6 +103,8 @@ export function renderPluginExperimentReportHtml(report) {
 
   ${renderIncrementalChangeStalenessHtml(report.incrementalChangeStaleness)}
 
+  ${renderContextWindowScalingHtml(report.contextWindowScaling)}
+
   <section>
     <h2>Warnings, Skips, And Failures</h2>
     ${report.findings.length ? table(["Severity", "Code", "Message", "Variant", "Case"], report.findings.map((finding) => [

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

@@ -1,5 +1,8 @@
 import { STALE_RISK_CLASSIFICATION_EXPLANATIONS } from "./buildIncrementalChangeStalenessReport.js";
+import { isV2ReportSection } from "./buildIncrementalChangeStalenessReportV2.js";
+import { renderIncrementalChangeStalenessSectionV2 } from "./renderIncrementalChangeStalenessTextV2.js";
 import { REINDEX_RECOMMENDATION_EXPLANATIONS } from "./buildWarmIndexReuseReport.js";
+import { renderContextWindowScalingTextLines } from "./renderContextWindowScalingText.js";
 function sanitizeScalar(value) {
     const text = String(value);
     let result = "";
@@ -612,6 +615,10 @@ function renderIncrementalChangeStalenessSection(lines, section) {
         lines.push("Not applicable to this plugin.");
         return;
     }
+    if (isV2ReportSection(section)) {
+        renderIncrementalChangeStalenessSectionV2(lines, section, { pushSection, fieldLine, pushDashList, pushBoundedStringList });
+        return;
+    }
     pushSection(lines, "Summary");
     lines.push(fieldLine("Scenarios", section.scenarioCount));
     lines.push(fieldLine("Ready", section.readyScenarioCount));
@@ -657,6 +664,13 @@ export function renderPluginExperimentReportText(report) {
     renderWarmIndexReuseSection(lines, report.warmIndexReuse);
     pushSection(lines, "Incremental-Change And Staleness Evidence");
     renderIncrementalChangeStalenessSection(lines, report.incrementalChangeStaleness);
+    pushSection(lines, "Context Window Scaling");
+    if (report.contextWindowScaling === null) {
+        lines.push("Not applicable to this plugin.");
+    }
+    else {
+        lines.push(...renderContextWindowScalingTextLines(report.contextWindowScaling));
+    }
     pushSection(lines, "Warnings, Skips, And Failures");
     pushDashList(lines, report.findings.map((finding) => `${finding.severity} ${finding.code} ${finding.message} variant=${finding.variantId ?? ""} case=${finding.caseId ?? ""}`));
     pushSection(lines, "Artifacts");

package/dist/src/securityValidation/staticScans/codeql.js

@@ -1,18 +1,18 @@
 import { runSecurityCommand } from "../commandRunner.js";
 import { resolveCommand } from "../../core/resolveCommand.js";
 import { skippedCheck } from "../cliAdversarial/runAdversarialCheck.js";
-// CodeQL is primarily a GitHub Actions / code-scanning integration.
-// Local CodeQL CLI is optional — if unavailable the check is skipped.
-// Absence is not a release blocker; it surfaces as "ready except optional checks".
+// This local check only verifies CodeQL CLI availability and integration.
+// Full CodeQL analysis is owned by .github/workflows/codeql.yml.
+// Release readiness requires successful GitHub analysis for the exact candidate SHA.
 export async function runCodeqlCheck(options) {
     const { cwd, timeoutMs } = options;
     const resolved = resolveCommand("codeql", { cwd, env: process.env });
     if (resolved.resolutionKind === "unavailable") {
         return skippedCheck({
             id: "codeql-scan",
-            name: "CodeQL static analysis",
+            name: "CodeQL CLI availability preflight",
             category: "static-scan",
-            reason: "CodeQL CLI not found in PATH. Full analysis runs via GitHub Actions code-scanning workflow. Install the CodeQL CLI locally for local analysis.",
+            reason: "Local CodeQL CLI is unavailable, so the local availability preflight is skipped. Full release-readiness coverage requires a successful GitHub CodeQL advanced-setup analysis for the exact candidate SHA.",
         });
     }
     const startedAt = new Date().toISOString();
@@ -29,7 +29,7 @@ export async function runCodeqlCheck(options) {
     if (versionCmd.exitCode !== 0 || versionCmd.exitCode === null) {
         return {
             id: "codeql-scan",
-            name: "CodeQL static analysis",
+            name: "CodeQL CLI availability preflight",
             category: "static-scan",
             status: "failed",
             severity: "major",
@@ -50,10 +50,10 @@ export async function runCodeqlCheck(options) {
             command: "codeql version --format terse",
         };
     }
-    // CLI is present and functional. Full analysis runs in GitHub Actions.
+    // The CLI is present and functional; this is not repository-wide analysis.
     return {
         id: "codeql-scan",
-        name: "CodeQL static analysis",
+        name: "CodeQL CLI availability preflight",
         category: "static-scan",
         status: "passed",
         severity: "informational",

package/docs/METRICS.md

@@ -596,6 +596,32 @@ All six metrics are warm-side only (they are not on the raw-full-file side, beca
 
 **Observational only.** The evidence never triggers reindexing, suppresses or alters warm retrieval, or changes execution, provider, agent, correctness, or token-evidence status. It uses only the baseline graph of the prepared index: there is no graph-diff, refreshed-index, or stale-versus-refreshed comparison.
 
+## Context-window scaling evidence (v0.7.0)
+
+Status: **released in v0.7.0**. The `context-window-scaling` plugin compares `raw-full-file` and `my-dev-kit-guided` treatment contexts against selected estimated-token budgets. It runs the bundled case catalog against the fixed self target.
+
+### Measurement and budget-cell semantics
+
+- **Estimated tokens:** context construction records character count and an estimated token count using the Lab's deterministic `ceil(characters / 4)` heuristic. It is not a provider tokenizer result, model-window measurement, or billing telemetry.
+- **Budget values:** defaults are 8192, 16384, 32768, and 65536 tokens (shown as 8k, 16k, 32k, and 64k). Users can select other positive safe integers. Duplicate values after normalization are rejected; accepted budgets are sorted ascending.
+- **Context fit:** `fits` when estimated context tokens are less than or equal to the selected budget; `context-too-large` when they exceed it; `unavailable` when context measurement is unavailable. This classification does not truncate or reconstruct the context. Each treatment's context is built once, independent of its budgets.
+- **Budget utilization:** `contextBudgetUtilizationPercent = estimatedContextTokens / budget * 100`. It is not capped at 100 percent, so an over-budget context can have utilization greater than 100. It is unavailable when context size is unavailable.
+- **Correctness:** the existing deterministic fake-agent answer-key evaluator runs no more than once per treatment and is shared by every budget cell where that treatment's context fits. Correctness is unavailable for a `context-too-large` cell and is not converted to zero. This harness's evaluation is context-independent; it does not estimate how a real model's correctness would change with the supplied context.
+- **Success:** success is true only when the context fits and the available correctness evidence passes. A too-large context is an available unsuccessful cell with reason `context-too-large`, even though no evaluation ran. Operational or evidence-unavailable cells remain unavailable and are excluded from success-rate denominators. Thus context-too-large cells count as not successful, while unavailable cells do not.
+- **Omitted relevant files:** benchmark-expected relevant files absent from the treatment's observed context provenance. This is an evidence count/list, not retrieval precision, recall, or an irrelevant-context ratio. The report bounds displayed omitted paths and retains total/displayed/omitted counts.
+
+### Aggregate and per-cell metrics
+
+`aggregateContextWindowScaling` in `src/experiments/plugins/contextWindowScaling/metrics.ts` owns the per-budget and run summaries. `buildContextWindowScalingReport.ts` presents these results without recalculating fit, utilization, success, or correctness.
+
+For each budget and treatment, aggregate evidence includes `fitCount`, `contextTooLargeCount`, `contextUnavailableCount`, `successfulCellCount`, `notSuccessfulCellCount`, success-evidence availability counts, `successRatePercent`, correctness availability counts and `meanCorrectnessScore`, and availability counts plus mean/min/max context-budget utilization. Success rate is successful cells divided by success-evidence-available cells; it is null when none are available. Mean correctness averages only available scores and is null when none are available. Utilization summaries include only measured values and remain uncapped.
+
+The generic `ExperimentMetric` projection emits run-level case and budget counts, plus per-budget/per-treatment fit count, too-large count, successful count, success rate, mean correctness, and mean utilization. Per-case treatment outcomes carry context estimated tokens, omitted relevant file count when available, and budget-scoped utilization, correctness score, and success evidence. Unavailable values remain null/unavailable with their evidence status; no value is fabricated as zero.
+
+The report artifact schema is `my-dev-kit-lab-context-window-scaling-report-v1`. It includes run summaries, budget-treatment summaries, per-treatment context measurements, budget cells, relevant-file summary, and fixed interpretation limits. The execution artifact is `context-window-scaling-execution.json` (`my-dev-kit-lab-context-window-scaling-execution-v1`) and does not embed context text.
+
+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)
 
 The `incremental-change-staleness` plugin reuses the six existing v0.6.1 affected-neighborhood numeric metrics unchanged (`changedFileCount`, `changedSymbolCount`, `affectedNodeCount`, `affectedEdgeCount`, `taskOverlapCount`, `taskOverlapPercent`; see "Affected-neighborhood metrics (v0.6.1)" above) and adds no new numeric formula.
@@ -629,3 +655,35 @@ The `incremental-change-staleness` plugin reuses the six existing v0.6.1 affecte
 `staleRiskClassification` is not a numeric risk score, not a winner, not a ranking, and not an automatic reindex decision. `no-observed-stale-regression` means only that this matched scenario did not observe a stale-specific regression under these two frozen evidence dimensions; it does not establish that stale indexes are generally safe. `reindexRecommendation` (the released v0.6.1 categorical evidence) remains separate observational evidence about the affected-neighborhood analysis; it does not select or trigger either treatment and is not an input to the stale-risk classification above.
 
 **Report presentation.** `report.incrementalChangeStaleness` holds `scenarioCount`, `readyScenarioCount`, `failedScenarioCount`, `observedStaleRegressionCount`, `noObservedStaleRegressionCount`, `inconclusiveCount`, per-scenario evidence (lifecycle, both treatments in order, and the comparison), and fixed limitations text. There is no overall score, grade, winner, best-treatment, or safe-to-skip-reindex field anywhere in the report or the persisted execution artifact.
+
+### Partial-refresh treatment evidence (v0.6.3, retained in current release)
+
+The `incremental-change-staleness` plugin now compares four treatments (`stale-index`, `changed-files-refresh`, `affected-neighborhood-refresh`, `full-refresh`). It defines no new formula. Two evidence families must not be merged:
+
+- **Lab task-relationship affected-neighborhood evidence** (released v0.6.1, unchanged): the six numeric metrics `changedFileCount`, `changedSymbolCount`, `affectedNodeCount`, `affectedEdgeCount`, `taskOverlapCount`, `taskOverlapPercent`, plus the categorical `relationship` and `reindexRecommendation`. They describe the baseline graph neighborhood of the controlled change relative to the task. `changedSymbolCount` still means baseline symbol identities belonging to confirmed changed indexed files, not proof that any symbol body changed, and `reindexRecommendation` stays observational: it selects and executes no treatment.
+- **Upstream refresh execution evidence** (new): what my-dev-kit actually did during a partial refresh invocation. It does not depend on the task and is not a task-relevance measure.
+
+**Numeric upstream-refresh metrics** (unit `count`; emitted as `ExperimentMetric` entries on the outcome of an incremental treatment, `changed-files-refresh` or `affected-neighborhood-refresh`, and never on `stale-index` or `full-refresh`):
+
+| Metric ID | Meaning |
+|---|---|
+| `upstream-refresh-fresh-extraction-file-count` | Files upstream freshly re-extracted during the refresh invocation. |
+| `upstream-refresh-reused-file-count` | Files upstream reused from the previous index. |
+| `upstream-refresh-forced-neighbor-reanalysis-file-count` | Neighboring files upstream forced to re-analyze during the refresh. |
+| `upstream-refresh-seed-file-count` | Seed files upstream selected for the affected-neighborhood refresh. |
+| `upstream-refresh-seed-symbol-count` | Seed symbols upstream selected. |
+| `upstream-refresh-affected-node-count` | Graph nodes upstream treated as affected. |
+| `upstream-refresh-affected-edge-count` | Graph edges upstream treated as affected. |
+
+Availability: the first three are always present for a validated incremental treatment. The seed, node, and edge counts appear only when upstream supplied a non-null value; a `null` upstream value is unavailable evidence and the metric is omitted, never emitted as zero. These counts describe upstream execution only: they do not prove a treatment is better, faster, safer, or more accurate, and they are distinct from the Lab `affectedNodeCount`/`affectedEdgeCount` above (different metric IDs).
+
+**Categorical refresh evidence** (not numeric metrics, never converted to numbers): `requestedScope` (`changed-files` or `affected-neighborhood`), `appliedScope` (the scope upstream actually applied: `changed-files`, `affected-neighborhood`, `full`, or `none`), `selectionStatus` (`applied`, `fallback-full`, or `not-needed`), `fallbackReason` (an upstream reason or `null`), `forcedNeighborSample` (a bounded sample of path strings, capped by upstream, so its length can be less than the forced-neighbor count), and the Lab `refreshRealization` (`NO_REFRESH`, `APPLIED_PARTIAL`, `FALLBACK_FULL`, `FULL_REFRESH`). Only `changed-files-refresh` and `affected-neighborhood-refresh` can be `APPLIED_PARTIAL` or `FALLBACK_FULL`.
+
+**Reference comparisons** (exactly three per ready scenario, each against `full-refresh`):
+
+- `stale-index` vs `full-refresh` uses the v0.6.2 stale-risk vocabulary and precedence unchanged (`observed-stale-regression`, `no-observed-stale-regression`, `inconclusive`).
+- `changed-files-refresh` vs `full-refresh` and `affected-neighborhood-refresh` vs `full-refresh` use neutral candidate relations (`candidate-worse`, `same`, `candidate-better`, `unknown`) for deterministic fake-agent correctness and for the required-file status, with the frozen precedence: (1) `not-comparable-as-partial-refresh` if the candidate fell back to a full rebuild (`FALLBACK_FULL`); (2) `observed-regression-relative-to-full` if correctness or required-file presence is `candidate-worse`; (3) `inconclusive` if either relation is `unknown`; (4) otherwise `no-observed-regression-relative-to-full`.
+
+`no-observed-regression-relative-to-full` means only that the executed scenario showed no regression under those two evidence dimensions. It does not establish equivalence or safety and does not show that full refresh is unnecessary. `not-comparable-as-partial-refresh` says the run gives no evidence about the requested partial behavior. There is no winner, ranking, composite score, safety score, safe-to-skip-refresh flag, or stale-risk percentage. Ordinary per-treatment correctness `score` remains the existing deterministic fake-agent evidence.
+
+**Report presentation.** `report.incrementalChangeStaleness` (schema `my-dev-kit-lab-incremental-change-staleness-report-v2`) holds the summary counts (including per-treatment applied-partial, fallback, and classification counts), per-scenario lifecycle, four treatments and three comparisons identified by explicit treatment IDs, and fixed limitations text. Unavailable evidence is written as `unavailable` or `not applicable`, never zero. Historical V1 reports keep their original two-treatment presentation.

package/examples/tutorial-browser/prepare.mjs

@@ -1,14 +1,14 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const sourceRoot = path.dirname(fileURLToPath(import.meta.url));
-const targetRoot = process.argv[2];
-if (!targetRoot) {
-  console.error("prepare requires a target root argument");
-  process.exit(2);
-}
-fs.mkdirSync(path.join(targetRoot, "app"), { recursive: true });
-fs.mkdirSync(path.join(targetRoot, "out"), { recursive: true });
-for (const file of ["index.html", "server.mjs"]) fs.copyFileSync(path.join(sourceRoot, file), path.join(targetRoot, "app", file));
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const sourceRoot = path.dirname(fileURLToPath(import.meta.url));
+const targetRoot = process.argv[2];
+if (!targetRoot) {
+  console.error("prepare requires a target root argument");
+  process.exit(2);
+}
+fs.mkdirSync(path.join(targetRoot, "app"), { recursive: true });
+fs.mkdirSync(path.join(targetRoot, "out"), { recursive: true });
+for (const file of ["index.html", "server.mjs"]) fs.copyFileSync(path.join(sourceRoot, file), path.join(targetRoot, "app", file));
 fs.writeFileSync(path.join(targetRoot, "out", "report.json"), JSON.stringify({ prepared: true, counts: { widgets: 3 } }, null, 2), "utf8");

package/examples/tutorial-browser/server.mjs

@@ -1,14 +1,14 @@
-import http from "node:http";
-import fs from "node:fs";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-
-const root = path.dirname(fileURLToPath(import.meta.url));
-const port = Number(process.env.TUTORIAL_FIXTURE_PORT || 0);
-const server = http.createServer((req, res) => {
-  const url = new URL(req.url ?? "/", "http://127.0.0.1");
-  if (url.pathname === "/api/status") { res.writeHead(200, { "content-type": "application/json" }); res.end(JSON.stringify({ ok: true, widgets: 3 })); return; }
-  const filePath = url.pathname === "/" ? path.join(root, "index.html") : path.join(root, url.pathname);
-  fs.readFile(filePath, (error, contents) => { if (error) { res.writeHead(404); res.end("not found"); return; } res.writeHead(200, { "content-type": filePath.endsWith(".html") ? "text/html" : "application/octet-stream" }); res.end(contents); });
-});
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+
+const root = path.dirname(fileURLToPath(import.meta.url));
+const port = Number(process.env.TUTORIAL_FIXTURE_PORT || 0);
+const server = http.createServer((req, res) => {
+  const url = new URL(req.url ?? "/", "http://127.0.0.1");
+  if (url.pathname === "/api/status") { res.writeHead(200, { "content-type": "application/json" }); res.end(JSON.stringify({ ok: true, widgets: 3 })); return; }
+  const filePath = url.pathname === "/" ? path.join(root, "index.html") : path.join(root, url.pathname);
+  fs.readFile(filePath, (error, contents) => { if (error) { res.writeHead(404); res.end("not found"); return; } res.writeHead(200, { "content-type": filePath.endsWith(".html") ? "text/html" : "application/octet-stream" }); res.end(contents); });
+});
 server.listen(port, "127.0.0.1", () => console.log("tutorial fixture listening on " + server.address().port));

package/package.json

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