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

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

@@ -0,0 +1,305 @@
+import { compareCodeUnits } from "../../../evaluation/indexSnapshot.js";
+import { normalizeRetrievedRepositoryPath } from "../../../evaluation/retrievalQuality/buildRetrievalEvidence.js";
+/** Frozen v0.8.2 selection policy. These are experimental constants, never user configuration; do not tune them. */
+export const CONTEXT_PACK_SELECTION_POLICY_ID = "bounded-multiseed-v1";
+export const SEARCH_RESULT_LIMIT = 12;
+export const MAX_SEED_NODES = 8;
+export const GRAPH_DEPTH = 1;
+export const MAX_FILES = 12;
+export const MAX_SYMBOLS = 16;
+export const MAX_SOURCE_SLICES = 8;
+export const MAX_SOURCE_LINES_PER_SLICE = 160;
+export const MAX_TOTAL_SOURCE_LINES = 1280;
+export const MAX_TEST_FILES = 8;
+export const MAX_CALL_RELATIONSHIPS = 32;
+export function buildContextPackSelectionPolicy(myDevKitVersion) {
+    return {
+        id: CONTEXT_PACK_SELECTION_POLICY_ID,
+        searchResultLimit: SEARCH_RESULT_LIMIT,
+        maxSeedNodes: MAX_SEED_NODES,
+        graphDepth: GRAPH_DEPTH,
+        maxFiles: MAX_FILES,
+        maxSymbols: MAX_SYMBOLS,
+        maxSourceSlices: MAX_SOURCE_SLICES,
+        maxSourceLinesPerSlice: MAX_SOURCE_LINES_PER_SLICE,
+        maxTotalSourceLines: MAX_TOTAL_SOURCE_LINES,
+        maxTestFiles: MAX_TEST_FILES,
+        maxCallRelationships: MAX_CALL_RELATIONSHIPS,
+        myDevKitVersion
+    };
+}
+const ORIGIN_PRIORITY = { search: 0, lookup: 1, graph: 2 };
+const ORIGIN_COMMAND = {
+    search: "search",
+    lookup: "lookup",
+    graph: "slice"
+};
+const FILE_REASON = {
+    search: "search-candidate",
+    lookup: "lookup-evidence",
+    graph: "graph-neighbor"
+};
+const compareNullableRank = (left, right) => left === right ? 0 : left === null ? 1 : right === null ? -1 : left - right;
+const compareNullableText = (left, right) => compareCodeUnits(left ?? "", right ?? "");
+const provenanceOf = (origin, nodeId, rank) => ({
+    command: ORIGIN_COMMAND[origin],
+    nodeId,
+    rank
+});
+function mergeProvenance(entries) {
+    const unique = new Map();
+    for (const entry of entries)
+        unique.set(`${entry.command}\0${entry.nodeId ?? ""}\0${entry.rank ?? ""}`, entry);
+    return [...unique.values()].sort((a, b) => compareCodeUnits(a.command, b.command) || compareNullableText(a.nodeId, b.nodeId) || compareNullableRank(a.rank, b.rank));
+}
+function uniqueSortedNotes(notes) {
+    return [...new Set(notes)].sort(compareCodeUnits);
+}
+/** Pure repository test-file classification: tests/, test/, __tests__/ directories and *.test.* / *.spec.* files. */
+export function isTestFilePath(path) {
+    const segments = path.split("/");
+    const directories = segments.slice(0, -1);
+    if (directories.some((segment) => segment === "tests" || segment === "test" || segment === "__tests__"))
+        return true;
+    return /\.(test|spec)\.[^/.]+$/.test(segments[segments.length - 1] ?? "");
+}
+/** Direct search evidence, then lookup, then depth-1 graph; lower rank first; code-unit ties. Deduplicated before the cap. */
+export function selectSeedNodes(candidates) {
+    const best = new Map();
+    for (const candidate of candidates) {
+        const current = best.get(candidate.nodeId);
+        if (!current || compareSeeds(candidate, current) < 0)
+            best.set(candidate.nodeId, { ...candidate });
+    }
+    const ordered = [...best.values()].sort(compareSeeds);
+    const items = ordered.slice(0, MAX_SEED_NODES);
+    return { items, notes: ordered.length > MAX_SEED_NODES ? ["seed-cap-reached"] : [] };
+}
+function compareSeeds(a, b) {
+    return ORIGIN_PRIORITY[a.origin] - ORIGIN_PRIORITY[b.origin] || a.rank - b.rank || compareCodeUnits(a.nodeId, b.nodeId);
+}
+export function selectRelevantFiles(candidates) {
+    const notes = [];
+    const byPath = new Map();
+    for (const candidate of candidates) {
+        const path = normalizeRetrievedRepositoryPath(candidate.path);
+        if (path === null) {
+            notes.push("invalid-repository-path-ignored");
+            continue;
+        }
+        const entry = byPath.get(path);
+        const provenance = provenanceOf(candidate.origin, null, candidate.rank);
+        const normalized = { ...candidate, path };
+        if (!entry)
+            byPath.set(path, { best: normalized, provenance: [provenance] });
+        else {
+            entry.provenance.push(provenance);
+            if (compareEvidence(normalized, entry.best) < 0)
+                entry.best = normalized;
+        }
+    }
+    const ordered = [...byPath.values()].sort((a, b) => compareEvidence(a.best, b.best) || compareCodeUnits(a.best.path, b.best.path));
+    if (ordered.length > MAX_FILES)
+        notes.push("file-cap-reached");
+    return {
+        items: ordered.slice(0, MAX_FILES).map(({ best, provenance }) => ({
+            path: best.path,
+            rank: best.rank,
+            reason: isTestFilePath(best.path) ? "test-candidate" : FILE_REASON[best.origin],
+            provenance: mergeProvenance(provenance)
+        })),
+        notes: uniqueSortedNotes(notes)
+    };
+}
+function compareEvidence(a, b) {
+    return ORIGIN_PRIORITY[a.origin] - ORIGIN_PRIORITY[b.origin] || a.rank - b.rank;
+}
+export function selectRelevantSymbols(candidates) {
+    const notes = [];
+    const byKey = new Map();
+    for (const candidate of candidates) {
+        let file = null;
+        if (candidate.file !== null) {
+            file = normalizeRetrievedRepositoryPath(candidate.file);
+            if (file === null) {
+                notes.push("invalid-repository-path-ignored");
+                continue;
+            }
+        }
+        const key = candidate.nodeId !== null ? `n\0${candidate.nodeId}` : `f\0${file ?? ""}\0${candidate.name}`;
+        const normalized = { ...candidate, file };
+        const provenance = provenanceOf(candidate.origin, candidate.nodeId, candidate.rank);
+        const entry = byKey.get(key);
+        if (!entry)
+            byKey.set(key, { best: normalized, provenance: [provenance] });
+        else {
+            entry.provenance.push(provenance);
+            if (compareEvidence(normalized, entry.best) < 0)
+                entry.best = normalized;
+        }
+    }
+    const ordered = [...byKey.values()].sort((a, b) => compareEvidence(a.best, b.best) ||
+        compareNullableText(a.best.file, b.best.file) ||
+        compareCodeUnits(a.best.name, b.best.name) ||
+        compareNullableText(a.best.nodeId, b.best.nodeId));
+    if (ordered.length > MAX_SYMBOLS)
+        notes.push("symbol-cap-reached");
+    return {
+        items: ordered.slice(0, MAX_SYMBOLS).map(({ best, provenance }) => ({
+            name: best.name,
+            nodeId: best.nodeId,
+            file: best.file,
+            rank: best.rank,
+            line: best.line ?? null,
+            provenance: mergeProvenance(provenance)
+        })),
+        notes: uniqueSortedNotes(notes)
+    };
+}
+/** Only `calls` edges qualify; `defines`, `exports` and every other kind are ignored. Canonical order: from, then to. */
+export function selectCallRelationships(candidates) {
+    const unique = new Map();
+    for (const candidate of candidates) {
+        if (candidate.kind !== "calls")
+            continue;
+        unique.set(`${candidate.fromNodeId}\0${candidate.toNodeId}`, {
+            fromNodeId: candidate.fromNodeId,
+            toNodeId: candidate.toNodeId,
+            kind: "calls",
+            provenance: [{ command: "slice", nodeId: candidate.fromNodeId, rank: null }]
+        });
+    }
+    const ordered = [...unique.values()].sort((a, b) => compareCodeUnits(a.fromNodeId, b.fromNodeId) || compareCodeUnits(a.toNodeId, b.toNodeId));
+    return {
+        items: ordered.slice(0, MAX_CALL_RELATIONSHIPS),
+        notes: ordered.length > MAX_CALL_RELATIONSHIPS ? ["call-relationship-cap-reached"] : []
+    };
+}
+const TEST_ORIGIN_PRIORITY = { "search-candidate": 0, "graph-neighbor": 1 };
+/** Descriptive test evidence only; non-test paths are ignored. No coverage score exists. */
+export function selectTestFiles(candidates) {
+    const notes = [];
+    const byPath = new Map();
+    const compare = (a, b) => TEST_ORIGIN_PRIORITY[a.origin] - TEST_ORIGIN_PRIORITY[b.origin] || compareNullableRank(a.rank, b.rank);
+    for (const candidate of candidates) {
+        const path = normalizeRetrievedRepositoryPath(candidate.path);
+        if (path === null) {
+            notes.push("invalid-repository-path-ignored");
+            continue;
+        }
+        if (!isTestFilePath(path))
+            continue;
+        const rank = candidate.rank ?? null;
+        const provenance = { command: candidate.origin === "search-candidate" ? "search" : "slice", nodeId: null, rank };
+        const normalized = { path, origin: candidate.origin, rank };
+        const entry = byPath.get(path);
+        if (!entry)
+            byPath.set(path, { best: normalized, provenance: [provenance] });
+        else {
+            entry.provenance.push(provenance);
+            if (compare(normalized, entry.best) < 0)
+                entry.best = normalized;
+        }
+    }
+    const ordered = [...byPath.values()].sort((a, b) => compare(a.best, b.best) || compareCodeUnits(a.best.path, b.best.path));
+    if (ordered.length > MAX_TEST_FILES)
+        notes.push("test-file-cap-reached");
+    return {
+        items: ordered.slice(0, MAX_TEST_FILES).map(({ best, provenance }) => ({
+            path: best.path,
+            rank: best.rank,
+            how: best.origin,
+            provenance: mergeProvenance(provenance)
+        })),
+        notes: uniqueSortedNotes(notes)
+    };
+}
+const normalizeLineEndings = (text) => text.replace(/\r\n?/g, "\n");
+function splitLines(text) {
+    const normalized = normalizeLineEndings(text);
+    if (normalized.length === 0)
+        return [];
+    const lines = normalized.split("\n");
+    if (lines[lines.length - 1] === "")
+        lines.pop();
+    return lines;
+}
+const FROZEN_SOURCE_SLICE_LIMITS = {
+    maxSourceSlices: MAX_SOURCE_SLICES,
+    maxSourceLinesPerSlice: MAX_SOURCE_LINES_PER_SLICE,
+    maxTotalSourceLines: MAX_TOTAL_SOURCE_LINES
+};
+/**
+ * Applies the source caps to already-captured slices; performs no source command and no continuation.
+ * Slices are consumed in (rank, file, startLine, endLine, nodeId) order. A slice longer than the per-slice cap keeps its
+ * first lines. The total cap truncates the slice that crosses it and drops every later slice; earlier slices are never
+ * reordered. The returned slices are in canonical render order: file, startLine, endLine, nodeId.
+ */
+export function selectSourceSlices(candidates, 
+/** Test seam only: with the frozen constants the slice-count cap (8 x 160 = 1280) is reached before the total cap can be crossed. */
+limits = FROZEN_SOURCE_SLICE_LIMITS) {
+    const notes = [];
+    const prepared = [];
+    for (const candidate of candidates) {
+        const file = normalizeRetrievedRepositoryPath(candidate.file);
+        if (file === null) {
+            notes.push("invalid-repository-path-ignored");
+            continue;
+        }
+        const lines = splitLines(candidate.text);
+        if (!Number.isInteger(candidate.startLine) || candidate.startLine < 1 || lines.length === 0) {
+            notes.push("invalid-source-slice-ignored");
+            continue;
+        }
+        prepared.push({ ...candidate, file, nodeId: candidate.nodeId ?? null, lines });
+    }
+    const byRange = (a, b) => compareCodeUnits(a.file, b.file) || a.startLine - b.startLine || a.lines.length - b.lines.length || compareNullableText(a.nodeId, b.nodeId);
+    prepared.sort((a, b) => a.rank - b.rank || byRange(a, b));
+    const selected = [];
+    const seen = new Set();
+    let usedLines = 0;
+    for (const candidate of prepared) {
+        const key = `${candidate.file}\0${candidate.startLine}\0${candidate.lines.length}\0${candidate.nodeId ?? ""}`;
+        if (seen.has(key))
+            continue;
+        seen.add(key);
+        if (selected.length >= limits.maxSourceSlices) {
+            notes.push("source-slice-count-cap-reached");
+            break;
+        }
+        if (usedLines >= limits.maxTotalSourceLines) {
+            notes.push("total-source-line-cap-reached");
+            break;
+        }
+        let keep = candidate.lines.length;
+        let truncated = candidate.truncated === true;
+        if (keep > limits.maxSourceLinesPerSlice) {
+            keep = limits.maxSourceLinesPerSlice;
+            truncated = true;
+            notes.push("source-slice-cap-reached");
+        }
+        if (usedLines + keep > limits.maxTotalSourceLines) {
+            keep = limits.maxTotalSourceLines - usedLines;
+            truncated = true;
+            notes.push("total-source-line-cap-reached");
+        }
+        usedLines += keep;
+        if (!candidate.boundaryKnown)
+            notes.push("symbol-end-unknown");
+        selected.push({
+            file: candidate.file,
+            nodeId: candidate.nodeId,
+            symbolName: candidate.symbolName ?? null,
+            startLine: candidate.startLine,
+            endLine: candidate.startLine + keep - 1,
+            lineCount: keep,
+            text: candidate.lines.slice(0, keep).join("\n"),
+            boundaryKnown: candidate.boundaryKnown,
+            truncated,
+            continuationAvailable: candidate.continuationAvailable === true,
+            provenance: [{ command: "source", nodeId: candidate.nodeId, rank: candidate.rank }]
+        });
+    }
+    selected.sort((a, b) => compareCodeUnits(a.file, b.file) || a.startLine - b.startLine || a.endLine - b.endLine || compareNullableText(a.nodeId, b.nodeId));
+    return { items: selected, notes: uniqueSortedNotes(notes) };
+}

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

@@ -0,0 +1,355 @@
+import { access, mkdir, rm, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveWithinRoot } from "../../../core/pathSafety.js";
+import { serializeLocalRepositorySubjectManifest } from "../../../evaluation/localRepositorySubject/index.js";
+import { summarizeExperimentRun } from "../../results.js";
+import { LocalSubjectExecutionError } from "../contextWindowScaling/localSubjectErrors.js";
+import { projectExternalLocalTarget } from "../contextWindowScaling/localSubjectPrivacy.js";
+import { isSamePhysicalDirectory } from "../contextWindowScaling/localSubjectScratch.js";
+import { selectWarmIndexCases } from "../warmIndexReuse/selection.js";
+import { analyzeContextPackGeneration } from "./analysis.js";
+import { buildContextPackGenerationAnalysisArtifact, CONTEXT_PACK_GENERATION_ANALYSIS_ARTIFACT_FILE } from "./analysisArtifact.js";
+import { contextPackGenerationConfigDefinition, defaultContextPackGenerationConfig, validateContextPackGenerationConfig } from "./config.js";
+import { executeContextPackGeneration } from "./execution.js";
+import { buildContextPackGenerationExecutionArtifact, CONTEXT_PACK_GENERATION_EXECUTION_ARTIFACT_FILE } from "./executionArtifact.js";
+import { CONTEXT_PACK_GENERATION_PLUGIN_ID, CONTEXT_PACK_GENERATION_VARIANTS, contextPackGenerationMetadata } from "./metadata.js";
+import { toContextPackGenerationCaseComparisonMetrics, toContextPackGenerationOutcomeMetrics, toContextPackGenerationRunMetrics } from "./metrics.js";
+import { executeLocalRepositorySubjectContextPackGeneration } from "./localSubjectExecution.js";
+import { assertContextPackExternalProjectionIsPrivate, collectContextPackExternalPrivateValues, CONTEXT_PACK_EXTERNAL_PERSISTENCE_FAILURE_MESSAGE, CONTEXT_PACK_PRIVACY_FAILURE_MESSAGE, CONTEXT_PACK_UNEXPECTED_EXTERNAL_FAILURE_MESSAGE, describeContextPackLocalSubjectFailureForPersistence, projectContextPackAnalysisForExternalLocalPersistence, projectContextPackExecutionForExternalLocalPersistence } from "./localSubjectPrivacy.js";
+import { contextPackArtifactRelativePath, serializeContextPackArtifact } from "./packArtifact.js";
+/** An external target must always arrive with a loaded local repository subject; the bundled corpus never runs against it. */
+export const CONTEXT_PACK_GENERATION_SELF_ONLY_MESSAGE = "External-local context-pack-generation targets require a loaded local repository subject (--local-subject-config).";
+/** Privacy-safe subject manifest persisted beside the artifacts for external-local runs (same file as the other local-subject plugins). */
+export const CONTEXT_PACK_GENERATION_LOCAL_SUBJECT_MANIFEST_FILE = "local-repository-subject-manifest.json";
+export const CONTEXT_PACK_GENERATION_PERSISTENCE_FAILURE_MESSAGE = "Context pack generation artifact persistence failed.";
+export const CONTEXT_PACK_GENERATION_ARTIFACT_STATE_MESSAGE = "Context pack generation artifact state was inconsistent; nothing was written.";
+const defaultArtifactIo = {
+    ensureDirectory: async (directory) => {
+        await mkdir(directory, { recursive: true });
+    },
+    exists: async (filePath) => {
+        try {
+            await access(filePath);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    },
+    writeFile: (filePath, content) => writeFile(filePath, content, "utf8"),
+    removeFile: (filePath) => rm(filePath, { force: true })
+};
+export const contextPackGenerationPlugin = {
+    metadata: contextPackGenerationMetadata,
+    defaultConfig: defaultContextPackGenerationConfig,
+    configDefinition: contextPackGenerationConfigDefinition,
+    supportedVariants: CONTEXT_PACK_GENERATION_VARIANTS.map((variant) => variant.id),
+    validateConfig: validateContextPackGenerationConfig,
+    async run(context) {
+        const startedAt = context.startedAt.toISOString();
+        const inputs = context.inputs;
+        const localSubject = readLocalSubjectInput(inputs);
+        if (localSubject)
+            return runLocalSubject(context, localSubject, startedAt);
+        // The runner does not enforce supportedTargets; never run the bundled corpus against another target.
+        if (context.target.kind !== "self" || context.target.isSelf !== true) {
+            throw new Error(CONTEXT_PACK_GENERATION_SELF_ONLY_MESSAGE);
+        }
+        const cases = selectWarmIndexCases(readCasesInput(inputs), context.config);
+        const outDir = context.outputRoot ?? path.resolve(context.toolRoot, context.config.outDir);
+        const io = readArtifactIo(inputs);
+        await io.ensureDirectory(outDir);
+        // 1-3. Execute every case and construct all packs in memory; nothing durable is written yet.
+        const results = await executeContextPackGeneration({
+            cases,
+            kitCommand: context.config.kitCommand,
+            outputRoot: outDir,
+            dependencies: readDependenciesInput(inputs)
+        });
+        const caseEvidence = results.map((result) => result.evidence);
+        // Scientific analysis is calculated in memory before persistence; reports later consume it, never recalculate it.
+        const analysis = analyzeContextPackGeneration(cases, caseEvidence);
+        const completedAt = new Date().toISOString();
+        // 4-6. Build and validate the complete artifact state.
+        const common = { runId: context.runId, pluginId: contextPackGenerationMetadata.id, pluginSchemaVersion: contextPackGenerationMetadata.schemaVersion, startedAt, completedAt };
+        const executionArtifact = buildContextPackGenerationExecutionArtifact({ ...common, cases: caseEvidence });
+        const analysisArtifact = buildContextPackGenerationAnalysisArtifact({ ...common, analysis });
+        const packFiles = collectPackFiles(results, outDir);
+        // 7-9. Packs in corpus order, then the execution artifact, then the analysis artifact last.
+        const executionArtifactPath = resolveWithinRoot(outDir, CONTEXT_PACK_GENERATION_EXECUTION_ARTIFACT_FILE);
+        const analysisArtifactPath = resolveWithinRoot(outDir, CONTEXT_PACK_GENERATION_ANALYSIS_ARTIFACT_FILE);
+        const created = [];
+        const write = async (filePath, content) => {
+            const existed = await io.exists(filePath);
+            await io.writeFile(filePath, content);
+            if (!existed)
+                created.push(filePath);
+        };
+        try {
+            if (packFiles.length > 0)
+                await io.ensureDirectory(resolveWithinRoot(outDir, "packs"));
+            for (const packFile of packFiles)
+                await write(packFile.absolutePath, packFile.content);
+            await write(executionArtifactPath, `${JSON.stringify(executionArtifact, null, 2)}\n`);
+            await write(analysisArtifactPath, `${JSON.stringify(analysisArtifact, null, 2)}\n`);
+        }
+        catch {
+            // Remove only files this attempt created; never touch anything else.
+            for (const filePath of created.reverse()) {
+                try {
+                    await io.removeFile(filePath);
+                }
+                catch {
+                    // best effort: the failure below is the outcome
+                }
+            }
+            throw new Error(CONTEXT_PACK_GENERATION_PERSISTENCE_FAILURE_MESSAGE);
+        }
+        return mapContextPackGenerationToRun({
+            runId: context.runId,
+            startedAt,
+            completedAt,
+            target: context.target,
+            caseEvidence,
+            analysis,
+            executionArtifactPath,
+            analysisArtifactPath,
+            packArtifactPaths: packFiles.map((packFile) => ({ caseId: packFile.caseId, path: packFile.relativePath }))
+        });
+    },
+    summarize(result) {
+        return result.summary ?? summarizeExperimentRun(result);
+    }
+};
+function readLocalSubjectInput(inputs) {
+    const value = inputs?.localSubject;
+    return value && typeof value === "object" ? value : undefined;
+}
+/**
+ * External-local path. The safe seam owns execution, immutability and scratch cleanup and either returns real in-memory
+ * results or throws. Science is calculated from the real, unprojected identities; only then is the evidence
+ * privacy-projected and asserted private. Nothing durable is written before every gate has passed, and then in this
+ * order: execution artifact, analysis artifact, manifest. No context-pack body is ever written.
+ */
+async function runLocalSubject(context, subject, startedAt) {
+    if (context.target.isSelf || context.target.kind !== "external-local") {
+        throw new Error("Local-repository subject mode requires an external-local target.");
+    }
+    if (context.config.caseIds !== undefined || context.config.benchmarkProjects !== undefined) {
+        throw new Error("Case and benchmark-project filters are not supported for an external local repository subject; the subject config owns the case set.");
+    }
+    if (!(await isSamePhysicalDirectory(context.target.targetRoot, subject.repositoryRoot))) {
+        throw new Error("The selected --target is not the repository the local subject was loaded from.");
+    }
+    const outDir = context.outputRoot;
+    if (!outDir)
+        throw new Error("Local-repository subject mode requires an experiment output directory.");
+    const io = readArtifactIo(context.inputs);
+    let local;
+    try {
+        local = await executeLocalRepositorySubjectContextPackGeneration({
+            subject,
+            kitCommand: context.config.kitCommand,
+            workRoot: outDir,
+            dependencies: readDependenciesInput(context.inputs)
+        });
+    }
+    catch (error) {
+        if (error instanceof LocalSubjectExecutionError)
+            throw new Error(describeContextPackLocalSubjectFailureForPersistence(error));
+        throw new Error(CONTEXT_PACK_UNEXPECTED_EXTERNAL_FAILURE_MESSAGE);
+    }
+    // Science first, on real identities; placeholders are never scientific identities.
+    const realEvidence = local.results.map((result) => result.evidence);
+    let analysis;
+    try {
+        analysis = analyzeContextPackGeneration(subject.evaluationCases, realEvidence);
+    }
+    catch {
+        throw new Error(CONTEXT_PACK_UNEXPECTED_EXTERNAL_FAILURE_MESSAGE);
+    }
+    let projectedExecution;
+    let projectedAnalysis;
+    try {
+        projectedExecution = projectContextPackExecutionForExternalLocalPersistence(local.results);
+        projectedAnalysis = projectContextPackAnalysisForExternalLocalPersistence(analysis);
+    }
+    catch {
+        throw new Error(CONTEXT_PACK_PRIVACY_FAILURE_MESSAGE);
+    }
+    const privateValues = collectContextPackExternalPrivateValues({ subject, results: local.results, outputRoot: outDir });
+    const manifestText = serializeLocalRepositorySubjectManifest(subject.manifest);
+    assertContextPackExternalProjectionIsPrivate(projectedExecution, privateValues);
+    assertContextPackExternalProjectionIsPrivate(projectedAnalysis, privateValues);
+    assertContextPackExternalProjectionIsPrivate(manifestText, privateValues);
+    const completedAt = new Date().toISOString();
+    const common = { runId: context.runId, pluginId: contextPackGenerationMetadata.id, pluginSchemaVersion: contextPackGenerationMetadata.schemaVersion, startedAt, completedAt };
+    const executionArtifact = buildContextPackGenerationExecutionArtifact({ ...common, cases: projectedExecution });
+    const analysisArtifact = buildContextPackGenerationAnalysisArtifact({ ...common, analysis: projectedAnalysis });
+    const executionText = `${JSON.stringify(executionArtifact, null, 2)}\n`;
+    const analysisText = `${JSON.stringify(analysisArtifact, null, 2)}\n`;
+    // The run carries only relative artifact names and the projected logical target; pack bodies never exist externally.
+    const run = mapContextPackGenerationToRun({
+        runId: context.runId,
+        startedAt,
+        completedAt,
+        target: projectExternalLocalTarget(subject.manifest),
+        caseEvidence: projectedExecution,
+        analysis: projectedAnalysis,
+        executionArtifactPath: CONTEXT_PACK_GENERATION_EXECUTION_ARTIFACT_FILE,
+        analysisArtifactPath: CONTEXT_PACK_GENERATION_ANALYSIS_ARTIFACT_FILE,
+        packArtifactPaths: []
+    });
+    run.artifacts.push({
+        id: "local-repository-subject-manifest",
+        label: "Privacy-safe local repository subject manifest",
+        path: CONTEXT_PACK_GENERATION_LOCAL_SUBJECT_MANIFEST_FILE,
+        kind: "artifact",
+        mimeType: "application/json",
+        description: "Privacy-safe logical subject, Git, safety and aggregate inventory metadata without source or private identity lists."
+    });
+    for (const payload of [executionText, analysisText, run])
+        assertContextPackExternalProjectionIsPrivate(payload, privateValues);
+    // Durable phase: execution, analysis, then the manifest last. Only files this attempt created are removed on failure.
+    const created = [];
+    const write = async (relativePath, content) => {
+        const filePath = resolveWithinRoot(outDir, relativePath);
+        const existed = await io.exists(filePath);
+        await io.writeFile(filePath, content);
+        if (!existed)
+            created.push(filePath);
+    };
+    try {
+        await io.ensureDirectory(outDir);
+        await write(CONTEXT_PACK_GENERATION_EXECUTION_ARTIFACT_FILE, executionText);
+        await write(CONTEXT_PACK_GENERATION_ANALYSIS_ARTIFACT_FILE, analysisText);
+        await write(CONTEXT_PACK_GENERATION_LOCAL_SUBJECT_MANIFEST_FILE, manifestText);
+    }
+    catch {
+        for (const filePath of created.reverse()) {
+            try {
+                await io.removeFile(filePath);
+            }
+            catch {
+                // best effort: the failure below is the outcome
+            }
+        }
+        throw new Error(CONTEXT_PACK_EXTERNAL_PERSISTENCE_FAILURE_MESSAGE);
+    }
+    return run;
+}
+/** Validates that every produced pack has exactly the path its evidence promises, then serializes in corpus order. */
+function collectPackFiles(results, outDir) {
+    const files = [];
+    const seen = new Set();
+    for (const result of results) {
+        const packTreatment = result.evidence.treatments.find((treatment) => treatment.treatmentId === "context-pack");
+        if (!result.pack) {
+            if (packTreatment?.packArtifactPath)
+                throw new Error(CONTEXT_PACK_GENERATION_ARTIFACT_STATE_MESSAGE);
+            continue;
+        }
+        const relativePath = contextPackArtifactRelativePath(result.evidence.caseId);
+        if (packTreatment?.packArtifactPath !== relativePath || seen.has(relativePath) || result.pack.caseId !== result.evidence.caseId) {
+            throw new Error(CONTEXT_PACK_GENERATION_ARTIFACT_STATE_MESSAGE);
+        }
+        seen.add(relativePath);
+        files.push({ caseId: result.evidence.caseId, relativePath, absolutePath: resolveWithinRoot(outDir, relativePath), content: serializeContextPackArtifact(result.pack) });
+    }
+    return files;
+}
+export function mapContextPackGenerationToRun(args) {
+    const cases = args.caseEvidence.map((entry, caseIndex) => ({
+        id: entry.caseId,
+        name: entry.caseName,
+        outcomes: entry.treatments.map((treatment, treatmentIndex) => buildOutcome(entry, treatment, args.analysis.cases[caseIndex].treatments[treatmentIndex])),
+        metadata: { benchmarkProject: entry.benchmarkProject, taskLocality: entry.taskLocality }
+    }));
+    const run = {
+        runId: args.runId,
+        pluginId: CONTEXT_PACK_GENERATION_PLUGIN_ID,
+        startedAt: args.startedAt,
+        completedAt: args.completedAt,
+        status: aggregateTreatmentStatus(args.caseEvidence.flatMap((entry) => entry.treatments.map((treatment) => treatment.status))),
+        target: args.target,
+        variants: CONTEXT_PACK_GENERATION_VARIANTS.map((variant) => ({ ...variant })),
+        cases,
+        metrics: [...toContextPackGenerationRunMetrics(args.analysis), ...args.analysis.cases.flatMap(toContextPackGenerationCaseComparisonMetrics)],
+        artifacts: [
+            {
+                id: "context-pack-generation-execution",
+                label: "Context pack generation execution evidence",
+                path: args.executionArtifactPath,
+                kind: "artifact",
+                mimeType: "application/json",
+                description: "Matched per-case execution evidence for raw-full-file and context-pack without source text or raw command output."
+            },
+            {
+                id: "context-pack-generation-analysis",
+                label: "Context pack generation scientific analysis",
+                path: args.analysisArtifactPath,
+                kind: "artifact",
+                mimeType: "application/json",
+                description: "Retrieval-quality metrics, size comparison and matched-case scope aggregates for raw-full-file versus context-pack."
+            },
+            ...args.packArtifactPaths.map((pack) => ({
+                id: `context-pack:${pack.caseId}`,
+                label: `Context pack for ${pack.caseId}`,
+                path: pack.path,
+                kind: "artifact",
+                mimeType: "application/json",
+                description: "Complete bundled experimental context pack (my-dev-kit-lab-context-pack-experiment-v1).",
+                caseId: pack.caseId,
+                variantId: "context-pack"
+            }))
+        ],
+        warnings: [],
+        // Outcome failures are the authoritative per-treatment failure location.
+        failures: [],
+        metadata: { executionArtifactPath: args.executionArtifactPath, analysisArtifactPath: args.analysisArtifactPath },
+        caseExecutionEvidence: structuredClone(args.caseEvidence),
+        analysis: structuredClone(args.analysis)
+    };
+    run.summary = summarizeExperimentRun(run);
+    return run;
+}
+function buildOutcome(caseEvidence, treatment, treatmentAnalysis) {
+    const { caseId, benchmarkProject, taskLocality } = caseEvidence;
+    const { treatmentId } = treatment;
+    return {
+        id: `${caseId}:${treatmentId}`,
+        caseId,
+        variantId: treatmentId,
+        status: treatment.status,
+        metrics: toContextPackGenerationOutcomeMetrics(treatmentAnalysis, caseId),
+        artifacts: [],
+        warnings: [],
+        failures: treatment.errors.map((error) => ({ code: error.code, message: error.message, variantId: treatmentId, caseId, recoverable: true })),
+        metadata: { benchmarkProject, taskLocality, evidenceAvailability: treatment.availability }
+    };
+}
+function aggregateTreatmentStatus(statuses) {
+    if (statuses.length === 0)
+        return "skipped";
+    if (statuses.every((status) => status === "completed"))
+        return "completed";
+    if (statuses.every((status) => status === "skipped"))
+        return "skipped";
+    if (statuses.every((status) => status === "failed"))
+        return "failed";
+    return "partial";
+}
+function readCasesInput(inputs) {
+    const value = inputs?.cases;
+    if (!Array.isArray(value))
+        throw new Error("Context pack generation requires cases input.");
+    return value;
+}
+function readDependenciesInput(inputs) {
+    const value = inputs?.contextPackDependencies;
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function readArtifactIo(inputs) {
+    const value = inputs?.contextPackArtifactIo;
+    return value && typeof value === "object" && !Array.isArray(value) ? { ...defaultArtifactIo, ...value } : defaultArtifactIo;
+}