knodin 0.7.4 → 0.7.6

package/dist/src/codeflow-replay.js

@@ -1,80 +0,0 @@
-export const EXPECTED_RELATIONSHIPS = [
-    "packages/api/route.ts->packages/auth/service.ts",
-    "packages/api/route.ts->packages/audit/store.ts",
-    "packages/auth/service.ts->packages/data/users.ts",
-];
-export function normalizeCodeFlowRelationships(connections) {
-    return connections.map((value) => {
-        const edge = value;
-        return {
-            // CodeFlow exports callee/definition as source and caller as target.
-            from: String(edge.target ?? ""),
-            to: String(edge.source ?? ""),
-            kind: typeof edge.kind === "string" ? edge.kind : null,
-            extractor: typeof edge.extractor === "string" ? edge.extractor : null,
-            confidence: edge.confidence === "exact" || edge.confidence === "heuristic" ? edge.confidence : null,
-            sourceFile: typeof edge.sourceFile === "string" ? edge.sourceFile : null,
-            sourceLine: typeof edge.sourceLine === "number" ? edge.sourceLine : null,
-            evidence: typeof edge.evidence === "string" ? edge.evidence : null,
-            raw: value,
-        };
-    });
-}
-export function scoreRelationships(relationships) {
-    const actual = new Set(relationships.map((edge) => `${edge.from}->${edge.to}`));
-    const expected = new Set(EXPECTED_RELATIONSHIPS);
-    const truePositives = [...expected].filter((edge) => actual.has(edge));
-    const falseNegatives = [...expected].filter((edge) => !actual.has(edge));
-    const falsePositives = [...actual].filter((edge) => !expected.has(edge));
-    const malformed = relationships.filter((edge) => !edge.from || !edge.to);
-    return {
-        truePositives,
-        falsePositives,
-        falseNegatives,
-        precision: actual.size === 0 ? 0 : truePositives.length / actual.size,
-        recall: truePositives.length / expected.size,
-        unsupportedEdgeRate: falseNegatives.length / expected.size,
-        malformedRelationships: malformed.length,
-    };
-}
-export function blastRadiusCompleteness(relationships) {
-    const origin = "packages/data/users.ts";
-    const expected = new Set(["packages/auth/service.ts", "packages/api/route.ts"]);
-    const adjacency = new Map();
-    for (const edge of relationships) {
-        if (!adjacency.has(edge.to))
-            adjacency.set(edge.to, new Set());
-        adjacency.get(edge.to)?.add(edge.from);
-    }
-    const found = new Set();
-    const queue = [origin];
-    while (queue.length) {
-        const current = queue.shift();
-        for (const dependent of adjacency.get(current) ?? []) {
-            if (dependent === origin || found.has(dependent))
-                continue;
-            found.add(dependent);
-            queue.push(dependent);
-        }
-    }
-    return {
-        origin,
-        expected: [...expected],
-        found: [...found].sort(),
-        missing: [...expected].filter((file) => !found.has(file)),
-        completeness: [...expected].filter((file) => found.has(file)).length / expected.size,
-    };
-}
-export function provenanceCoverage(relationships) {
-    const count = relationships.length;
-    const rate = (predicate) => count === 0 ? 0 : relationships.filter(predicate).length / count;
-    return {
-        relationships: count,
-        relationKind: rate((edge) => edge.kind !== null),
-        extractorIdentity: rate((edge) => edge.extractor !== null),
-        exactOrHeuristicConfidence: rate((edge) => edge.confidence !== null),
-        sourceFile: rate((edge) => edge.sourceFile !== null),
-        sourceLine: rate((edge) => edge.sourceLine !== null),
-        boundedSourceEvidence: rate((edge) => edge.evidence !== null),
-    };
-}

package/dist/src/compact-structural.js

@@ -1,96 +0,0 @@
-const IDENTITY_PREFIX = "sym_";
-/** A stable, repository-scoped shorthand. Prefix collisions remain ambiguity-safe
- * because selectors are expanded as prefixes rather than guessed as one symbol. */
-export function compactIdentity(identity) {
-    if (!identity)
-        return "~?";
-    const body = identity.startsWith(IDENTITY_PREFIX)
-        ? identity.slice(IDENTITY_PREFIX.length)
-        : identity;
-    return `~${body.slice(0, 6)}`;
-}
-export function expandCompactIdentity(identity) {
-    return identity?.startsWith("~") ? `${IDENTITY_PREFIX}${identity.slice(1)}*` : identity;
-}
-function freshness(value) {
-    if (value === "reconciled")
-        return "reconciled";
-    if (value === "unknown")
-        return "unknown";
-    return "fresh";
-}
-function terseSignature(row) {
-    const signature = row.signature?.replace(/\s+/g, " ").trim() ?? "";
-    if (!signature)
-        return "";
-    const python = /^(.*?:)(?:\s|$)/.exec(signature)?.[1];
-    return python ?? signature;
-}
-function rowLine(row, repeatFile) {
-    const nested = row.parent?.symbol ? `${row.parent.symbol}/` : "";
-    const filePrefix = repeatFile ? `${row.file ?? "?"}:` : "";
-    const location = `${filePrefix}${row.line ?? "?"}`;
-    const signature = terseSignature(row);
-    const signatureSuffix = signature ? ` ${signature}` : "";
-    return `${compactIdentity(row.identity)} ${row.kind ?? "?"} ${nested}${row.symbol ?? "?"}@${location}${signatureSuffix}`;
-}
-function withinBytes(header, rows, byteBudget) {
-    let selected = rows;
-    if (byteBudget !== undefined) {
-        while (selected.length > 0 &&
-            Buffer.byteLength([header(selected.length), ...selected].join("\n"), "utf8") > byteBudget)
-            selected = selected.slice(0, -1);
-    }
-    const output = [header(selected.length), ...selected].join("\n");
-    return byteBudget !== undefined && Buffer.byteLength(output, "utf8") > byteBudget ? "" : output;
-}
-export function compactQueryResult(result, byteBudget) {
-    if (result.ambiguity)
-        return compactAmbiguity(result.ambiguity.candidates, result.staleness);
-    const total = result.count;
-    const state = freshness(result.staleness);
-    if (result.pattern === "project_overview") {
-        const rows = result.results.map((row) => `${row.symbol ?? row.file ?? "."} ${row.fileCount ?? 0} ${row.sizeBytes ?? 0}B`);
-        return withinBytes((n) => `${state} ${n}/${total}`, rows, byteBudget);
-    }
-    const repeatFile = result.pattern === "batch_outline";
-    const rows = result.results.map((row) => rowLine(row, repeatFile));
-    return withinBytes((n) => {
-        const continuation = result.hasMore ? "+" : "";
-        const target = result.target ? ` ${result.target}` : "";
-        return `${state} ${n}/${total}${continuation}${target}`;
-    }, rows, byteBudget);
-}
-export function compactSearchResult(page, query, byteBudget) {
-    const normalize = (value) => value.toLocaleLowerCase().replace(/[^a-z0-9]/g, "");
-    const normalized = normalize(query);
-    const matches = page.results.filter((row) => normalize(row.symbol).includes(normalized));
-    const state = freshness(matches[0]?.staleness ?? page.results[0]?.staleness);
-    const rows = matches.map((row) => {
-        const source = row.source ? ` ${row.source}` : "";
-        return `${compactIdentity(row.identity)} ${row.kind} @${row.filePath}${source}`;
-    });
-    return withinBytes((n) => `${state} ${n}/${matches.length}${page.hasMore ? "+" : ""} ${query}`, rows, byteBudget);
-}
-export function compactExplainResult(result, selectorFile, byteBudget) {
-    if (result.ambiguity)
-        return compactAmbiguity(result.ambiguity.candidates, result.staleness);
-    const numbered = result.source ?? "";
-    const firstLine = Number(/^(\d+): /.exec(numbered)?.[1] ?? 0);
-    const source = numbered
-        .split("\n")
-        .map((line) => line.replace(/^\d+: /, ""))
-        .join("\n");
-    const header = `${freshness(result.staleness)} ${compactIdentity(result.identity)} ${selectorFile ?? "?"}:${firstLine || "?"}`;
-    const output = `${header}\n${source}`;
-    if (byteBudget === undefined || Buffer.byteLength(output, "utf8") <= byteBudget)
-        return output;
-    const omitted = `${header}\nomitted ${Buffer.byteLength(source, "utf8")}B`;
-    return Buffer.byteLength(omitted, "utf8") <= byteBudget ? omitted : "";
-}
-function compactAmbiguity(candidates, staleness) {
-    return [
-        `ambiguous ${freshness(staleness)} ${candidates.length}`,
-        ...candidates.map((candidate) => `${compactIdentity(candidate.identity)} ${candidate.kind} ${candidate.file}:${candidate.line}`),
-    ].join("\n");
-}

package/dist/src/competitive-cold-mcp.js

@@ -1,40 +0,0 @@
-import { createHash } from "node:crypto";
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import { sampleOperation } from "./competitive-measurement.js";
-function textOf(value) {
-    return (value.content ?? [])
-        .filter((item) => item.type === "text")
-        .map((item) => item.text ?? "")
-        .join("\n");
-}
-/** Measure five cold calls, rebuilding the MCP process before every recorded call. */
-export async function measureColdMcp(command, args, cwd, side, clientName) {
-    let last;
-    let error;
-    const { measurement } = await sampleOperation(async () => {
-        const transport = new StdioClientTransport({ command, args, cwd, stderr: "pipe" });
-        const client = new Client({ name: clientName, version: "1" }, { capabilities: {} });
-        try {
-            await client.connect(transport);
-            last = await client.callTool({ name: side.tool, arguments: side.args });
-            error = undefined;
-        }
-        catch (cause) {
-            error = cause instanceof Error ? cause.message : String(cause);
-        }
-        finally {
-            await transport.close().catch(() => undefined);
-        }
-        return last;
-    }, { mode: "cold" });
-    const response = last ? textOf(last) : "";
-    return {
-        ok: !error && !last?.isError,
-        error,
-        ...measurement,
-        responseBytes: Buffer.byteLength(response),
-        responseSha256: createHash("sha256").update(response).digest("hex"),
-        response,
-    };
-}

package/dist/src/competitive-constraints.js

@@ -1,20 +0,0 @@
-/** Verifies the local-only, single-gateway contract that qualifies a competitive replay. */
-export function assessCompetitiveConstraints(tools) {
-    const mcpToolNames = tools.map((tool) => tool.name).sort();
-    const schemaBytes = Buffer.byteLength(JSON.stringify(tools));
-    const violations = [];
-    if (tools.length !== 1)
-        violations.push(`Expected one MCP tool, found ${tools.length}`);
-    if (mcpToolNames.length !== 1 || mcpToolNames[0] !== "knodin")
-        violations.push(`Expected only the knodin gateway, found ${mcpToolNames.join(", ") || "none"}`);
-    return {
-        passed: violations.length === 0,
-        mcpToolCount: tools.length,
-        mcpToolNames,
-        schemaBytes,
-        schemaTokens: Math.ceil(schemaBytes / 4),
-        localOnly: true,
-        optionalServices: ["local GitHub CLI integration (prs operation)"],
-        violations,
-    };
-}

package/dist/src/competitive-manifest.js

@@ -1,411 +0,0 @@
-const bunHarness = (script) => ({ output }) => ["bun", `scripts/${script}`, output];
-export const COMPETITIVE_MANIFEST = [
-    {
-        id: "gitnexus",
-        name: "GitNexus",
-        version: "1.6.9",
-        roadmap: ["C2", "C4", "C5", "C6", "C7", "C8", "C9", "C10", "C24", "C25", "C26"],
-        baseline: "gitnexus-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "gitnexus" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["gitnexus", "--version"],
-        prepare: [["gitnexus", "analyze"]],
-        command: bunHarness("gitnexus-bakeoff.ts"),
-    },
-    {
-        id: "codegraph",
-        name: "CodeGraph",
-        version: "1.5.0",
-        roadmap: ["C2", "C3", "C11", "C24", "C25"],
-        baseline: "codegraph-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "codegraph" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["codegraph", "--version"],
-        command: bunHarness("codegraph-bakeoff.ts"),
-    },
-    {
-        id: "code-review-graph",
-        name: "code-review-graph",
-        version: "2.3.7",
-        roadmap: ["C3", "C5", "C11", "C12", "C15", "C17", "C24", "C26"],
-        baseline: "code-review-graph-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "code-review-graph" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["code-review-graph", "--version"],
-        prepare: [["code-review-graph", "build"]],
-        command: bunHarness("code-review-graph-bakeoff.ts"),
-    },
-    {
-        id: "graphify",
-        name: "Graphify",
-        version: "0.9.23",
-        roadmap: ["C2", "C3", "C11", "C12", "C13", "C17", "C24", "C26", "C41"],
-        baseline: "graphify-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "graphify" },
-            { type: "command", value: "graphify-mcp" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["graphify", "--version"],
-        prepare: [
-            ["graphify", "extract", ".", "--code-only", "--no-cluster"],
-            ["graphify", "cluster-only", ".", "--no-label", "--no-viz"],
-        ],
-        command: bunHarness("graphify-bakeoff.ts"),
-        caseMappings: [
-            {
-                idPattern: "^neighbors-calls-(?:path|default)(?:-cold)?$",
-                useCase: "direct call neighbors",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "get_neighbors",
-                    knodinOperation: "query:traverse",
-                    dimensions: ["target", "direction=both", "relation=call", "depth=1", "items=200"],
-                },
-                budgets: { bytes: null, tokens: null, items: 200 },
-                reason: "Both sides return direct inbound and outbound call neighbors for createEngine.",
-                oracleId: "create-engine-both",
-            },
-            {
-                idPattern: "^god-nodes-10-default(?:-cold)?$",
-                useCase: "bounded architectural hubs",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "god_nodes",
-                    knodinOperation: "map:minimal",
-                    dimensions: ["repository scope", "items=10", "hub ranking"],
-                },
-                budgets: { bytes: null, tokens: null, items: 10 },
-                reason: "Both sides return the ten highest-ranked architectural hubs.",
-                oracleId: "architecture-facet",
-            },
-        ],
-    },
-    {
-        id: "serena",
-        name: "Serena",
-        version: "1.6.2.dev0",
-        roadmap: ["C11", "C12", "C15", "C24", "C25"],
-        baseline: "serena-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "serena" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["serena", "--version"],
-        command: ({ output, fixture }) => ["bun", "scripts/serena-bakeoff.ts", fixture, output],
-    },
-    {
-        id: "codebase-memory",
-        name: "codebase-memory-mcp",
-        version: "0.9.0",
-        roadmap: ["C4", "C10", "C11", "C12", "C13", "C16", "C24", "C25", "C26", "C41"],
-        baseline: "codebase-memory-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "codebase-memory-mcp" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["codebase-memory-mcp", "--version"],
-        command: bunHarness("codebase-memory-bakeoff.ts"),
-        caseMappings: [
-            {
-                idPattern: "^search-graph-e0-c0(?:-cold)?$",
-                useCase: "bounded graph search",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "search_graph",
-                    knodinOperation: "search",
-                    dimensions: ["query=create engine", "offset=0", "items=10", "connected=false"],
-                },
-                budgets: { bytes: null, tokens: null, items: 10 },
-                reason: "Both sides run the same unexpanded first-page query with the same item limit.",
-                oracleId: "create-engine-definition",
-            },
-            {
-                idPattern: "^trace-inbound-calls-r0-t1(?:-cold)?$",
-                useCase: "typed call traversal",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "trace_path",
-                    knodinOperation: "query:traverse",
-                    dimensions: [
-                        "target=createEngine",
-                        "direction",
-                        "relation=call",
-                        "depth=3",
-                        "include_tests=true",
-                    ],
-                },
-                budgets: { bytes: null, tokens: null, items: 100 },
-                reason: "Both sides use the same target, direction, call relation, depth, and test scope.",
-                oracleId: "create-engine-callers",
-            },
-            {
-                idPattern: "^trace-outbound-calls-r0-t1(?:-cold)?$",
-                useCase: "typed call traversal",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "trace_path",
-                    knodinOperation: "query:traverse",
-                    dimensions: [
-                        "target=createEngine",
-                        "direction",
-                        "relation=call",
-                        "depth=3",
-                        "include_tests=true",
-                    ],
-                },
-                budgets: { bytes: null, tokens: null, items: 100 },
-                reason: "Both sides use the same target, outbound direction, call relation, depth, and test scope.",
-                oracleId: "create-engine-callees",
-            },
-            {
-                idPattern: "^trace-both-calls-r0-t1(?:-cold)?$",
-                useCase: "typed call traversal",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "trace_path",
-                    knodinOperation: "query:traverse",
-                    dimensions: [
-                        "target=createEngine",
-                        "direction",
-                        "relation=call",
-                        "depth=3",
-                        "include_tests=true",
-                    ],
-                },
-                budgets: { bytes: null, tokens: null, items: 100 },
-                reason: "Both sides use the same target, bidirectional scope, call relation, depth, and test scope.",
-                oracleId: "create-engine-both",
-            },
-            {
-                idPattern: "^architecture-(?:languages|packages|entry_points|hotspots|boundaries|layers)(?:-cold)?$",
-                useCase: "single architecture facet",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "get_architecture",
-                    knodinOperation: "query:architecture_overview",
-                    dimensions: ["one named facet", "repository scope", "source inclusion=metadata"],
-                },
-                budgets: { bytes: null, tokens: null, items: null },
-                reason: "Each row requests one architecture facet that knodin supports independently.",
-                oracleId: "engine-package",
-            },
-        ],
-    },
-    {
-        id: "grepai",
-        name: "grepai",
-        version: "0.35.0",
-        roadmap: ["C3", "C11", "C12", "C16", "C17", "C24", "C41"],
-        baseline: "grepai-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "grepai" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["grepai", "version"],
-        prepare: [
-            ["grepai", "init", "--provider", "ollama", "--backend", "gob", "--yes"],
-            ["node", "--import", "tsx", "scripts/wait-grepai-ready.ts"],
-        ],
-        command: bunHarness("grepai-bakeoff.ts"),
-        caseMappings: [
-            {
-                idPattern: "^status-json-v0(?:-cold)?$",
-                useCase: "cached index status",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "grepai_index_status",
-                    knodinOperation: "status:cached",
-                    dimensions: ["cached summary", "repository scope", "non-verbose"],
-                },
-                budgets: { bytes: null, tokens: null, items: null },
-                reason: "Both sides return a cached, non-deep index status summary.",
-                oracleId: "indexed-status",
-            },
-            {
-                idPattern: "^status-json-v1(?:-cold)?$",
-                useCase: "verified index lifecycle audit",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "grepai_index_status:verbose",
-                    knodinOperation: "status:deep",
-                    dimensions: ["verified deep audit", "repository scope", "verbose"],
-                },
-                budgets: { bytes: null, tokens: null, items: null },
-                reason: "Both sides verify repository index state rather than returning cached summaries.",
-                oracleId: "indexed-status",
-            },
-            {
-                idPattern: "^search-json-c0-l5-all(?:-cold)?$",
-                useCase: "bounded semantic search",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "grepai_search",
-                    knodinOperation: "search",
-                    dimensions: ["query=index freshness reconciliation", "repository scope", "items"],
-                },
-                budgets: { bytes: null, tokens: null, items: 5 },
-                reason: "Both sides use the same semantic query, repository scope, and row limit.",
-                oracleId: "freshness-search",
-            },
-            {
-                idPattern: "^grepai_trace_callers-json-c0(?:-cold)?$",
-                useCase: "direct call neighbors",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "grepai_trace_callers",
-                    knodinOperation: "query:callers_of",
-                    dimensions: ["target=createEngine", "direction=callers", "depth=1", "relation=call"],
-                },
-                budgets: { bytes: null, tokens: null, items: null },
-                reason: "Both sides return the same direct call-neighbor direction for createEngine.",
-                oracleId: "create-engine-callers",
-            },
-            {
-                idPattern: "^grepai_trace_callees-json-c0(?:-cold)?$",
-                useCase: "direct call neighbors",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "grepai_trace_callees",
-                    knodinOperation: "query:callees_of",
-                    dimensions: ["target=createEngine", "direction=callees", "depth=1", "relation=call"],
-                },
-                budgets: { bytes: null, tokens: null, items: null },
-                reason: "Both sides return direct callees of createEngine.",
-                oracleId: "create-engine-callees",
-            },
-        ],
-    },
-    {
-        id: "repomix",
-        name: "Repomix",
-        version: "1.17.0",
-        roadmap: ["C3", "C14", "C24", "C41"],
-        baseline: "repomix-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "repomix" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["repomix", "--version"],
-        command: ({ output, fixture }) => ["bun", "scripts/repomix-bakeoff.ts", fixture, output],
-        caseMappings: [
-            {
-                idPattern: "^pack-(?:xml|markdown|json)-c0(?:-cold)?$",
-                useCase: "two-file context pack",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "pack_codebase",
-                    knodinOperation: "pack:export",
-                    dimensions: ["format", "two includes", "test exclusion", "compression=false"],
-                },
-                budgets: { bytes: null, tokens: null, items: 2 },
-                reason: "Both sides pack the same two full files in the same supported format without compression.",
-                oracleId: "pack-two-files",
-            },
-            {
-                idPattern: "^read-(?:xml|markdown|json)-c0-(?:all|head|middle)$",
-                useCase: "bounded packed artifact read",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "read_repomix_output",
-                    knodinOperation: "pack:read",
-                    dimensions: ["same saved artifact", "same inclusive line range"],
-                },
-                budgets: { bytes: null, tokens: null, items: null },
-                reason: "Both sides read the same inclusive range from their immediately preceding pack.",
-                oracleId: "packed-read",
-            },
-            {
-                idPattern: "^grep-(?:xml|markdown|json)-c0-i(?:0|1)-x0$",
-                useCase: "exact packed artifact grep",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "grep_repomix_output",
-                    knodinOperation: "pack:grep",
-                    dimensions: ["same saved artifact", "same regex", "same case mode", "context=0"],
-                },
-                budgets: { bytes: null, tokens: null, items: null },
-                reason: "Both sides grep their equivalent packs with the same expression and no context lines.",
-                oracleId: "grep-create-engine",
-            },
-        ],
-    },
-    {
-        id: "aider",
-        name: "Aider repo-map",
-        version: "0.86.2",
-        roadmap: ["C3", "C14", "C24"],
-        baseline: "aider-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "aider" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["aider", "--version"],
-        command: bunHarness("aider-repomap-bakeoff.ts"),
-    },
-    {
-        id: "code2prompt",
-        name: "code2prompt",
-        version: "4.2.0",
-        roadmap: ["C3", "C5", "C14", "C24", "C41"],
-        baseline: "code2prompt-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "code2prompt" },
-            { type: "command", value: "bun" },
-        ],
-        versionCommand: ["code2prompt", "--version"],
-        command: bunHarness("code2prompt-bakeoff.ts"),
-        caseMappings: [
-            {
-                idPattern: "^format-(?:markdown|json|xml)-l(?:0|1)-t0-a0-c1(?:-cold)?$",
-                useCase: "two-file context pack",
-                mode: "warm",
-                scope: {
-                    competitorOperation: "code2prompt",
-                    knodinOperation: "pack:export",
-                    dimensions: [
-                        "format",
-                        "line numbers",
-                        "directory tree=false",
-                        "relative paths",
-                        "two includes",
-                    ],
-                },
-                budgets: { bytes: null, tokens: null, items: 2 },
-                reason: "Both sides pack the same two files with matching format, line, tree, and path settings.",
-                oracleId: "pack-two-files",
-            },
-        ],
-    },
-    {
-        id: "claude-context",
-        name: "claude-context-mcp",
-        version: "0.1.15",
-        roadmap: ["C11", "C12", "C16", "C24"],
-        baseline: "claude-context-vs-knodin.raw.json",
-        requirements: [
-            { type: "command", value: "claude-context-mcp" },
-            { type: "command", value: "bun" },
-            { type: "tcp", host: "127.0.0.1", port: 11434, label: "Ollama" },
-            { type: "tcp", host: "127.0.0.1", port: 19530, label: "Milvus" },
-        ],
-        versionCommand: ["bun", "pm", "ls", "-g"],
-        command: ({ output, fixture }) => ["bun", "scripts/claude-context-bakeoff.ts", fixture, output],
-    },
-    {
-        id: "mcp-codebase-index",
-        name: "mcp-codebase-index",
-        version: "1.6.0",
-        roadmap: ["C16", "C24"],
-        baseline: "mcp-codebase-index-blocker.raw.json",
-        requirements: [{ type: "command", value: "mcp-codebase-index" }],
-        versionCommand: ["bun", "pm", "ls", "-g"],
-        blocker: "Mandatory hosted Gemini embeddings violate the local-only protocol.",
-    },
-];