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

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

@@ -0,0 +1,84 @@
+import { countEstimatedTokens, countTextChars, tokenCountMethod } from "../../../core/countTokens.js";
+import { compareCodeUnits } from "../../../evaluation/indexSnapshot.js";
+import { buildContextPackSelectionPolicy, selectCallRelationships, selectRelevantFiles, selectRelevantSymbols, selectSourceSlices, selectTestFiles } from "./packSelectionPolicy.js";
+import { renderContextPack } from "./renderContextPack.js";
+import { CONTEXT_PACK_SCHEMA_VERSION, CONTEXT_PACK_SECTION_IDS } from "./types.js";
+/**
+ * Pure context-pack composition. No filesystem, process, environment, network, clock or randomness: identical input
+ * yields structurally identical output. It selects within the frozen caps, renders deterministically, and measures size
+ * from the exact rendered text.
+ */
+export function buildContextPack(input) {
+    const files = selectRelevantFiles(input.fileCandidates);
+    const symbols = selectRelevantSymbols(input.symbolCandidates);
+    const sourceSlices = selectSourceSlices(input.sourceSliceCandidates);
+    const calls = selectCallRelationships(input.callCandidates);
+    const tests = selectTestFiles(input.testCandidates);
+    const evidenceNotes = [
+        ...new Set([
+            ...(input.evidenceNotes ?? []),
+            ...files.notes,
+            ...symbols.notes,
+            ...sourceSlices.notes,
+            ...calls.notes,
+            ...tests.notes
+        ])
+    ].sort(compareCodeUnits);
+    const sectionAvailability = {
+        task: { availability: "available", reason: null },
+        files: { ...input.sectionAvailability.files },
+        symbols: { ...input.sectionAvailability.symbols },
+        sourceSlices: { ...input.sectionAvailability.sourceSlices },
+        callRelationships: { ...input.sectionAvailability.callRelationships },
+        tests: { ...input.sectionAvailability.tests },
+        evidenceNotes: { ...input.sectionAvailability.evidenceNotes }
+    };
+    const itemCounts = {
+        task: 1,
+        files: files.items.length,
+        symbols: symbols.items.length,
+        sourceSlices: sourceSlices.items.length,
+        callRelationships: calls.items.length,
+        tests: tests.items.length,
+        evidenceNotes: evidenceNotes.length
+    };
+    const rendered = renderContextPack({
+        task: input.task,
+        files: files.items,
+        symbols: symbols.items,
+        sourceSlices: sourceSlices.items,
+        callRelationships: calls.items,
+        tests: tests.items,
+        evidenceNotes,
+        sectionAvailability
+    });
+    return {
+        schemaVersion: CONTEXT_PACK_SCHEMA_VERSION,
+        caseId: input.caseId,
+        benchmarkProject: input.benchmarkProject,
+        taskLocality: input.taskLocality,
+        task: { title: input.task.title, summary: input.task.summary },
+        selectionPolicy: buildContextPackSelectionPolicy(input.myDevKitVersion),
+        files: files.items,
+        symbols: symbols.items,
+        sourceSlices: sourceSlices.items,
+        callRelationships: calls.items,
+        tests: tests.items,
+        evidenceNotes,
+        sections: CONTEXT_PACK_SECTION_IDS.map((id) => ({
+            id,
+            availability: sectionAvailability[id].availability,
+            reason: sectionAvailability[id].reason,
+            itemCount: itemCounts[id],
+            estimatedTokens: countEstimatedTokens(rendered.sections[id])
+        })),
+        size: {
+            totalChars: countTextChars(rendered.renderedText),
+            totalEstimatedTokens: countEstimatedTokens(rendered.renderedText),
+            tokenCountMethod
+        },
+        availability: input.availability,
+        reason: input.reason,
+        renderedText: rendered.renderedText
+    };
+}

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

@@ -0,0 +1,39 @@
+import { invalidExperimentConfig, isPlainObject, mergeConfig, validExperimentConfig } from "../../config.js";
+export const defaultContextPackGenerationConfig = {
+    outDir: "lab-output/context-pack-generation",
+    kitCommand: "npx @dailephd/my-dev-kit@latest"
+};
+const SUPPORTED_FIELDS = ["outDir", "kitCommand", "caseIds", "benchmarkProjects"];
+export const contextPackGenerationConfigDefinition = {
+    fields: [
+        { name: "outDir", type: "string", required: true, description: "Experiment output root." },
+        { name: "kitCommand", type: "string", description: "my-dev-kit command used for index and retrieval." },
+        { name: "caseIds", type: "array", description: "Bundled evaluation case IDs to include; corpus order is preserved." },
+        { name: "benchmarkProjects", type: "array", description: "Bundled benchmark project IDs to include; corpus order is preserved." }
+    ]
+};
+export function validateContextPackGenerationConfig(config) {
+    if (config !== undefined && !isPlainObject(config)) {
+        return invalidExperimentConfig(["context pack generation config must be an object."]);
+    }
+    const errors = [];
+    const unsupported = Object.keys(config ?? {}).filter((key) => !SUPPORTED_FIELDS.includes(key));
+    if (unsupported.length > 0) {
+        errors.push(`Unsupported context-pack-generation config field(s): ${unsupported.sort().join(", ")}.`);
+    }
+    const normalized = mergeConfig(defaultContextPackGenerationConfig, config);
+    for (const field of ["outDir", "kitCommand"]) {
+        const value = normalized[field];
+        if (typeof value !== "string" || !value.trim())
+            errors.push(`${field} must be a non-empty string.`);
+    }
+    for (const field of ["caseIds", "benchmarkProjects"]) {
+        const value = normalized[field];
+        if (value === undefined)
+            continue;
+        if (!Array.isArray(value) || value.length === 0 || !value.every((item) => typeof item === "string" && item.trim())) {
+            errors.push(`${field} must be a non-empty array of non-empty strings when provided.`);
+        }
+    }
+    return errors.length > 0 ? invalidExperimentConfig(errors) : validExperimentConfig(normalized);
+}

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

@@ -0,0 +1,361 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { resolveWithinRoot } from "../../../core/pathSafety.js";
+import { runMeasuredCommand } from "../../../core/runMeasuredCommand.js";
+import { validateRetrievalPrecisionRecallCase } from "../../../evaluation/retrievalQuality/index.js";
+import { buildMyDevKitIndex, probeMyDevKitVersion } from "../../../evaluation/runMyDevKitRetrieval.js";
+import { runRawFullFileBaseline } from "../../../evaluation/runRawFullFileBaseline.js";
+import { groupWarmIndexCases, taskOutputSegment } from "../warmIndexReuse/selection.js";
+import { buildContextPack } from "./buildContextPack.js";
+import { CONTEXT_PACK_GENERATION_ERROR_TEXT } from "./executionTypes.js";
+import { buildContextPackIdentityEvidence, buildRawFullFileIdentityEvidence } from "./identityEvidence.js";
+import { CONTEXT_PACK_GENERATION_TREATMENT_IDS } from "./metadata.js";
+import { contextPackArtifactRelativePath } from "./packArtifact.js";
+import { deriveSymbolSourceRange, findIndexedSymbolLine, interpretSymbolIndex, parseLookup, parseSearchHits, parseSlice, parseSource } from "./packEvidence.js";
+import { GRAPH_DEPTH, MAX_SOURCE_LINES_PER_SLICE, MAX_SOURCE_SLICES, SEARCH_RESULT_LIMIT, selectRelevantSymbols, selectSeedNodes } from "./packSelectionPolicy.js";
+const defaultDependencies = {
+    buildIndex: buildMyDevKitIndex,
+    runCommand: runMeasuredCommand,
+    runRawBaseline: runRawFullFileBaseline,
+    readSymbolIndex: async (indexDir) => JSON.parse(await readFile(path.join(indexDir, "symbol-index.json"), "utf8")),
+    probeVersion: probeMyDevKitVersion
+};
+const pad = (index) => String(index + 1).padStart(2, "0");
+function failedTreatment(treatmentId, code, steps = []) {
+    return {
+        treatmentId,
+        status: "failed",
+        availability: null,
+        availabilityReason: null,
+        size: null,
+        identityEvidence: null,
+        includedFiles: [],
+        steps,
+        sections: null,
+        evidenceNotes: [],
+        packArtifactPath: null,
+        errors: [{ code, message: CONTEXT_PACK_GENERATION_ERROR_TEXT[code] }]
+    };
+}
+function failedCase(evaluationCase, code) {
+    return {
+        evidence: {
+            caseId: evaluationCase.id,
+            caseName: evaluationCase.title,
+            benchmarkProject: evaluationCase.benchmarkProject,
+            taskLocality: evaluationCase.taskLocality ?? null,
+            treatments: CONTEXT_PACK_GENERATION_TREATMENT_IDS.map((treatmentId) => failedTreatment(treatmentId, code))
+        },
+        pack: null
+    };
+}
+const statusOf = (availability) => (availability === "available" ? "completed" : availability === "partial" ? "partial" : "failed");
+async function executeRawTreatment(context) {
+    try {
+        const baseline = await context.dependencies.runRawBaseline(context.evaluationCase);
+        const symbolIndex = context.symbolIndex;
+        const availability = symbolIndex ? "available" : "partial";
+        const reason = symbolIndex ? null : "symbol-index-unavailable";
+        return {
+            treatmentId: "raw-full-file",
+            status: statusOf(availability),
+            availability,
+            availabilityReason: reason,
+            size: { totalChars: baseline.totalChars, totalEstimatedTokens: baseline.totalEstimatedTokens, tokenCountMethod: baseline.tokenCountMethod },
+            identityEvidence: buildRawFullFileIdentityEvidence({
+                includedFiles: baseline.filesIncluded,
+                indexedFiles: symbolIndex?.files ?? [],
+                availability,
+                reason
+            }),
+            includedFiles: [...baseline.filesIncluded],
+            steps: [],
+            sections: null,
+            evidenceNotes: [],
+            packArtifactPath: null,
+            errors: []
+        };
+    }
+    catch {
+        return failedTreatment("raw-full-file", "raw-baseline-failed");
+    }
+}
+async function executePackTreatment(context) {
+    const { evaluationCase, indexDir, symbolIndex } = context;
+    const steps = [];
+    const run = (commandId, extraArgs) => context.dependencies.runCommand({ commandId, commandString: context.kitCommand, cwd: process.cwd(), outDir: context.commandsDir, extraArgs });
+    const fail = (code) => ({ treatment: failedTreatment("context-pack", code, steps), pack: null });
+    // 1. One search, capped, upstream rank preserved.
+    let hits;
+    try {
+        const search = await run("search", ["search", "--index", indexDir, "--query", evaluationCase.query, "--limit", String(SEARCH_RESULT_LIMIT), "--json"]);
+        const parsed = search.ok ? parseSearchHits(search.stdout, SEARCH_RESULT_LIMIT) : null;
+        if (!search.ok || !parsed || !parsed.ok) {
+            steps.push({ kind: "search", nodeId: null, sourceMode: null, succeeded: false, reason: search.ok ? "malformed-output" : "command-failed" });
+            return fail("retrieval-failed");
+        }
+        steps.push({ kind: "search", nodeId: null, sourceMode: null, succeeded: true, reason: null });
+        hits = parsed.value;
+    }
+    catch {
+        steps.push({ kind: "search", nodeId: null, sourceMode: null, succeeded: false, reason: "command-failed" });
+        return fail("retrieval-failed");
+    }
+    const fileCandidates = [];
+    const symbolCandidates = [];
+    const testCandidates = [];
+    const callCandidates = [];
+    const lineByNodeId = new Map();
+    const extraNotes = [];
+    for (const hit of hits) {
+        if (hit.path !== null) {
+            fileCandidates.push({ path: hit.path, origin: "search", rank: hit.rank });
+            testCandidates.push({ path: hit.path, origin: "search-candidate", rank: hit.rank });
+        }
+        if (hit.kind === "symbol") {
+            symbolCandidates.push({ name: hit.label ?? hit.nodeId.slice(hit.nodeId.indexOf("#") + 1), nodeId: hit.nodeId, file: hit.path, line: null, origin: "search", rank: hit.rank });
+        }
+    }
+    // 2. Seeds in upstream order; lookup then depth-1 slice per seed.
+    const seeds = selectSeedNodes(hits.map((hit) => ({ nodeId: hit.nodeId, origin: "search", rank: hit.rank })));
+    extraNotes.push(...seeds.notes);
+    let graphIncomplete = false;
+    for (const [index, seed] of seeds.items.entries()) {
+        try {
+            const lookup = await run(`lookup-${pad(index)}`, ["lookup", "--index", indexDir, "--node", seed.nodeId, "--depth", String(GRAPH_DEPTH), "--json"]);
+            const parsed = lookup.ok ? parseLookup(lookup.stdout) : null;
+            if (parsed && parsed.ok) {
+                steps.push({ kind: "lookup", nodeId: seed.nodeId, sourceMode: null, succeeded: true, reason: null });
+                const node = parsed.value.node;
+                if (node.path !== null)
+                    fileCandidates.push({ path: node.path, origin: "lookup", rank: seed.rank });
+                if (node.kind === "symbol" && node.symbolName !== null) {
+                    symbolCandidates.push({ name: node.symbolName, nodeId: node.id, file: node.path, line: node.line, origin: "lookup", rank: seed.rank });
+                    if (node.line !== null)
+                        lineByNodeId.set(node.id, node.line);
+                }
+            }
+            else {
+                graphIncomplete = true;
+                steps.push({ kind: "lookup", nodeId: seed.nodeId, sourceMode: null, succeeded: false, reason: lookup.ok ? "malformed-output" : "command-failed" });
+            }
+        }
+        catch {
+            graphIncomplete = true;
+            steps.push({ kind: "lookup", nodeId: seed.nodeId, sourceMode: null, succeeded: false, reason: "command-failed" });
+        }
+        try {
+            const slice = await run(`slice-${pad(index)}`, ["slice", "--index", indexDir, "--node", seed.nodeId, "--depth", String(GRAPH_DEPTH), "--direction", "both", "--json"]);
+            const parsed = slice.ok ? parseSlice(slice.stdout) : null;
+            if (parsed && parsed.ok) {
+                steps.push({ kind: "slice", nodeId: seed.nodeId, sourceMode: null, succeeded: true, reason: null });
+                for (const node of parsed.value.nodes) {
+                    if (node.path !== null) {
+                        fileCandidates.push({ path: node.path, origin: "graph", rank: seed.rank });
+                        testCandidates.push({ path: node.path, origin: "graph-neighbor", rank: seed.rank });
+                    }
+                    if (node.kind === "symbol" && node.symbolName !== null) {
+                        symbolCandidates.push({ name: node.symbolName, nodeId: node.id, file: node.path, line: node.line, origin: "graph", rank: seed.rank });
+                        if (node.line !== null && !lineByNodeId.has(node.id))
+                            lineByNodeId.set(node.id, node.line);
+                    }
+                }
+                for (const edge of parsed.value.edges)
+                    callCandidates.push({ fromNodeId: edge.source, toNodeId: edge.target, kind: edge.kind });
+            }
+            else {
+                graphIncomplete = true;
+                steps.push({ kind: "slice", nodeId: seed.nodeId, sourceMode: null, succeeded: false, reason: slice.ok ? "malformed-output" : "command-failed" });
+            }
+        }
+        catch {
+            graphIncomplete = true;
+            steps.push({ kind: "slice", nodeId: seed.nodeId, sourceMode: null, succeeded: false, reason: "command-failed" });
+        }
+    }
+    // 3. Bounded source for the selected symbols, in selection order, at most MAX_SOURCE_SLICES commands.
+    const selectedSymbols = selectRelevantSymbols(symbolCandidates).items;
+    const sliceCandidates = [];
+    let sourceIncomplete = false;
+    let sourceCount = 0;
+    for (const symbol of selectedSymbols) {
+        if (sourceCount >= MAX_SOURCE_SLICES)
+            break;
+        if (symbol.file === null)
+            continue;
+        const line = (symbol.nodeId !== null ? lineByNodeId.get(symbol.nodeId) : undefined) ?? (symbolIndex ? findIndexedSymbolLine(symbolIndex, symbol.file, symbol.name) : null);
+        const range = symbolIndex && line !== null ? deriveSymbolSourceRange(symbolIndex, symbol.file, line) : null;
+        if (!range && symbol.nodeId === null)
+            continue;
+        sourceCount += 1;
+        const sourceMode = range ? "index-range" : "node";
+        const nodeId = symbol.nodeId;
+        try {
+            const args = range
+                ? ["source", "--index", indexDir, "--file", symbol.file, "--start", String(range.startLine), "--end", String(range.endLine), "--json"]
+                : ["source", "--index", indexDir, "--node", nodeId, "--max-lines", String(MAX_SOURCE_LINES_PER_SLICE), "--json"];
+            const source = await run(`source-${pad(sourceCount - 1)}`, args);
+            const parsed = source.ok ? parseSource(source.stdout) : null;
+            if (!parsed || !parsed.ok) {
+                sourceIncomplete = true;
+                steps.push({ kind: "source", nodeId, sourceMode, succeeded: false, reason: source.ok ? "malformed-output" : "command-failed" });
+                continue;
+            }
+            const value = parsed.value;
+            steps.push({ kind: "source", nodeId, sourceMode, succeeded: true, reason: value.boundaryKnown ? null : "symbol-end-unknown" });
+            if (range?.capped)
+                extraNotes.push("source-slice-cap-reached");
+            sliceCandidates.push({
+                file: symbol.file,
+                nodeId,
+                symbolName: symbol.name,
+                startLine: value.startLine,
+                endLine: value.endLine,
+                text: value.content,
+                boundaryKnown: value.boundaryKnown,
+                truncated: range?.capped === true,
+                continuationAvailable: range ? range.capped : !value.eof,
+                rank: symbol.rank
+            });
+        }
+        catch {
+            sourceIncomplete = true;
+            steps.push({ kind: "source", nodeId, sourceMode, succeeded: false, reason: "command-failed" });
+        }
+    }
+    const boundaryUnknown = sliceCandidates.some((candidate) => !candidate.boundaryKnown);
+    // 4. Deterministic section availability decided here (execution), then pure composition.
+    const available = { availability: "available", reason: null };
+    const graphSection = graphIncomplete ? { availability: "partial", reason: "graph-step-incomplete" } : available;
+    const sourceSection = sourceIncomplete
+        ? { availability: "partial", reason: "source-step-incomplete" }
+        : boundaryUnknown
+            ? { availability: "partial", reason: "symbol-end-unknown" }
+            : available;
+    const sectionAvailability = { files: graphSection, symbols: graphSection, sourceSlices: sourceSection, callRelationships: graphSection, tests: graphSection, evidenceNotes: available };
+    const packAvailability = graphIncomplete || sourceIncomplete || boundaryUnknown ? "partial" : "available";
+    const packReason = graphIncomplete ? "graph-step-incomplete" : sourceIncomplete ? "source-step-incomplete" : boundaryUnknown ? "symbol-end-unknown" : null;
+    let pack;
+    try {
+        pack = buildContextPack({
+            caseId: evaluationCase.id,
+            benchmarkProject: evaluationCase.benchmarkProject,
+            taskLocality: evaluationCase.taskLocality ?? null,
+            task: { title: evaluationCase.title, summary: evaluationCase.query },
+            myDevKitVersion: context.myDevKitVersion,
+            fileCandidates,
+            symbolCandidates,
+            sourceSliceCandidates: sliceCandidates,
+            callCandidates,
+            testCandidates,
+            evidenceNotes: extraNotes,
+            sectionAvailability,
+            availability: packAvailability,
+            reason: packReason
+        });
+    }
+    catch {
+        return fail("pack-construction-failed");
+    }
+    // Slice-contained symbols need the symbol index; without it the identity evidence is explicitly partial, never guessed.
+    const identitySource = symbolIndex || pack.availability !== "available" ? pack : { ...pack, availability: "partial", reason: "symbol-index-unavailable" };
+    return {
+        pack,
+        treatment: {
+            treatmentId: "context-pack",
+            status: statusOf(identitySource.availability),
+            availability: identitySource.availability,
+            availabilityReason: identitySource.reason,
+            size: pack.size,
+            identityEvidence: buildContextPackIdentityEvidence(identitySource, symbolIndex?.files ?? []),
+            includedFiles: pack.files.map((file) => file.path),
+            steps,
+            sections: pack.sections.map((section) => ({ ...section })),
+            evidenceNotes: [...pack.evidenceNotes],
+            packArtifactPath: contextPackArtifactRelativePath(evaluationCase.id),
+            errors: []
+        }
+    };
+}
+/**
+ * Matched two-treatment execution (raw-full-file, context-pack). One base index per benchmark project, shared by both
+ * treatments of every case in it; cases run strictly sequentially in corpus order. Builds no scientific analysis and
+ * writes nothing durable: it returns bounded evidence plus the in-memory packs.
+ */
+export async function executeContextPackGeneration(options) {
+    const dependencies = { ...defaultDependencies, ...options.dependencies };
+    const results = new Map();
+    const validCases = [];
+    for (const evaluationCase of options.cases) {
+        if (validateRetrievalPrecisionRecallCase(evaluationCase).length > 0)
+            results.set(evaluationCase.id, failedCase(evaluationCase, "ground-truth-invalid"));
+        else
+            validCases.push(evaluationCase);
+    }
+    let myDevKitVersion = null;
+    for (const group of groupWarmIndexCases(validCases)) {
+        if (group.structuralErrors.length > 0) {
+            for (const evaluationCase of group.cases)
+                results.set(evaluationCase.id, failedCase(evaluationCase, "project-group-inconsistent"));
+            continue;
+        }
+        const baseIndexDir = resolveWithinRoot(options.outputRoot, path.join("indexes", group.projectSegment, "base"));
+        const projectCommandsDir = resolveWithinRoot(options.outputRoot, path.join("commands", group.projectSegment));
+        let indexReady = false;
+        try {
+            const build = await dependencies.buildIndex({
+                target: { absoluteTargetRoot: group.targetRoot, sourceRoots: [...group.sourceRoots] },
+                kitCommand: options.kitCommand,
+                indexDir: baseIndexDir,
+                commandsDir: path.join(projectCommandsDir, "index"),
+                requireKit: false,
+                // Context packs carry call relationships, which upstream emits only for call-graph indexes.
+                callGraph: true
+            });
+            indexReady = build.ok;
+        }
+        catch {
+            indexReady = false;
+        }
+        if (!indexReady) {
+            for (const evaluationCase of group.cases)
+                results.set(evaluationCase.id, failedCase(evaluationCase, "project-index-failed"));
+            continue;
+        }
+        if (myDevKitVersion === null) {
+            const tool = await dependencies.probeVersion({ kitCommand: options.kitCommand, commandsDir: resolveWithinRoot(options.outputRoot, path.join("commands", "version")) });
+            myDevKitVersion = tool.version ?? "unavailable";
+        }
+        let symbolIndex = null;
+        try {
+            symbolIndex = interpretSymbolIndex(await dependencies.readSymbolIndex(baseIndexDir));
+        }
+        catch {
+            symbolIndex = null;
+        }
+        for (const evaluationCase of group.cases) {
+            const context = {
+                evaluationCase,
+                kitCommand: options.kitCommand,
+                indexDir: baseIndexDir,
+                commandsDir: resolveWithinRoot(projectCommandsDir, taskOutputSegment(evaluationCase.id)),
+                symbolIndex,
+                myDevKitVersion,
+                dependencies
+            };
+            // Strictly sequential, fixed treatment order.
+            const raw = await executeRawTreatment(context);
+            const pack = await executePackTreatment(context);
+            const evidence = {
+                caseId: evaluationCase.id,
+                caseName: evaluationCase.title,
+                benchmarkProject: evaluationCase.benchmarkProject,
+                taskLocality: evaluationCase.taskLocality ?? null,
+                treatments: [raw, pack.treatment]
+            };
+            results.set(evaluationCase.id, { evidence, pack: pack.pack });
+        }
+    }
+    // Selection order is the corpus order after filtering, regardless of how projects were grouped.
+    return options.cases.map((evaluationCase) => results.get(evaluationCase.id));
+}

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

@@ -0,0 +1,17 @@
+import { CONTEXT_PACK_GENERATION_TREATMENT_IDS } from "./metadata.js";
+import { CONTEXT_PACK_SELECTION_POLICY_ID } from "./packSelectionPolicy.js";
+export const CONTEXT_PACK_GENERATION_EXECUTION_ARTIFACT_FILE = "context-pack-generation-execution.json";
+export const CONTEXT_PACK_GENERATION_EXECUTION_SCHEMA_VERSION = "my-dev-kit-lab-context-pack-generation-execution-v1";
+export function buildContextPackGenerationExecutionArtifact(args) {
+    return {
+        schemaVersion: CONTEXT_PACK_GENERATION_EXECUTION_SCHEMA_VERSION,
+        runId: args.runId,
+        pluginId: args.pluginId,
+        pluginSchemaVersion: args.pluginSchemaVersion,
+        startedAt: args.startedAt,
+        completedAt: args.completedAt,
+        treatmentOrder: [...CONTEXT_PACK_GENERATION_TREATMENT_IDS],
+        selectionPolicyId: CONTEXT_PACK_SELECTION_POLICY_ID,
+        cases: structuredClone(args.cases)
+    };
+}

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

@@ -0,0 +1,11 @@
+/** Plugin-owned text per code; caught error messages and process stderr are never copied into durable evidence. */
+export const CONTEXT_PACK_GENERATION_ERROR_TEXT = {
+    "ground-truth-invalid": "The case ground truth was invalid.",
+    "project-group-inconsistent": "The case source configuration was inconsistent.",
+    "project-index-failed": "The my-dev-kit index could not be prepared.",
+    "raw-baseline-failed": "The raw full-file baseline could not be built.",
+    "retrieval-failed": "The context-pack retrieval did not complete.",
+    "pack-construction-failed": "The context pack could not be constructed."
+};
+/** Fixed schema of the external-local identity-redaction marker. */
+export const CONTEXT_PACK_IDENTITY_REDACTION_SCHEMA_VERSION = "my-dev-kit-lab-context-pack-identity-redaction-v1";

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

@@ -0,0 +1,71 @@
+import { compareCodeUnits } from "../../../evaluation/indexSnapshot.js";
+import { normalizeRetrievedRepositoryPath } from "../../../evaluation/retrievalQuality/buildRetrievalEvidence.js";
+function canonicalSymbols(identities) {
+    const unique = new Map();
+    for (const identity of identities)
+        unique.set(`${identity.file ?? ""}\0${identity.name}`, identity);
+    return [...unique.values()].sort((a, b) => compareCodeUnits(a.file ?? "", b.file ?? "") || compareCodeUnits(a.name, b.name));
+}
+/** Raw-full-file rule: every indexed symbol defined in a file the raw baseline actually included. */
+export function collectRawFullFileSymbols(indexedFiles, includedFiles) {
+    const included = new Set();
+    for (const file of includedFiles) {
+        const normalized = normalizeRetrievedRepositoryPath(file);
+        if (normalized !== null)
+            included.add(normalized);
+    }
+    const found = [];
+    for (const entry of indexedFiles) {
+        const path = normalizeRetrievedRepositoryPath(entry.path);
+        if (path === null || !included.has(path))
+            continue;
+        for (const symbol of entry.symbols)
+            found.push({ name: symbol.name, file: path });
+    }
+    return canonicalSymbols(found);
+}
+/**
+ * Context-pack rule: the union of the explicitly selected symbols and the indexed symbols whose definition line falls
+ * inside a selected (post-cap) source slice range of the same file.
+ */
+export function collectContextPackSymbols(pack, indexedFiles) {
+    const found = pack.symbols.map((symbol) => (symbol.file === null ? { name: symbol.name } : { name: symbol.name, file: symbol.file }));
+    for (const entry of indexedFiles) {
+        const path = normalizeRetrievedRepositoryPath(entry.path);
+        if (path === null)
+            continue;
+        const slices = pack.sourceSlices.filter((slice) => slice.file === path);
+        if (slices.length === 0)
+            continue;
+        for (const symbol of entry.symbols) {
+            if (slices.some((slice) => symbol.location.line >= slice.startLine && symbol.location.line <= slice.endLine)) {
+                found.push({ name: symbol.name, file: path });
+            }
+        }
+    }
+    return canonicalSymbols(found);
+}
+const withReason = (input) => input.reason === null ? { availability: input.availability } : { availability: input.availability, availabilityReason: input.reason };
+/** Context-pack identity evidence for the existing retrieval-quality calculator. Tests stay descriptive and are excluded. */
+export function buildContextPackIdentityEvidence(pack, indexedFiles) {
+    const files = new Set([...pack.files.map((file) => file.path), ...pack.sourceSlices.map((slice) => slice.file)]);
+    return {
+        ...withReason({ availability: pack.availability, reason: pack.reason }),
+        files: [...files].sort(compareCodeUnits),
+        symbols: collectContextPackSymbols(pack, indexedFiles)
+    };
+}
+/** Raw-full-file identity evidence; availability is supplied by the caller, never inferred from an empty list. */
+export function buildRawFullFileIdentityEvidence(input) {
+    const files = new Set();
+    for (const file of input.includedFiles) {
+        const normalized = normalizeRetrievedRepositoryPath(file);
+        if (normalized !== null)
+            files.add(normalized);
+    }
+    return {
+        ...withReason(input),
+        files: [...files].sort(compareCodeUnits),
+        symbols: collectRawFullFileSymbols(input.indexedFiles, input.includedFiles)
+    };
+}

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

@@ -0,0 +1,19 @@
+export * from "./analysis.js";
+export * from "./analysisArtifact.js";
+export * from "./analysisTypes.js";
+export * from "./buildContextPack.js";
+export * from "./config.js";
+export * from "./execution.js";
+export * from "./executionArtifact.js";
+export * from "./executionTypes.js";
+export * from "./identityEvidence.js";
+export * from "./localSubjectExecution.js";
+export * from "./localSubjectPrivacy.js";
+export * from "./metadata.js";
+export * from "./metrics.js";
+export * from "./packArtifact.js";
+export * from "./packEvidence.js";
+export * from "./packSelectionPolicy.js";
+export * from "./plugin.js";
+export * from "./renderContextPack.js";
+export * from "./types.js";