@dailephd/my-dev-kit-lab 0.8.0 → 0.8.2

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

@@ -28,3 +28,12 @@ export * from "./retrievalPrecisionRecallReportModel.js";
 export { buildRetrievalPrecisionRecallReport, RETRIEVAL_PRECISION_RECALL_LIMITATIONS } from "./buildRetrievalPrecisionRecallReport.js";
 export { renderRetrievalPrecisionRecallHtml } from "./renderRetrievalPrecisionRecallHtml.js";
 export { renderRetrievalPrecisionRecallTextLines } from "./renderRetrievalPrecisionRecallText.js";
+export * from "./contextPackGenerationReportModel.js";
+export { buildContextPackGenerationReport, CONTEXT_PACK_GENERATION_LIMITATIONS } from "./buildContextPackGenerationReport.js";
+export { loadContextPackArtifacts } from "./loadContextPackArtifacts.js";
+export { renderContextPackGenerationHtml } from "./renderContextPackGenerationHtml.js";
+export { renderContextPackGenerationTextLines } from "./renderContextPackGenerationText.js";
+export * from "./retrievalQueryStrategyComparisonReportModel.js";
+export { buildRetrievalQueryStrategyComparisonReport, RETRIEVAL_QUERY_STRATEGY_COMPARISON_LIMITATIONS } from "./buildRetrievalQueryStrategyComparisonReport.js";
+export { renderRetrievalQueryStrategyComparisonHtml } from "./renderRetrievalQueryStrategyComparisonHtml.js";
+export { renderRetrievalQueryStrategyComparisonTextLines } from "./renderRetrievalQueryStrategyComparisonText.js";

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

@@ -0,0 +1,43 @@
+import { readFile } from "node:fs/promises";
+import { resolveWithinRoot } from "../../core/pathSafety.js";
+import { CONTEXT_PACK_GENERATION_PLUGIN_ID } from "../../experiments/plugins/contextPackGeneration/metadata.js";
+import { CONTEXT_PACK_SCHEMA_VERSION } from "../../experiments/plugins/contextPackGeneration/types.js";
+function isContextPack(value, caseId) {
+    if (typeof value !== "object" || value === null)
+        return false;
+    const pack = value;
+    return (pack.schemaVersion === CONTEXT_PACK_SCHEMA_VERSION &&
+        pack.caseId === caseId &&
+        typeof pack.task === "object" &&
+        pack.task !== null &&
+        Array.isArray(pack.files) &&
+        Array.isArray(pack.symbols) &&
+        Array.isArray(pack.sourceSlices) &&
+        Array.isArray(pack.callRelationships) &&
+        Array.isArray(pack.tests) &&
+        Array.isArray(pack.evidenceNotes));
+}
+/**
+ * Reads the persisted per-case pack artifacts the plugin already wrote under the output root. It never reruns retrieval or
+ * reopens repository source. A missing or invalid artifact is simply absent: the report then marks that preview unavailable.
+ */
+export async function loadContextPackArtifacts(run, outputRoot) {
+    const packs = new Map();
+    if (run.pluginId !== CONTEXT_PACK_GENERATION_PLUGIN_ID)
+        return packs;
+    const evidence = run.caseExecutionEvidence ?? [];
+    for (const entry of evidence) {
+        const relativePath = entry.treatments.find((treatment) => treatment.treatmentId === "context-pack")?.packArtifactPath;
+        if (!relativePath)
+            continue;
+        try {
+            const parsed = JSON.parse(await readFile(resolveWithinRoot(outputRoot, relativePath), "utf8"));
+            if (isContextPack(parsed, entry.caseId))
+                packs.set(entry.caseId, parsed);
+        }
+        catch {
+            // Unreadable or unsafe artifact: the preview is reported as pack-artifact-unavailable, never as an empty pack.
+        }
+    }
+    return packs;
+}

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

@@ -0,0 +1,122 @@
+import { formatContextPackNumber, redactedPreviewDisplayLines } from "./renderContextPackGenerationText.js";
+import { formatRetrievalQueryStrategyMetric } from "./renderRetrievalQueryStrategyComparisonText.js";
+const formatMean = (value) => (value === undefined || value === null ? "unavailable" : value.toFixed(4));
+export function renderContextPackGenerationHtml(section) {
+    if (section === null)
+        return "";
+    return `<section>
+    <h2>Context Pack Generation</h2>
+    <h3>Methodology</h3>
+    ${table(["Field", "Value"], [
+        ["Schema", section.schemaVersion],
+        ["Experiment", `${section.experiment.pluginId} (${section.experiment.target})`],
+        ["Treatment order", section.treatmentOrder.join(", ")],
+        ["File F1", section.methodology.fileF1],
+        ["Symbol F1", section.methodology.symbolF1],
+        ["Aggregation", section.methodology.aggregation],
+        ["Treatment comparison", section.methodology.treatmentComparison],
+        ["Size measure", section.methodology.sizeMeasure]
+    ])}
+    <h3>Per-Case Treatments</h3>
+    ${table(["Case", "Project", "Task Type", "Treatment", "Status", "Availability", "File F1", "Symbol F1", "Fact Coverage", "Estimated Tokens"], section.cases.flatMap((entry) => entry.treatments.map((treatment) => [
+        entry.caseId,
+        entry.benchmarkProject,
+        entry.taskLocality ?? "unavailable",
+        treatment.treatmentId,
+        treatment.executionStatus,
+        treatment.availability ?? "unavailable",
+        formatRetrievalQueryStrategyMetric(treatment.fileF1),
+        formatRetrievalQueryStrategyMetric(treatment.symbolF1),
+        formatRetrievalQueryStrategyMetric(treatment.factCoverage),
+        formatContextPackNumber(treatment.estimatedTokens)
+    ])))}
+    <h3>Paired Comparison (context-pack minus raw-full-file)</h3>
+    ${table(["Case", "File F1 Delta", "Symbol F1 Delta", "Fact Coverage Delta", "Estimated Token Delta", "Tokens Saved", "Percent Saved"], section.cases.map((entry) => [
+        entry.caseId,
+        formatMean(entry.comparison.fileF1Delta),
+        formatMean(entry.comparison.symbolF1Delta),
+        formatMean(entry.comparison.factCoverageDelta),
+        formatContextPackNumber(entry.comparison.estimatedTokenDelta),
+        formatContextPackNumber(entry.comparison.tokensSaved),
+        formatMean(entry.comparison.percentSaved)
+    ]))}
+    <h3>Scope Aggregates</h3>
+    ${section.scopes
+        .map((scope) => `<h4>${escapeHtml(scope.scopeId)}</h4>
+    <p>Cases ${scope.caseCount}; included ${scope.includedCaseCount} (${escapeHtml(scope.includedCaseIds.join(", ") || "none")}); excluded ${scope.excludedCaseCount} (${escapeHtml(scope.excludedCaseIds.join(", ") || "none")}).</p>
+    ${table(["Treatment", "Completed", "Partial", "Failed", "Mean File F1", "Mean Symbol F1", "Mean Fact Coverage", "Mean Estimated Tokens"], scope.treatmentSummaries.map((summary) => [
+        summary.treatmentId,
+        String(summary.completedCaseCount),
+        String(summary.partialCaseCount),
+        String(summary.failedCaseCount),
+        formatMean(summary.objectives?.meanFileF1),
+        formatMean(summary.objectives?.meanSymbolF1),
+        formatMean(summary.objectives?.meanFactCoverage),
+        formatContextPackNumber(summary.objectives?.meanEstimatedTokenCount)
+    ]))}
+    ${table(["Mean File F1 Delta", "Mean Symbol F1 Delta", "Mean Fact Coverage Delta", "Mean Estimated Token Delta", "Mean Tokens Saved", "Percent Saved Of Means"], [
+        [
+            formatMean(scope.pairedDeltas?.meanFileF1Delta),
+            formatMean(scope.pairedDeltas?.meanSymbolF1Delta),
+            formatMean(scope.pairedDeltas?.meanFactCoverageDelta),
+            formatContextPackNumber(scope.pairedDeltas?.meanEstimatedTokenDelta),
+            formatContextPackNumber(scope.tokenSavings?.meanTokensSaved),
+            formatMean(scope.tokenSavings?.percentSavedOfMeans)
+        ]
+    ])}`)
+        .join("\n    ")}
+    <h3>Context Pack Preview</h3>
+    <p>Bounded for display only; stored packs and measured sizes are unchanged.</p>
+    ${section.previews.map(previewHtml).join("\n    ")}
+    <h3>Interpretation Limits</h3>
+    ${listHtml(section.limitations)}
+  </section>`;
+}
+function previewHtml(preview) {
+    if (preview.status === "redacted-external-local") {
+        return `<h4>${escapeHtml(preview.caseId)}</h4>
+    <p>Status ${escapeHtml(preview.status)}; pack availability ${escapeHtml(preview.packAvailability ?? "unavailable")}.</p>
+    ${table(["Section", "Availability", "Items", "Estimated Tokens"], preview.sections.map((s) => [s.id, s.availability, String(s.itemCount), String(s.estimatedTokens)]))}
+    ${listHtml(redactedPreviewDisplayLines(preview))}`;
+    }
+    const head = `<h4>${escapeHtml(preview.caseId)}</h4>
+    <p>Status ${escapeHtml(preview.status)}; pack availability ${escapeHtml(preview.packAvailability ?? "unavailable")}.</p>
+    ${table(["Section", "Availability", "Items", "Estimated Tokens"], preview.sections.map((s) => [s.id, s.availability, String(s.itemCount), String(s.estimatedTokens)]))}`;
+    if (preview.task === null)
+        return head;
+    const count = (list) => `shown ${list.items.length} of ${list.totalCount}; omitted ${list.omittedCount}`;
+    return `${head}
+    <h5>1. Task</h5>
+    <p><strong>${escapeHtml(preview.task.title)}</strong> ${escapeHtml(preview.task.summary)}</p>
+    <h5>2. Relevant files (${count(preview.files)})</h5>
+    ${listHtml(preview.files.items.map((file) => `${file.path} rank=${file.rank} reason=${file.reason}`))}
+    <h5>3. Relevant symbols (${count(preview.symbols)})</h5>
+    ${listHtml(preview.symbols.items.map((symbol) => `${symbol.name} file=${symbol.file ?? "unknown"} line=${symbol.line ?? "unknown"}`))}
+    <h5>4. Source slices (${count(preview.sourceSlices)})</h5>
+    ${preview
+        .sourceSlices.items.map((slice) => `<p>${escapeHtml(`${slice.file}:${slice.startLine}-${slice.endLine}`)} boundary known: ${slice.boundaryKnown}; truncated by experiment policy: ${slice.truncated}; truncated by report preview: ${slice.previewTruncated} (showing ${slice.previewLineCount} of ${slice.lineCount} lines)</p>
+    <pre>${escapeHtml(slice.previewText)}</pre>`)
+        .join("\n    ")}
+    <h5>5. Call relationships (${count(preview.callRelationships)})</h5>
+    ${listHtml(preview.callRelationships.items.map((call) => `${call.fromNodeId} calls ${call.toNodeId}`))}
+    <h5>6. Tests (${count(preview.tests)})</h5>
+    ${listHtml(preview.tests.items.map((test) => `${test.path} how=${test.how}`))}
+    <h5>7. Evidence notes (${count(preview.evidenceNotes)})</h5>
+    ${listHtml(preview.evidenceNotes.items)}`;
+}
+function listHtml(items) {
+    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/renderContextPackGenerationText.js

@@ -0,0 +1,101 @@
+import { formatRetrievalQueryStrategyMetric, formatRetrievalQueryStrategyNumber } from "./renderRetrievalQueryStrategyComparisonText.js";
+const formatMean = (value) => (value === undefined || value === null ? "unavailable" : value.toFixed(4));
+export const formatContextPackNumber = (value) => formatRetrievalQueryStrategyNumber(value ?? null);
+const omitted = (list) => `shown=${list.items.length} total=${list.totalCount} omitted=${list.omittedCount}`;
+const REDACTED_SECTION_LABELS = {
+    files: { label: "Relevant files", what: "identities redacted" },
+    symbols: { label: "Relevant symbols", what: "identities redacted" },
+    sourceSlices: { label: "Source slices", what: "content redacted" },
+    callRelationships: { label: "Call relationships", what: "identities redacted" },
+    tests: { label: "Tests", what: "identities redacted" },
+    evidenceNotes: { label: "Evidence notes", what: "counts only" }
+};
+/**
+ * Literal, fixed-text lines for an external-local preview, generated from persisted safe counts only. Shared by the text
+ * and HTML renderers so both show identical wording; no identity or source text can reach this function.
+ */
+export function redactedPreviewDisplayLines(preview) {
+    const lines = ["Task: title and summary redacted"];
+    for (const section of preview.sections) {
+        const entry = REDACTED_SECTION_LABELS[section.id];
+        if (!entry)
+            continue;
+        const truncated = section.truncatedCount !== null ? `, ${section.truncatedCount} truncated by experiment policy` : "";
+        lines.push(`${entry.label}: ${section.itemCount} ${section.itemCount === 1 ? "item" : "items"}${truncated} — ${entry.what}`);
+    }
+    return lines;
+}
+function redactedPreviewLines(preview) {
+    const lines = [`Pack preview: case=${preview.caseId} status=${preview.status} packAvailability=${preview.packAvailability ?? "unavailable"}`];
+    for (const section of preview.sections) {
+        lines.push(`  section ${section.id}: availability=${section.availability} items=${section.itemCount} estimatedTokens=${section.estimatedTokens}${section.reason ? ` reason=${section.reason}` : ""}`);
+    }
+    for (const [index, line] of redactedPreviewDisplayLines(preview).entries())
+        lines.push(`  ${index + 1}. ${line}`);
+    return lines;
+}
+function previewLines(preview) {
+    if (preview.status === "redacted-external-local")
+        return redactedPreviewLines(preview);
+    const lines = [`Pack preview: case=${preview.caseId} status=${preview.status} packAvailability=${preview.packAvailability ?? "unavailable"}`];
+    for (const section of preview.sections) {
+        lines.push(`  section ${section.id}: availability=${section.availability} items=${section.itemCount} estimatedTokens=${section.estimatedTokens}${section.reason ? ` reason=${section.reason}` : ""}`);
+    }
+    if (preview.task === null)
+        return lines;
+    lines.push(`  1. Task: ${preview.task.title}`, `     ${preview.task.summary}`);
+    lines.push(`  2. Relevant files (${omitted(preview.files)})`);
+    for (const file of preview.files.items)
+        lines.push(`     - ${file.path} rank=${file.rank} reason=${file.reason}`);
+    lines.push(`  3. Relevant symbols (${omitted(preview.symbols)})`);
+    for (const symbol of preview.symbols.items)
+        lines.push(`     - ${symbol.name} file=${symbol.file ?? "unknown"} line=${symbol.line ?? "unknown"}`);
+    lines.push(`  4. Source slices (${omitted(preview.sourceSlices)})`);
+    for (const slice of preview.sourceSlices.items) {
+        lines.push(`     - ${slice.file}:${slice.startLine}-${slice.endLine} boundaryKnown=${slice.boundaryKnown} policyTruncated=${slice.truncated} previewTruncated=${slice.previewTruncated} (showing ${slice.previewLineCount} of ${slice.lineCount} lines)`);
+        for (const sourceLine of slice.previewText.split("\n"))
+            lines.push(`         | ${sourceLine}`);
+    }
+    lines.push(`  5. Call relationships (${omitted(preview.callRelationships)})`);
+    for (const call of preview.callRelationships.items)
+        lines.push(`     - ${call.fromNodeId} calls ${call.toNodeId}`);
+    lines.push(`  6. Tests (${omitted(preview.tests)})`);
+    for (const test of preview.tests.items)
+        lines.push(`     - ${test.path} how=${test.how}`);
+    lines.push(`  7. Evidence notes (${omitted(preview.evidenceNotes)})`);
+    for (const note of preview.evidenceNotes.items)
+        lines.push(`     - ${note}`);
+    return lines;
+}
+export function renderContextPackGenerationTextLines(section) {
+    const lines = [];
+    lines.push(`Schema: ${section.schemaVersion}`);
+    lines.push(`Experiment: ${section.experiment.pluginId} target=${section.experiment.target}`);
+    lines.push(`Treatment order: ${section.treatmentOrder.join(", ")}`);
+    lines.push(`Methodology: fileF1=${section.methodology.fileF1} symbolF1=${section.methodology.symbolF1} aggregation=${section.methodology.aggregation} comparison=${section.methodology.treatmentComparison} size=${section.methodology.sizeMeasure}`);
+    lines.push("", "Per-Case Treatments");
+    for (const entry of section.cases) {
+        for (const treatment of entry.treatments) {
+            lines.push(`- case=${entry.caseId} project=${entry.benchmarkProject} taskType=${entry.taskLocality ?? "unavailable"} treatment=${treatment.treatmentId} status=${treatment.executionStatus} availability=${treatment.availability ?? "unavailable"} fileF1=${formatRetrievalQueryStrategyMetric(treatment.fileF1)} symbolF1=${formatRetrievalQueryStrategyMetric(treatment.symbolF1)} factCoverage=${formatRetrievalQueryStrategyMetric(treatment.factCoverage)} estimatedTokens=${formatContextPackNumber(treatment.estimatedTokens)}`);
+        }
+        const c = entry.comparison;
+        lines.push(`  paired case=${entry.caseId} fileF1Delta=${formatMean(c.fileF1Delta)} symbolF1Delta=${formatMean(c.symbolF1Delta)} factCoverageDelta=${formatMean(c.factCoverageDelta)} estimatedTokenDelta=${formatContextPackNumber(c.estimatedTokenDelta)} tokensSaved=${formatContextPackNumber(c.tokensSaved)} percentSaved=${formatMean(c.percentSaved)}`);
+    }
+    lines.push("", "Scope Aggregates");
+    for (const scope of section.scopes) {
+        lines.push(`Scope ${scope.scopeId}: cases=${scope.caseCount} included=${scope.includedCaseCount} excluded=${scope.excludedCaseCount} includedIds=${scope.includedCaseIds.join(", ") || "none"} excludedIds=${scope.excludedCaseIds.join(", ") || "none"}`);
+        for (const summary of scope.treatmentSummaries) {
+            const o = summary.objectives;
+            lines.push(`- ${summary.treatmentId} completed=${summary.completedCaseCount} partial=${summary.partialCaseCount} failed=${summary.failedCaseCount} meanFileF1=${formatMean(o?.meanFileF1)} meanSymbolF1=${formatMean(o?.meanSymbolF1)} meanFactCoverage=${formatMean(o?.meanFactCoverage)} meanEstimatedTokens=${formatContextPackNumber(o?.meanEstimatedTokenCount)}`);
+        }
+        const d = scope.pairedDeltas;
+        lines.push(`  paired meanFileF1Delta=${formatMean(d?.meanFileF1Delta)} meanSymbolF1Delta=${formatMean(d?.meanSymbolF1Delta)} meanFactCoverageDelta=${formatMean(d?.meanFactCoverageDelta)} meanEstimatedTokenDelta=${formatContextPackNumber(d?.meanEstimatedTokenDelta)} meanTokensSaved=${formatContextPackNumber(scope.tokenSavings?.meanTokensSaved)} percentSavedOfMeans=${formatMean(scope.tokenSavings?.percentSavedOfMeans)}`);
+    }
+    lines.push("", "Context Pack Preview (bounded for display; stored packs are unchanged)");
+    for (const preview of section.previews)
+        lines.push(...previewLines(preview));
+    lines.push("", "Interpretation Limits");
+    for (const limitation of section.limitations)
+        lines.push(`- ${limitation}`);
+    return lines;
+}

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

@@ -3,6 +3,8 @@ import { renderWarmIndexReuseHtml } from "./renderWarmIndexReuseHtml.js";
 import { renderIncrementalChangeStalenessHtml } from "./renderIncrementalChangeStalenessHtml.js";
 import { renderContextWindowScalingHtml } from "./renderContextWindowScalingHtml.js";
 import { renderRetrievalPrecisionRecallHtml } from "./renderRetrievalPrecisionRecallHtml.js";
+import { renderRetrievalQueryStrategyComparisonHtml } from "./renderRetrievalQueryStrategyComparisonHtml.js";
+import { renderContextPackGenerationHtml } from "./renderContextPackGenerationHtml.js";
 export function renderPluginExperimentReportHtml(report) {
     const redactedTarget = report.target.privacyProjection === "external-local-redacted";
     return `<!DOCTYPE html>
@@ -109,6 +111,10 @@ export function renderPluginExperimentReportHtml(report) {
 
   ${renderRetrievalPrecisionRecallHtml(report.retrievalPrecisionRecall ?? null)}
 
+  ${renderRetrievalQueryStrategyComparisonHtml(report.retrievalQueryStrategyComparison ?? null)}
+
+  ${renderContextPackGenerationHtml(report.contextPackGeneration ?? null)}
+
   <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

@@ -4,6 +4,8 @@ import { renderIncrementalChangeStalenessSectionV2 } from "./renderIncrementalCh
 import { REINDEX_RECOMMENDATION_EXPLANATIONS } from "./buildWarmIndexReuseReport.js";
 import { renderContextWindowScalingTextLines } from "./renderContextWindowScalingText.js";
 import { renderRetrievalPrecisionRecallTextLines } from "./renderRetrievalPrecisionRecallText.js";
+import { renderRetrievalQueryStrategyComparisonTextLines } from "./renderRetrievalQueryStrategyComparisonText.js";
+import { renderContextPackGenerationTextLines } from "./renderContextPackGenerationText.js";
 function sanitizeScalar(value) {
     const text = String(value);
     let result = "";
@@ -680,6 +682,20 @@ export function renderPluginExperimentReportText(report) {
     else {
         lines.push(...renderRetrievalPrecisionRecallTextLines(retrievalPrecisionRecall));
     }
+    pushSection(lines, "Retrieval Query Strategy Comparison");
+    const retrievalQueryStrategyComparison = report.retrievalQueryStrategyComparison ?? null;
+    if (retrievalQueryStrategyComparison === null) {
+        lines.push("Not applicable to this plugin.");
+    }
+    else {
+        lines.push(...renderRetrievalQueryStrategyComparisonTextLines(retrievalQueryStrategyComparison));
+    }
+    // Additive: other plugins keep their existing text output unchanged.
+    const contextPackGeneration = report.contextPackGeneration ?? null;
+    if (contextPackGeneration !== null) {
+        pushSection(lines, "Context Pack Generation");
+        lines.push(...renderContextPackGenerationTextLines(contextPackGeneration));
+    }
     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/report/experiments/renderRetrievalQueryStrategyComparisonHtml.js

@@ -0,0 +1,96 @@
+import { RETRIEVAL_QUERY_STRATEGY_EXTERNAL_PRIVACY_NOTE, describeRetrievalQueryStrategyScope, formatRetrievalQueryStrategyList, formatRetrievalQueryStrategyMetric, formatRetrievalQueryStrategyNumber } from "./renderRetrievalQueryStrategyComparisonText.js";
+export function renderRetrievalQueryStrategyComparisonHtml(section) {
+    if (section === null)
+        return "";
+    const methodology = section.methodology;
+    const objective = (value, digits) => (value === undefined ? "unavailable" : digits ? value.toFixed(4) : String(value));
+    return `<section>
+    <h2>Retrieval Query Strategy Comparison</h2>
+    <h3>Methodology</h3>
+    ${table(["Field", "Value"], [
+        ["Schema", section.schemaVersion],
+        ["File F1", methodology.fileF1],
+        ["Symbol F1", methodology.symbolF1],
+        ["Aggregation", methodology.aggregation],
+        ["Multi-objective comparison", methodology.multiObjectiveComparison],
+        ["Unique-best rule", methodology.uniqueBestRule],
+        ["Strategy order", section.strategyOrder.join(", ")]
+    ])}
+    ${section.identityRedaction !== null ? `<p><strong>Identity redaction.</strong> ${escapeHtml(RETRIEVAL_QUERY_STRATEGY_EXTERNAL_PRIVACY_NOTE)}</p>` : ""}
+    <h3>Task-Type Comparison</h3>
+    ${table(["Scope", "Cases", "Matched Cases", "Excluded Cases", "Interpretation", "Best Strategy", "Pareto Front"], section.scopes.map((scope) => [
+        scope.scopeId,
+        String(scope.caseCount),
+        String(scope.comparisonCaseCount),
+        String(scope.excludedCaseCount),
+        scope.interpretation,
+        scope.bestStrategyId ?? "none",
+        formatRetrievalQueryStrategyList(scope.paretoFrontStrategyIds)
+    ]))}
+    ${listHtml(section.scopes.map(describeRetrievalQueryStrategyScope))}
+    <h3>Per-Scope Strategy Objectives</h3>
+    ${section.scopes
+        .map((scope) => `<h4>${escapeHtml(scope.scopeId)}</h4>
+    ${table(["Strategy", "Completed", "Partial", "Failed", "Mean File F1", "Mean Symbol F1", "Mean Fact Coverage", "Mean Retrieved Tokens"], scope.strategySummaries.map((summary) => [
+        summary.strategyId,
+        String(summary.completedCaseCount),
+        String(summary.partialCaseCount),
+        String(summary.failedCaseCount),
+        objective(summary.objectives?.meanFileF1, true),
+        objective(summary.objectives?.meanSymbolF1, true),
+        objective(summary.objectives?.meanFactCoverage, true),
+        objective(summary.objectives?.meanRetrievedTokenCount, false)
+    ]))}`)
+        .join("\n    ")}
+    <h3>Per-Case Treatments</h3>
+    ${table([
+        "Case",
+        "Task Type",
+        "Strategy",
+        "Status",
+        "Evidence",
+        "File Precision",
+        "File Recall",
+        "File F1",
+        "Symbol Precision",
+        "Symbol Recall",
+        "Symbol F1",
+        "Fact Coverage",
+        "Irrelevant Context Ratio",
+        "Retrieved Tokens"
+    ], section.cases.flatMap((entry) => entry.treatments.map((treatment) => [
+        entry.caseId,
+        entry.taskLocality ?? "unavailable",
+        treatment.strategyId,
+        treatment.executionStatus,
+        treatment.evidenceAvailability ?? "unavailable",
+        formatRetrievalQueryStrategyMetric(treatment.filePrecision),
+        formatRetrievalQueryStrategyMetric(treatment.fileRecall),
+        formatRetrievalQueryStrategyMetric(treatment.fileF1),
+        formatRetrievalQueryStrategyMetric(treatment.symbolPrecision),
+        formatRetrievalQueryStrategyMetric(treatment.symbolRecall),
+        formatRetrievalQueryStrategyMetric(treatment.symbolF1),
+        formatRetrievalQueryStrategyMetric(treatment.factCoverage),
+        formatRetrievalQueryStrategyMetric(treatment.irrelevantContextRatio),
+        formatRetrievalQueryStrategyNumber(treatment.retrievedTokenCount)
+    ])))}
+    <h3>Interpretation Limits</h3>
+    ${listHtml(section.limitations)}
+  </section>`;
+}
+function listHtml(items) {
+    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/renderRetrievalQueryStrategyComparisonText.js

@@ -0,0 +1,58 @@
+export const RETRIEVAL_QUERY_STRATEGY_EXTERNAL_PRIVACY_NOTE = "External-local report: private file, symbol, fact, semantic-node, warning, and case-title identities are withheld; numeric scientific results and strategy interpretations are preserved.";
+/** Available values keep four decimals; unavailable/not-applicable are never shown as zero. */
+export function formatRetrievalQueryStrategyMetric(metric) {
+    if (metric.availability === "available" && metric.value !== null)
+        return metric.value.toFixed(4);
+    return `${metric.availability}${metric.reason ? ` (${metric.reason})` : ""}`;
+}
+export const formatRetrievalQueryStrategyNumber = (value) => (value === null ? "unavailable" : String(value));
+const formatMean = (value) => (value === undefined ? "unavailable" : value.toFixed(4));
+const formatTokenMean = (value) => (value === undefined ? "unavailable" : String(value));
+export const formatRetrievalQueryStrategyList = (items) => (items.length === 0 ? "none" : items.join(", "));
+/** One human sentence per scope: a best strategy only for a single-member front; otherwise an explicit tradeoff. */
+export function describeRetrievalQueryStrategyScope(scope) {
+    if (scope.interpretation === "unique-best") {
+        return `${scope.scopeId}: unique-best ${scope.bestStrategyId} (single-member Pareto front).`;
+    }
+    if (scope.interpretation === "tradeoff") {
+        return `${scope.scopeId}: No Single Best strategy; Pareto front (nondominated, not ranked): ${formatRetrievalQueryStrategyList(scope.paretoFrontStrategyIds)}.`;
+    }
+    return `${scope.scopeId}: unavailable; no matched complete-case comparison.`;
+}
+export function renderRetrievalQueryStrategyComparisonTextLines(section) {
+    const lines = [];
+    const methodology = section.methodology;
+    lines.push(`Schema: ${section.schemaVersion}`);
+    lines.push(`File F1: ${methodology.fileF1}`);
+    lines.push(`Symbol F1: ${methodology.symbolF1}`);
+    lines.push(`Aggregation: ${methodology.aggregation}`);
+    lines.push(`Multi-objective comparison: ${methodology.multiObjectiveComparison}`);
+    lines.push(`Unique-best rule: ${methodology.uniqueBestRule}`);
+    lines.push(`Strategy order: ${section.strategyOrder.join(", ")}`);
+    if (section.identityRedaction !== null)
+        lines.push(RETRIEVAL_QUERY_STRATEGY_EXTERNAL_PRIVACY_NOTE);
+    lines.push("", "Task-Type Comparison");
+    for (const scope of section.scopes) {
+        lines.push(`- scope=${scope.scopeId} cases=${scope.caseCount} matched=${scope.comparisonCaseCount} excluded=${scope.excludedCaseCount} interpretation=${scope.interpretation} best=${scope.bestStrategyId ?? "none"} pareto=${formatRetrievalQueryStrategyList(scope.paretoFrontStrategyIds)}`);
+    }
+    for (const scope of section.scopes)
+        lines.push(describeRetrievalQueryStrategyScope(scope));
+    lines.push("", "Per-Scope Strategy Objectives");
+    for (const scope of section.scopes) {
+        lines.push(`Scope ${scope.scopeId}:`);
+        for (const summary of scope.strategySummaries) {
+            const objectives = summary.objectives;
+            lines.push(`- ${summary.strategyId} completed=${summary.completedCaseCount} partial=${summary.partialCaseCount} failed=${summary.failedCaseCount} meanFileF1=${formatMean(objectives?.meanFileF1)} meanSymbolF1=${formatMean(objectives?.meanSymbolF1)} meanFactCoverage=${formatMean(objectives?.meanFactCoverage)} meanRetrievedTokens=${formatTokenMean(objectives?.meanRetrievedTokenCount)}`);
+        }
+    }
+    lines.push("", "Per-Case Treatments");
+    for (const entry of section.cases) {
+        for (const treatment of entry.treatments) {
+            lines.push(`- case=${entry.caseId} taskType=${entry.taskLocality ?? "unavailable"} strategy=${treatment.strategyId} status=${treatment.executionStatus} evidence=${treatment.evidenceAvailability ?? "unavailable"} filePrecision=${formatRetrievalQueryStrategyMetric(treatment.filePrecision)} fileRecall=${formatRetrievalQueryStrategyMetric(treatment.fileRecall)} fileF1=${formatRetrievalQueryStrategyMetric(treatment.fileF1)} symbolPrecision=${formatRetrievalQueryStrategyMetric(treatment.symbolPrecision)} symbolRecall=${formatRetrievalQueryStrategyMetric(treatment.symbolRecall)} symbolF1=${formatRetrievalQueryStrategyMetric(treatment.symbolF1)} factCoverage=${formatRetrievalQueryStrategyMetric(treatment.factCoverage)} irrelevantContextRatio=${formatRetrievalQueryStrategyMetric(treatment.irrelevantContextRatio)} retrievedTokens=${formatRetrievalQueryStrategyNumber(treatment.retrievedTokenCount)}`);
+        }
+    }
+    lines.push("", "Interpretation Limits");
+    for (const limitation of section.limitations)
+        lines.push(`- ${limitation}`);
+    return lines;
+}

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

@@ -0,0 +1 @@
+export const RETRIEVAL_QUERY_STRATEGY_COMPARISON_REPORT_SCHEMA_VERSION = "my-dev-kit-lab-retrieval-query-strategy-comparison-report-v1";

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

@@ -2,6 +2,7 @@ import { mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import { resolveWithinRoot } from "../../core/pathSafety.js";
 import { buildPluginExperimentReport } from "./buildPluginExperimentReport.js";
+import { loadContextPackArtifacts } from "./loadContextPackArtifacts.js";
 import { renderPluginExperimentReportHtml } from "./renderPluginExperimentReportHtml.js";
 import { renderPluginExperimentReportText } from "./renderPluginExperimentReportText.js";
 export async function writePluginExperimentReports(args) {
@@ -22,6 +23,7 @@ export async function writePluginExperimentReports(args) {
         plugin: args.plugin,
         outputRoot: outputPaths.outDir,
         generatedAt: args.generatedAt,
+        contextPacks: await loadContextPackArtifacts(args.run, outputPaths.outDir),
     });
     const report = args.redactOutputRoot
         ? { ...builtReport, metadata: { ...builtReport.metadata, outputRoot: "[redacted]" } }