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

package/dist/src/experiments/plugins/contextPackGeneration/renderContextPack.js

@@ -0,0 +1,61 @@
+/** Stable source boundary; it cannot be confused with Markdown code-fence nesting. */
+export const CONTEXT_PACK_SOURCE_BEGIN = "<<<SOURCE";
+export const CONTEXT_PACK_SOURCE_END = "SOURCE>>>";
+export const CONTEXT_PACK_SECTION_HEADINGS = {
+    task: "## Task",
+    files: "## Relevant files",
+    symbols: "## Relevant symbols",
+    sourceSlices: "## Source slices",
+    callRelationships: "## Call relationships",
+    tests: "## Tests",
+    evidenceNotes: "## Evidence notes"
+};
+const lf = (text) => text.replace(/\r\n?/g, "\n");
+function renderBody(id, lines, availability) {
+    const heading = CONTEXT_PACK_SECTION_HEADINGS[id];
+    if (lines.length > 0)
+        return [heading, ...lines].join("\n");
+    const { availability: state, reason } = availability[id];
+    const suffix = reason === null ? "" : `: ${reason}`;
+    const placeholder = state === "available" ? "(none)" : `(${state}${suffix})`;
+    return `${heading}\n${placeholder}`;
+}
+function renderSlice(slice) {
+    return [
+        `file: ${slice.file}`,
+        `lines: ${slice.startLine}-${slice.endLine}`,
+        `boundary: ${slice.boundaryKnown ? "known" : "unknown"}`,
+        `truncated: ${slice.truncated ? "yes" : "no"}`,
+        CONTEXT_PACK_SOURCE_BEGIN,
+        lf(slice.text),
+        CONTEXT_PACK_SOURCE_END
+    ].join("\n");
+}
+/** Deterministic, language-agnostic rendering. Source text is verbatim apart from line-ending normalization. */
+export function renderContextPack(input) {
+    const availability = input.sectionAvailability;
+    const sections = {
+        task: `${CONTEXT_PACK_SECTION_HEADINGS.task}\nTitle: ${lf(input.task.title)}\nSummary: ${lf(input.task.summary)}`,
+        files: renderBody("files", input.files.map((file) => `- ${file.path}`), availability),
+        symbols: renderBody("symbols", input.symbols.map((symbol) => (symbol.file === null ? `- ${symbol.name}` : `- ${symbol.name} (${symbol.file})`)), availability),
+        sourceSlices: renderSourceSlices(input.sourceSlices, availability),
+        callRelationships: renderBody("callRelationships", input.callRelationships.map((call) => `${call.fromNodeId} -> ${call.toNodeId}`), availability),
+        tests: renderBody("tests", input.tests.map((test) => `- ${test.path}`), availability),
+        evidenceNotes: renderBody("evidenceNotes", input.evidenceNotes.map((code) => `- ${code}`), availability)
+    };
+    const renderedText = `${[
+        sections.task,
+        sections.files,
+        sections.symbols,
+        sections.sourceSlices,
+        sections.callRelationships,
+        sections.tests,
+        sections.evidenceNotes
+    ].join("\n\n")}\n`;
+    return { sections, renderedText };
+}
+function renderSourceSlices(slices, availability) {
+    if (slices.length === 0)
+        return renderBody("sourceSlices", [], availability);
+    return `${CONTEXT_PACK_SECTION_HEADINGS.sourceSlices}\n${slices.map(renderSlice).join("\n\n")}`;
+}

package/dist/src/experiments/plugins/contextPackGeneration/types.js

@@ -0,0 +1,29 @@
+/** Domain schema of the Lab-owned experimental context pack. It is a measurement artifact, not a production contract. */
+export const CONTEXT_PACK_SCHEMA_VERSION = "my-dev-kit-lab-context-pack-experiment-v1";
+/** Logical section order of the pack. */
+export const CONTEXT_PACK_SECTION_IDS = [
+    "task",
+    "files",
+    "symbols",
+    "sourceSlices",
+    "callRelationships",
+    "tests",
+    "evidenceNotes"
+];
+/**
+ * Closed fixed vocabulary. Only codes produced by the pure Batch 1 domain exist; no free-form warning text, and no
+ * execution, indexing, privacy or persistence failure codes.
+ */
+export const CONTEXT_PACK_EVIDENCE_NOTE_CODES = [
+    "symbol-end-unknown",
+    "source-slice-cap-reached",
+    "total-source-line-cap-reached",
+    "source-slice-count-cap-reached",
+    "seed-cap-reached",
+    "file-cap-reached",
+    "symbol-cap-reached",
+    "test-file-cap-reached",
+    "call-relationship-cap-reached",
+    "invalid-repository-path-ignored",
+    "invalid-source-slice-ignored"
+];

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

@@ -0,0 +1,171 @@
+import path from "node:path";
+import { CONTEXT_PACK_GENERATION_METHODOLOGY } from "../../experiments/plugins/contextPackGeneration/analysisArtifact.js";
+import { CONTEXT_PACK_GENERATION_PLUGIN_ID, CONTEXT_PACK_GENERATION_TREATMENT_IDS } from "../../experiments/plugins/contextPackGeneration/metadata.js";
+import { CONTEXT_PACK_GENERATION_REPORT_SCHEMA_VERSION, PACK_PREVIEW_MAX_CALL_RELATIONSHIPS, PACK_PREVIEW_MAX_EVIDENCE_NOTES, PACK_PREVIEW_MAX_FILES, PACK_PREVIEW_MAX_SOURCE_LINES_PER_SLICE, PACK_PREVIEW_MAX_SOURCE_SLICES, PACK_PREVIEW_MAX_SYMBOLS, PACK_PREVIEW_MAX_TESTS } from "./contextPackGenerationReportModel.js";
+/** Fixed wording: observed evidence only. */
+export const CONTEXT_PACK_GENERATION_LIMITATIONS = [
+    "This is a context-pack experiment over deterministic my-dev-kit workflows; it is not a coding-agent success evaluation.",
+    "Estimated tokens come from the existing Lab estimator over rendered text, not provider billing telemetry.",
+    "Unavailable and not-applicable values are not converted to zero.",
+    "Scope means use matched complete cases only and are unweighted macro means over task instances.",
+    "No composite score, ranking, or winning treatment is produced; treatments are reported side by side.",
+    "Tests and call relationships in the pack are descriptive and are not scored.",
+    "The context pack is an experimental Lab artifact, not the production my-dev-kit context API.",
+    "The pack preview is bounded for display only and does not change the stored pack or any measured size."
+];
+const copyMetric = (metric) => ({
+    availability: metric.availability,
+    numerator: metric.numerator,
+    denominator: metric.denominator,
+    value: metric.value,
+    reason: metric.reason
+});
+const NO_MEASUREMENT = { availability: "unavailable", numerator: null, denominator: null, value: null, reason: "no-retrieval-measurement" };
+function bounded(source, limit, project) {
+    return { items: source.slice(0, limit).map(project), totalCount: source.length, omittedCount: Math.max(0, source.length - limit) };
+}
+/** Display truncation of a stored slice: first lines only. The pack's own `truncated` flag is copied untouched. */
+function previewSlice(slice) {
+    const lines = slice.text.split("\n");
+    const shown = lines.slice(0, PACK_PREVIEW_MAX_SOURCE_LINES_PER_SLICE);
+    return {
+        file: slice.file,
+        symbolName: slice.symbolName,
+        startLine: slice.startLine,
+        endLine: slice.endLine,
+        lineCount: slice.lineCount,
+        boundaryKnown: slice.boundaryKnown,
+        truncated: slice.truncated,
+        previewText: shown.join("\n"),
+        previewLineCount: shown.length,
+        previewTruncated: lines.length > shown.length
+    };
+}
+/** External-local evidence carries a redaction marker and no pack body; the preview is counts and availability only. */
+function buildRedactedPreview(entry, redaction) {
+    const packTreatment = entry.treatments.find((treatment) => treatment.treatmentId === "context-pack");
+    return {
+        caseId: entry.caseId,
+        status: "redacted-external-local",
+        packArtifactPath: null,
+        packAvailability: packTreatment?.availability ?? null,
+        sections: (packTreatment?.sections ?? []).map((section) => ({
+            id: section.id,
+            availability: section.availability,
+            reason: section.reason,
+            itemCount: section.itemCount,
+            estimatedTokens: section.estimatedTokens,
+            truncatedCount: section.truncatedCount ?? null
+        })),
+        task: null,
+        files: null,
+        symbols: null,
+        sourceSlices: null,
+        callRelationships: null,
+        tests: null,
+        evidenceNotes: null,
+        redaction: { ...redaction }
+    };
+}
+function buildPreview(entry, pack) {
+    if (entry.identityRedaction)
+        return buildRedactedPreview(entry, entry.identityRedaction);
+    const packTreatment = entry.treatments.find((treatment) => treatment.treatmentId === "context-pack");
+    const packArtifactPath = packTreatment?.packArtifactPath ?? null;
+    const base = {
+        caseId: entry.caseId,
+        packArtifactPath,
+        // Section summaries are persisted execution evidence; they never come from the preview truncation.
+        sections: (packTreatment?.sections ?? []).map((section) => ({
+            id: section.id,
+            availability: section.availability,
+            reason: section.reason,
+            itemCount: section.itemCount,
+            estimatedTokens: section.estimatedTokens
+        }))
+    };
+    if (!pack) {
+        return {
+            ...base,
+            status: packArtifactPath === null ? "no-pack-produced" : "pack-artifact-unavailable",
+            packAvailability: packTreatment?.availability ?? null,
+            task: null,
+            files: null,
+            symbols: null,
+            sourceSlices: null,
+            callRelationships: null,
+            tests: null,
+            evidenceNotes: null
+        };
+    }
+    return {
+        ...base,
+        status: "available",
+        packAvailability: pack.availability,
+        task: { title: pack.task.title, summary: pack.task.summary },
+        files: bounded(pack.files, PACK_PREVIEW_MAX_FILES, (file) => ({ path: file.path, rank: file.rank, reason: file.reason })),
+        symbols: bounded(pack.symbols, PACK_PREVIEW_MAX_SYMBOLS, (symbol) => ({ name: symbol.name, file: symbol.file, line: symbol.line, nodeId: symbol.nodeId })),
+        sourceSlices: bounded(pack.sourceSlices, PACK_PREVIEW_MAX_SOURCE_SLICES, previewSlice),
+        callRelationships: bounded(pack.callRelationships.filter((relationship) => relationship.kind === "calls"), PACK_PREVIEW_MAX_CALL_RELATIONSHIPS, (relationship) => ({ fromNodeId: relationship.fromNodeId, toNodeId: relationship.toNodeId })),
+        tests: bounded(pack.tests, PACK_PREVIEW_MAX_TESTS, (test) => ({ path: test.path, how: test.how })),
+        evidenceNotes: bounded(pack.evidenceNotes, PACK_PREVIEW_MAX_EVIDENCE_NOTES, (code) => code)
+    };
+}
+/**
+ * Presentation-only adapter over the already-calculated `run.analysis` and `run.caseExecutionEvidence`. It recalculates no
+ * F1, fact coverage, token size, saving, matched-case membership, mean or delta; it copies persisted values. `contextPacks`
+ * are the persisted per-case pack artifacts, loaded by the caller; only display truncation is derived from them.
+ */
+export function buildContextPackGenerationReport(run, contextPacks = new Map()) {
+    if (run.pluginId !== CONTEXT_PACK_GENERATION_PLUGIN_ID)
+        return null;
+    const candidate = run;
+    const analysis = candidate.analysis;
+    const execution = candidate.caseExecutionEvidence;
+    if (!analysis || !execution) {
+        // A run that failed before analysis exists still gets the generic failure report.
+        if (run.status === "failed")
+            return null;
+        throw new Error("Invalid context-pack-generation report source: execution evidence and analysis are required.");
+    }
+    const inconsistent = analysis.cases.length !== execution.length ||
+        analysis.cases.some((entry, index) => entry.caseId !== execution[index].caseId ||
+            entry.treatments.length !== CONTEXT_PACK_GENERATION_TREATMENT_IDS.length ||
+            entry.treatments.some((treatment, position) => treatment.treatmentId !== CONTEXT_PACK_GENERATION_TREATMENT_IDS[position]));
+    if (inconsistent) {
+        throw new Error("Invalid context-pack-generation report source: execution evidence and analysis are inconsistent.");
+    }
+    const cases = analysis.cases.map((entry, caseIndex) => ({
+        caseId: entry.caseId,
+        caseName: execution[caseIndex].caseName,
+        benchmarkProject: entry.benchmarkProject,
+        taskLocality: entry.taskLocality,
+        treatments: entry.treatments.map((treatment) => ({
+            treatmentId: treatment.treatmentId,
+            executionStatus: treatment.executionStatus,
+            availability: treatment.availability,
+            fileF1: copyMetric(treatment.fileF1),
+            symbolF1: copyMetric(treatment.symbolF1),
+            factCoverage: treatment.quality ? copyMetric(treatment.quality.fact.coverage) : { ...NO_MEASUREMENT },
+            estimatedTokens: treatment.estimatedTokens,
+            tokenCountMethod: treatment.tokenCountMethod
+        })),
+        comparison: { ...entry.comparison }
+    }));
+    return {
+        schemaVersion: CONTEXT_PACK_GENERATION_REPORT_SCHEMA_VERSION,
+        experiment: { pluginId: run.pluginId, target: run.target.isSelf ? "self" : "external target" },
+        treatmentOrder: [...CONTEXT_PACK_GENERATION_TREATMENT_IDS],
+        methodology: { ...CONTEXT_PACK_GENERATION_METHODOLOGY },
+        cases,
+        scopes: structuredClone(analysis.scopes),
+        previews: execution.map((entry) => buildPreview(entry, contextPacks.get(entry.caseId))),
+        // Execution/analysis artifacts live directly in the output root; never expose a machine-local absolute path.
+        artifacts: run.artifacts.map((artifact) => ({
+            id: artifact.id,
+            path: artifact.path ? (path.isAbsolute(artifact.path) ? path.basename(artifact.path) : artifact.path) : null,
+            caseId: artifact.caseId ?? null
+        })),
+        limitations: [...CONTEXT_PACK_GENERATION_LIMITATIONS]
+    };
+}

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

@@ -5,6 +5,7 @@ import { buildIncrementalChangeStalenessPluginReport } from "./buildIncrementalC
 import { buildContextWindowScalingReport } from "./buildContextWindowScalingReport.js";
 import { buildRetrievalPrecisionRecallReport } from "./buildRetrievalPrecisionRecallReport.js";
 import { buildRetrievalQueryStrategyComparisonReport } from "./buildRetrievalQueryStrategyComparisonReport.js";
+import { buildContextPackGenerationReport } from "./buildContextPackGenerationReport.js";
 // Bulk context-window-scaling evidence is presented by the typed report section; the complete
 // evidence stays in context-window-scaling-execution.json.
 const CONTEXT_WINDOW_SCALING_BULK_KEYS = ["executionEvidence", "aggregate"];
@@ -12,6 +13,8 @@ const CONTEXT_WINDOW_SCALING_BULK_KEYS = ["executionEvidence", "aggregate"];
 const RETRIEVAL_PRECISION_RECALL_BULK_KEYS = ["caseExecutionEvidence", "aggregate"];
 // Same for retrieval-query-strategy-comparison: the typed section presents execution evidence and analysis.
 const RETRIEVAL_QUERY_STRATEGY_COMPARISON_BULK_KEYS = ["caseExecutionEvidence", "analysis"];
+// Same for context-pack-generation: the typed section presents execution evidence and analysis.
+const CONTEXT_PACK_GENERATION_BULK_KEYS = ["caseExecutionEvidence", "analysis"];
 const V043_BULK_ARRAY_KEYS = [
     "v043StageContextExecutions",
     "v043StageContextEvaluations",
@@ -26,6 +29,7 @@ export function buildPluginExperimentReport(args) {
     const contextWindowScaling = buildContextWindowScalingReport(args.run);
     const retrievalPrecisionRecall = buildRetrievalPrecisionRecallReport(args.run);
     const retrievalQueryStrategyComparison = buildRetrievalQueryStrategyComparisonReport(args.run);
+    const contextPackGeneration = buildContextPackGenerationReport(args.run, args.contextPacks);
     const rawRun = { ...args.run, artifacts: relativizeArtifacts(args.run.artifacts, outputRoot) };
     for (const key of V043_BULK_ARRAY_KEYS) {
         delete rawRun[key];
@@ -45,6 +49,11 @@ export function buildPluginExperimentReport(args) {
             delete rawRun[key];
         }
     }
+    if (contextPackGeneration) {
+        for (const key of CONTEXT_PACK_GENERATION_BULK_KEYS) {
+            delete rawRun[key];
+        }
+    }
     return {
         metadata: {
             generatedAt: args.generatedAt ?? new Date().toISOString(),
@@ -73,8 +82,9 @@ export function buildPluginExperimentReport(args) {
         contextWindowScaling,
         retrievalPrecisionRecall,
         retrievalQueryStrategyComparison,
+        contextPackGeneration,
         contextStrategyComparisonV043,
-        interpretation: buildInterpretation(args.run, contextStrategyComparisonV043, warmIndexReuse, contextWindowScaling, retrievalPrecisionRecall, retrievalQueryStrategyComparison),
+        interpretation: buildInterpretation(args.run, contextStrategyComparisonV043, warmIndexReuse, contextWindowScaling, retrievalPrecisionRecall, retrievalQueryStrategyComparison, contextPackGeneration),
         rawRun,
     };
 }
@@ -153,7 +163,19 @@ function affectedNeighborhoodSentence(report) {
         `reindex recommendations were recommended=${summary.recommendedReindexCount}, not-indicated=${summary.notIndicatedReindexCount}, unknown=${summary.unknownReindexRecommendationCount}. ` +
         "Affected-neighborhood evidence uses a one-hop baseline graph around confirmed changed indexed files/symbols. It is observational and does not alter retrieval or execution status.");
 }
-function buildInterpretation(run, contextStrategyComparisonV043, warmIndexReuse, contextWindowScaling, retrievalPrecisionRecall, retrievalQueryStrategyComparison) {
+function buildInterpretation(run, contextStrategyComparisonV043, warmIndexReuse, contextWindowScaling, retrievalPrecisionRecall, retrievalQueryStrategyComparison, contextPackGeneration = null) {
+    if (contextPackGeneration) {
+        const overall = contextPackGeneration.scopes.find((scope) => scope.scopeId === "overall");
+        const saved = overall?.tokenSavings;
+        const deltas = overall?.pairedDeltas;
+        const summary = overall && saved && deltas
+            ? `Overall matched comparison over ${overall.includedCaseCount} of ${overall.caseCount} case(s): the context pack used a mean of ${saved.meanTokensSaved} fewer estimated tokens than raw full-file context (${saved.percentSavedOfMeans}% of the raw mean; a negative value means more tokens); mean fact coverage delta ${deltas.meanFactCoverageDelta}, mean file F1 delta ${deltas.meanFileF1Delta}, mean symbol F1 delta ${deltas.meanSymbolF1Delta}. The treatments are reported side by side without a composite score.`
+            : "No matched complete-case context-pack comparison was available for the overall scope. Review treatment availability and excluded cases before drawing conclusions.";
+        return {
+            summary,
+            recommendedNextStep: "Review per-case coverage and size, the scope aggregates, and the bounded pack preview; unavailable values are never treated as zero."
+        };
+    }
     if (retrievalQueryStrategyComparison) {
         const overall = retrievalQueryStrategyComparison.scopes.find((scope) => scope.scopeId === "overall");
         const taskTypes = "Task-type results are reported separately for localized, cross-module, and broad-change cases.";

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

@@ -0,0 +1,9 @@
+export const CONTEXT_PACK_GENERATION_REPORT_SCHEMA_VERSION = "my-dev-kit-lab-context-pack-generation-report-v1";
+/** Report-presentation limits only. They never change the experimental pack limits and are not CLI configuration. */
+export const PACK_PREVIEW_MAX_FILES = 5;
+export const PACK_PREVIEW_MAX_SYMBOLS = 5;
+export const PACK_PREVIEW_MAX_SOURCE_SLICES = 3;
+export const PACK_PREVIEW_MAX_SOURCE_LINES_PER_SLICE = 12;
+export const PACK_PREVIEW_MAX_CALL_RELATIONSHIPS = 5;
+export const PACK_PREVIEW_MAX_TESTS = 5;
+export const PACK_PREVIEW_MAX_EVIDENCE_NOTES = 5;

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

@@ -28,6 +28,11 @@ 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";

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

@@ -4,6 +4,7 @@ import { renderIncrementalChangeStalenessHtml } from "./renderIncrementalChangeS
 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>
@@ -112,6 +113,8 @@ export function renderPluginExperimentReportHtml(report) {
 
   ${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) => [