@velum-labs/cursorkit 0.1.0

package/dist/src/tools/checkModelFusionProtocol.js

@@ -0,0 +1,274 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { MODEL_FUSION_SCHEMA_BUNDLE_HASH } from "../fixtures/modelFusion.js";
+const ROOT = process.cwd();
+const ORIGIN_MANIFEST_PATH = "docs/model-fusion-protocol-origin.json";
+const PROTOCOL_DOC_PATH = "docs/model-fusion-protocol.md";
+const PACKAGE_JSON_PATH = "package.json";
+const PROTOCOL_PACKAGE_NAME = "@velum-labs/model-fusion-protocol";
+const CONTRACT_FIXTURE_ROOT = "fixtures/model-fusion-contract";
+const CURSOR_HARNESS_PROTO_PATH = "proto/model_fusion/v1/cursor_harness.proto";
+const CURSOR_HARNESS_TS_PATH = "src/gen/model_fusion/v1/cursor_harness_pb.ts";
+const CURSOR_HARNESS_OPENAPI_PATH = "docs/model-fusion-cursor-harness.openapi.yaml";
+const CURSOR_HARNESS_OPENAPI_TS_PATH = "src/gen/model_fusion/cursor_harness_openapi.ts";
+export function checkModelFusionProtocol() {
+    const errors = [];
+    const manifest = readManifest(errors);
+    const packageJson = readPackageJson(errors);
+    if (manifest !== undefined) {
+        checkManifest(manifest, packageJson, errors);
+    }
+    checkFixtureBundleHashes(errors);
+    checkNoLocalProtocolMirrors(errors);
+    checkProtocolDocs(errors);
+    return errors;
+}
+function readManifest(errors) {
+    try {
+        return JSON.parse(fs.readFileSync(resolvePath(ORIGIN_MANIFEST_PATH), "utf8"));
+    }
+    catch (error) {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+function readPackageJson(errors) {
+    try {
+        return JSON.parse(fs.readFileSync(resolvePath(PACKAGE_JSON_PATH), "utf8"));
+    }
+    catch (error) {
+        errors.push(`${PACKAGE_JSON_PATH}: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+function checkManifest(manifest, packageJson, errors) {
+    if (manifest.schemaVersion !== 1) {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: schemaVersion must be 1`);
+    }
+    if (manifest.canonicalSpec !==
+        "https://github.com/velum-labs/openclaw-shared/blob/main/spec/2026-06-16-model-fusion-protocol-packaging-spec.md") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: canonicalSpec must point at the shared protocol packaging spec`);
+    }
+    if (manifest.schemaBundleHash !== MODEL_FUSION_SCHEMA_BUNDLE_HASH) {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: schemaBundleHash ${manifest.schemaBundleHash} does not match MODEL_FUSION_SCHEMA_BUNDLE_HASH ${MODEL_FUSION_SCHEMA_BUNDLE_HASH}`);
+    }
+    if (manifest.serviceIdl?.sourceOfTruth !== "openapi-3.1") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: serviceIdl.sourceOfTruth must be openapi-3.1`);
+    }
+    if (manifest.serviceIdl?.openapi !== "v1-http-json-source-of-truth") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: serviceIdl.openapi must be v1-http-json-source-of-truth`);
+    }
+    if (manifest.protobufBuf?.v1Required !== false) {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: protobufBuf.v1Required must be false`);
+    }
+    if (manifest.protobufBuf?.status !==
+        "reserved-for-future-internal-streaming-connect-grpc") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: protobufBuf.status must reserve protobuf/Buf for future internal streaming/Connect/gRPC`);
+    }
+    if (manifest.persistedRecordFormat?.sourceOfTruth !== "json-schema") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: persistedRecordFormat.sourceOfTruth must be json-schema`);
+    }
+    checkPackageConsumptionOrBlocker(manifest, packageJson, errors);
+    for (const schema of [
+        "harness-run-request.v1",
+        "harness-run-result.v1",
+        "cursor-run-request.v1",
+        "cursor-run-result.v1",
+    ]) {
+        if (!manifest.persistedJsonSchemas.includes(schema)) {
+            errors.push(`${ORIGIN_MANIFEST_PATH}: missing persisted JSON schema ${schema}`);
+        }
+    }
+    if (manifest.packages?.typescript?.name !== "@velum-labs/model-fusion-protocol") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: TypeScript package target must be @velum-labs/model-fusion-protocol`);
+    }
+    if (manifest.packages?.typescript?.generatedFrom !==
+        "fusionkit JSON Schema and OpenAPI 3.1 contracts") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: TypeScript package must be generated from fusionkit JSON Schema and OpenAPI 3.1 contracts`);
+    }
+    const pythonIndexes = manifest.packages?.python?.preferredPrivateIndexes ?? [];
+    for (const index of ["Cloudsmith", "CodeArtifact", "Gemfury"]) {
+        if (!pythonIndexes.includes(index)) {
+            errors.push(`${ORIGIN_MANIFEST_PATH}: Python private index plan must include ${index}`);
+        }
+    }
+    const shortTermOptions = manifest.packages?.python?.shortTermOptions ?? [];
+    if (!shortTermOptions.includes("GitHub Releases wheels") ||
+        !shortTermOptions.includes("uv git deps")) {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: Python short-term plan must include GitHub Releases wheels and uv git deps`);
+    }
+    if (manifest.packages?.python?.generatedFrom !==
+        "fusionkit JSON Schema and OpenAPI 3.1 contracts") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: Python package must be generated from fusionkit JSON Schema and OpenAPI 3.1 contracts`);
+    }
+    const cursorBoundary = manifest.serviceBoundaries?.find((boundary) => boundary.service === "CursorHarnessHttpApi");
+    if (cursorBoundary?.openapi !== undefined) {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: CursorHarnessHttpApi must not point at a local OpenAPI mirror while @velum-labs/model-fusion-protocol is unavailable`);
+    }
+    if (cursorBoundary?.canonicalSource !== "fusionkit") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: CursorHarnessHttpApi canonicalSource must be fusionkit`);
+    }
+    const followUps = manifest.followUpWorkOutsideCursorkit ?? [];
+    for (const expected of [
+        "OpenAPI 3.1 source",
+        "@velum-labs/model-fusion-protocol",
+        "velum-model-fusion-protocol wheels",
+        "TS OpenAPI client/types",
+        "TS durable-record validators/types",
+        "Python OpenAPI client/models",
+        "JSON Schema/Pydantic validators",
+        "JSON Schema bundle metadata",
+    ]) {
+        if (!followUps.some((item) => item.includes(expected))) {
+            errors.push(`${ORIGIN_MANIFEST_PATH}: followUpWorkOutsideCursorkit must mention ${expected}`);
+        }
+    }
+}
+function checkPackageConsumptionOrBlocker(manifest, packageJson, errors) {
+    const consumedVersion = packageJson?.dependencies?.[PROTOCOL_PACKAGE_NAME] ??
+        packageJson?.devDependencies?.[PROTOCOL_PACKAGE_NAME];
+    if (consumedVersion !== undefined) {
+        const pin = packageJson?.modelFusionProtocol;
+        if (pin?.packageName !== PROTOCOL_PACKAGE_NAME) {
+            errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.packageName must be ${PROTOCOL_PACKAGE_NAME}`);
+        }
+        if (pin?.schemaBundleHash !== manifest.schemaBundleHash) {
+            errors.push(`${PACKAGE_JSON_PATH}: consumed protocol package schema bundle hash must match ${ORIGIN_MANIFEST_PATH}`);
+        }
+        if (pin?.version !== consumedVersion.replace(/^[~^]/, "")) {
+            errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.version must match consumed ${PROTOCOL_PACKAGE_NAME} version`);
+        }
+        checkInstalledProtocolPackageMetadata(manifest, pin, errors);
+        return;
+    }
+    if (manifest.packages?.typescript?.currentStatus !==
+        "blocked-missing-registry-package") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: packages.typescript.currentStatus must document blocked-missing-registry-package when ${PROTOCOL_PACKAGE_NAME} is absent`);
+    }
+    if (manifest.mergeBlocker?.status !== "blocked") {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: mergeBlocker.status must be blocked`);
+    }
+    if (!manifest.mergeBlocker?.reason?.includes(PROTOCOL_PACKAGE_NAME)) {
+        errors.push(`${ORIGIN_MANIFEST_PATH}: mergeBlocker.reason must mention ${PROTOCOL_PACKAGE_NAME}`);
+    }
+    for (const expected of [
+        `Publish ${PROTOCOL_PACKAGE_NAME}`,
+        `Add ${PROTOCOL_PACKAGE_NAME}`,
+        "Replace local model-fusion contract mirrors",
+        "schema bundle hash matches",
+    ]) {
+        if (!manifest.mergeBlocker?.requiredBeforeReady?.some((item) => item.includes(expected))) {
+            errors.push(`${ORIGIN_MANIFEST_PATH}: mergeBlocker.requiredBeforeReady must mention ${expected}`);
+        }
+    }
+}
+function checkInstalledProtocolPackageMetadata(manifest, pin, errors) {
+    const packageMetadataPath = resolvePath("node_modules/@velum-labs/model-fusion-protocol/protocol-package.json");
+    let metadata;
+    try {
+        metadata = JSON.parse(fs.readFileSync(packageMetadataPath, "utf8"));
+    }
+    catch (error) {
+        errors.push(`${PROTOCOL_PACKAGE_NAME}: installed protocol-package.json is required: ${error instanceof Error ? error.message : String(error)}`);
+        return;
+    }
+    if (metadata.package_name !== PROTOCOL_PACKAGE_NAME) {
+        errors.push(`${PROTOCOL_PACKAGE_NAME}: protocol-package.json package_name must be ${PROTOCOL_PACKAGE_NAME}`);
+    }
+    if (metadata.version !== pin?.version) {
+        errors.push(`${PROTOCOL_PACKAGE_NAME}: protocol-package.json version must match ${PACKAGE_JSON_PATH} modelFusionProtocol.version`);
+    }
+    if (metadata.schema_bundle_hash !== manifest.schemaBundleHash) {
+        errors.push(`${PROTOCOL_PACKAGE_NAME}: protocol-package.json schema_bundle_hash must match ${ORIGIN_MANIFEST_PATH}`);
+    }
+}
+function checkFixtureBundleHashes(errors) {
+    for (const fixturePath of listJsonFiles(resolvePath(CONTRACT_FIXTURE_ROOT))) {
+        const relativePath = path.relative(ROOT, fixturePath);
+        const parsed = JSON.parse(fs.readFileSync(fixturePath, "utf8"));
+        if (parsed.schema_bundle_hash !== MODEL_FUSION_SCHEMA_BUNDLE_HASH) {
+            errors.push(`${relativePath}: schema_bundle_hash ${String(parsed.schema_bundle_hash)} does not match ${MODEL_FUSION_SCHEMA_BUNDLE_HASH}`);
+        }
+    }
+}
+function checkNoLocalProtocolMirrors(errors) {
+    for (const relativePath of [
+        CURSOR_HARNESS_PROTO_PATH,
+        CURSOR_HARNESS_TS_PATH,
+        CURSOR_HARNESS_OPENAPI_PATH,
+        CURSOR_HARNESS_OPENAPI_TS_PATH,
+    ]) {
+        if (fs.existsSync(resolvePath(relativePath))) {
+            errors.push(`${relativePath}: local model-fusion protocol mirrors are not merge-ready; consume ${PROTOCOL_PACKAGE_NAME} or document the missing-package blocker`);
+        }
+    }
+}
+function checkProtocolDocs(errors) {
+    const doc = readRequiredText(PROTOCOL_DOC_PATH, errors);
+    if (doc === undefined) {
+        return;
+    }
+    const normalizedDoc = doc.replace(/\s+/g, " ");
+    for (const expected of [
+        "fusionkit",
+        "@velum-labs/model-fusion-protocol",
+        "OpenAPI 3.1 is the source of truth",
+        "Service/API clients and request/response models should be generated from OpenAPI specs",
+        "Durable record validators and record types should be generated from the JSON Schema bundle",
+        "JSON Schema remains the persisted audit and benchmark record format",
+        "Protobuf/Buf is reserved for later internal streaming",
+        "openapi-typescript",
+        "openapi-fetch",
+        "openapi-python-client",
+        "datamodel-code-generator",
+        "Published package consumption",
+        "installed as a cursorkit dev dependency",
+        "Cloudsmith",
+        "CodeArtifact",
+        "Gemfury",
+        "GitHub Releases wheels",
+        "uv",
+        "HarnessExecutorService",
+        "Cursor harness OpenAPI",
+        "MlxProviderService",
+        "Benchmark execution",
+        "Follow-up outside cursorkit",
+    ]) {
+        if (!normalizedDoc.includes(expected)) {
+            errors.push(`${PROTOCOL_DOC_PATH}: missing ${expected}`);
+        }
+    }
+}
+function readRequiredText(relativePath, errors) {
+    try {
+        return fs.readFileSync(resolvePath(relativePath), "utf8");
+    }
+    catch (error) {
+        errors.push(`${relativePath}: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+function listJsonFiles(directory) {
+    const entries = fs.readdirSync(directory, { withFileTypes: true });
+    return entries.flatMap((entry) => {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            return listJsonFiles(fullPath);
+        }
+        return entry.isFile() && entry.name.endsWith(".json") ? [fullPath] : [];
+    });
+}
+function resolvePath(relativePath) {
+    return path.resolve(ROOT, relativePath);
+}
+if (process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const errors = checkModelFusionProtocol();
+    if (errors.length > 0) {
+        for (const error of errors) {
+            console.error(error);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/src/tools/checkReleasePublishConfig.d.ts

@@ -0,0 +1 @@
+export declare function checkReleasePublishConfig(repoRoot?: string): string[];

package/dist/src/tools/checkReleasePublishConfig.js

@@ -0,0 +1,99 @@
+import fs from "node:fs";
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+import { MODEL_FUSION_SCHEMA_BUNDLE_HASH } from "../fixtures/modelFusion.js";
+const PACKAGE_JSON_PATH = "package.json";
+const PROTOCOL_ORIGIN_PATH = "docs/model-fusion-protocol-origin.json";
+const PUBLIC_NPM_REGISTRY = "https://registry.npmjs.org";
+const CANONICAL_PACKAGE_NAME = "@velum-labs/cursorkit";
+const CANONICAL_REPOSITORY_URL = "git+https://github.com/velum-labs/cursorkit.git";
+const PROTOCOL_PACKAGE_NAME = "@velum-labs/model-fusion-protocol";
+const PROTOCOL_CONTRACTS = "json-schema+openapi-3.1";
+export function checkReleasePublishConfig(repoRoot = process.cwd()) {
+    const errors = [];
+    const packageJson = readJson(repoRoot, PACKAGE_JSON_PATH, errors);
+    const protocolOrigin = readJson(repoRoot, PROTOCOL_ORIGIN_PATH, errors);
+    if (packageJson === undefined || protocolOrigin === undefined) {
+        return errors;
+    }
+    checkPackageMetadata(packageJson, errors);
+    checkProtocolPin(packageJson, protocolOrigin, errors);
+    return errors;
+}
+function checkPackageMetadata(packageJson, errors) {
+    if (packageJson.name !== CANONICAL_PACKAGE_NAME) {
+        errors.push(`${PACKAGE_JSON_PATH}: name must be ${CANONICAL_PACKAGE_NAME}`);
+    }
+    if (packageJson.repository?.url !== CANONICAL_REPOSITORY_URL) {
+        errors.push(`${PACKAGE_JSON_PATH}: repository.url must be ${CANONICAL_REPOSITORY_URL}`);
+    }
+    // @velum-labs/cursorkit publishes to public npm (no manual deploys): the release
+    // workflow runs only on a reviewed GitHub Release and publishes with
+    // provenance, so the publish posture is asserted here.
+    if (packageJson.publishConfig?.registry !== PUBLIC_NPM_REGISTRY) {
+        errors.push(`${PACKAGE_JSON_PATH}: publishConfig.registry must be ${PUBLIC_NPM_REGISTRY}`);
+    }
+    if (packageJson.publishConfig?.access !== "public") {
+        errors.push(`${PACKAGE_JSON_PATH}: publishConfig.access must be public`);
+    }
+    if (packageJson.publishConfig?.provenance !== true) {
+        errors.push(`${PACKAGE_JSON_PATH}: publishConfig.provenance must be true for supply-chain provenance`);
+    }
+    if (packageJson.private !== false) {
+        errors.push(`${PACKAGE_JSON_PATH}: private must be false so the release workflow can publish`);
+    }
+}
+function checkProtocolPin(packageJson, protocolOrigin, errors) {
+    const pin = packageJson.modelFusionProtocol;
+    if (pin === undefined) {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol pin is required`);
+        return;
+    }
+    if (pin.packageName !== PROTOCOL_PACKAGE_NAME) {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.packageName must be ${PROTOCOL_PACKAGE_NAME}`);
+    }
+    if (pin.version === undefined ||
+        !/^\d+\.\d+\.\d+(?:[-+][0-9A-Za-z.-]+)?$/.test(pin.version)) {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.version must be a pinned semver version`);
+    }
+    if (pin.schemaBundleHash !== MODEL_FUSION_SCHEMA_BUNDLE_HASH) {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.schemaBundleHash must match ${MODEL_FUSION_SCHEMA_BUNDLE_HASH}`);
+    }
+    if (pin.schemaBundleHash !== protocolOrigin.schemaBundleHash) {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.schemaBundleHash must match ${PROTOCOL_ORIGIN_PATH}`);
+    }
+    if (pin.packageName !== protocolOrigin.packages?.typescript?.name) {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.packageName must match ${PROTOCOL_ORIGIN_PATH}`);
+    }
+    if (pin.contracts !== PROTOCOL_CONTRACTS) {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.contracts must be ${PROTOCOL_CONTRACTS}`);
+    }
+    if (pin.origin !== "fusionkit") {
+        errors.push(`${PACKAGE_JSON_PATH}: modelFusionProtocol.origin must be fusionkit`);
+    }
+    if (protocolOrigin.serviceIdl?.sourceOfTruth !== "openapi-3.1") {
+        errors.push(`${PROTOCOL_ORIGIN_PATH}: serviceIdl.sourceOfTruth must be openapi-3.1 for v1 release publishing`);
+    }
+    if (protocolOrigin.persistedRecordFormat?.sourceOfTruth !== "json-schema") {
+        errors.push(`${PROTOCOL_ORIGIN_PATH}: persistedRecordFormat.sourceOfTruth must be json-schema for v1 release publishing`);
+    }
+}
+function readJson(repoRoot, relativePath, errors) {
+    try {
+        return JSON.parse(fs.readFileSync(path.resolve(repoRoot, relativePath), "utf8"));
+    }
+    catch (error) {
+        errors.push(`${relativePath}: ${error instanceof Error ? error.message : String(error)}`);
+        return undefined;
+    }
+}
+if (process.argv[1] !== undefined &&
+    import.meta.url === pathToFileURL(process.argv[1]).href) {
+    const errors = checkReleasePublishConfig();
+    if (errors.length > 0) {
+        for (const error of errors) {
+            console.error(error);
+        }
+        process.exitCode = 1;
+    }
+}

package/dist/src/tools/generateProtoInventory.d.ts

@@ -0,0 +1 @@
+export declare function generateProtoInventory(repoRoot?: string): void;

package/dist/src/tools/generateProtoInventory.js

@@ -0,0 +1,89 @@
+import fs from "node:fs";
+import path from "node:path";
+import { listProtoFiles, resolveProtoDirectory } from "../proto.js";
+export function generateProtoInventory(repoRoot = process.cwd()) {
+    const protoDir = resolveProtoDirectory();
+    const serviceMethods = [];
+    const types = [];
+    for (const file of listProtoFiles(protoDir)) {
+        const content = fs.readFileSync(file, "utf8");
+        const packageName = /^package\s+([a-zA-Z0-9_.]+);/m.exec(content)?.[1] ?? "unknown";
+        for (const match of content.matchAll(/^message\s+([A-Za-z0-9_]+)\s+\{/gm)) {
+            types.push({ packageName, kind: "message", name: match[1] ?? "unknown" });
+        }
+        for (const match of content.matchAll(/^enum\s+([A-Za-z0-9_]+)\s+\{/gm)) {
+            types.push({ packageName, kind: "enum", name: match[1] ?? "unknown" });
+        }
+        for (const serviceMatch of content.matchAll(/^service\s+([A-Za-z0-9_]+)\s+\{([\s\S]*?)^}/gm)) {
+            const service = serviceMatch[1] ?? "unknown";
+            const body = serviceMatch[2] ?? "";
+            for (const rpcMatch of body.matchAll(/^\s*rpc\s+([A-Za-z0-9_]+)\(([^)]+)\)\s+returns\s+\((stream\s+)?([^)]+)\)/gm)) {
+                serviceMethods.push({
+                    packageName,
+                    service,
+                    method: rpcMatch[1] ?? "unknown",
+                    inputType: rpcMatch[2] ?? "unknown",
+                    outputType: rpcMatch[4] ?? "unknown",
+                    serverStreaming: rpcMatch[3] !== undefined,
+                });
+            }
+        }
+    }
+    const docsDir = path.join(repoRoot, "docs");
+    fs.mkdirSync(docsDir, { recursive: true });
+    fs.writeFileSync(path.join(docsDir, "service-manifest.json"), `${JSON.stringify(serviceMethods, null, 2)}\n`);
+    fs.writeFileSync(path.join(docsDir, "type-manifest-summary.json"), `${JSON.stringify(types, null, 2)}\n`);
+    fs.writeFileSync(path.join(docsDir, "proto-inventory.md"), renderInventory(protoDir, serviceMethods, types));
+}
+function renderInventory(protoDir, serviceMethods, types) {
+    const services = new Map();
+    for (const method of serviceMethods) {
+        const key = `${method.packageName}.${method.service}`;
+        services.set(key, [...(services.get(key) ?? []), method]);
+    }
+    const streamingMethods = serviceMethods.filter((method) => method.serverStreaming).length;
+    const messages = types.filter((type) => type.kind === "message").length;
+    const enums = types.filter((type) => type.kind === "enum").length;
+    const lines = [
+        "# Proto Inventory",
+        "",
+        `Generated from the default proto directory: \`${path.relative(process.cwd(), protoDir)}\`.`,
+        "",
+        "## Extraction Summary",
+        "",
+        `- Services: ${services.size} total`,
+        `- RPC methods: ${serviceMethods.length} total`,
+        `- Server-streaming RPC methods: ${streamingMethods} total`,
+        `- Top-level messages: ${messages}`,
+        `- Top-level enums: ${enums}`,
+        `- Proto files: ${listProtoFiles(protoDir)
+            .map((file) => `\`${path.relative(process.cwd(), file)}\``)
+            .join(", ")}`,
+        "",
+        "## Important Caveats",
+        "",
+        "- Runtime interception remains route-policy allowlisted and fixture-backed.",
+        "- Unknown endpoints pass through unchanged by default.",
+        "- The extractor still logs a non-fatal Cursor bundle `TypeError` after processing services, then writes proto files successfully.",
+        "",
+        "## Services",
+        "",
+    ];
+    let index = 1;
+    for (const [service, methods] of Array.from(services.entries()).sort()) {
+        lines.push(`${index}. \`${service}\`: ${methods.length} RPCs${methods.some((method) => method.serverStreaming) ? `, ${methods.filter((method) => method.serverStreaming).length} streaming` : ""}`);
+        index++;
+    }
+    lines.push("", "## Service Methods", "");
+    for (const [service, methods] of Array.from(services.entries()).sort()) {
+        lines.push(`### \`${service}\``, "");
+        for (const method of methods) {
+            lines.push(`- \`${method.method}(${method.inputType}) returns (${method.serverStreaming ? "stream " : ""}${method.outputType})\``);
+        }
+        lines.push("");
+    }
+    return `${lines.join("\n")}\n`;
+}
+if (import.meta.url === `file://${process.argv[1]}`) {
+    generateProtoInventory();
+}

package/dist/src/tools/normalizeGeneratedCode.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/tools/normalizeGeneratedCode.js

@@ -0,0 +1,18 @@
+import fs from "node:fs";
+import path from "node:path";
+const GENERATED_ROOT = path.resolve(process.cwd(), "src", "gen");
+function normalizeGeneratedFiles(directory) {
+    for (const entry of fs.readdirSync(directory, { withFileTypes: true })) {
+        const fullPath = path.join(directory, entry.name);
+        if (entry.isDirectory()) {
+            normalizeGeneratedFiles(fullPath);
+        }
+        else if (entry.isFile() && entry.name.endsWith(".ts")) {
+            const content = fs.readFileSync(fullPath, "utf8");
+            fs.writeFileSync(fullPath, `${content.trimEnd()}\n`);
+        }
+    }
+}
+if (fs.existsSync(GENERATED_ROOT)) {
+    normalizeGeneratedFiles(GENERATED_ROOT);
+}

package/dist/src/tools/releaseCheck.d.ts

@@ -0,0 +1,26 @@
+export type GateStatus = "passed" | "failed" | "skipped_with_reason";
+export type ReleaseCategoryId = "baseline-drift" | "static" | "protocol" | "mlx" | "tool" | "desktop-optional-live" | "reliability-security" | "packaging" | "final-gate";
+export interface ReleaseGateStatusInput {
+    id: string;
+    status: GateStatus;
+    categories: ReleaseCategoryId[];
+}
+export interface OptionalLiveSuite {
+    id: string;
+    category: ReleaseCategoryId;
+    status: "skipped_with_reason";
+    reason: string;
+    command: string;
+    prerequisites: string[];
+}
+export interface ReleaseCategoryStatus {
+    id: ReleaseCategoryId;
+    status: GateStatus;
+    gateIds: string[];
+    optionalSuiteIds: string[];
+    summary: string;
+}
+export declare const REQUIRED_PACKAGE_ENTRIES: readonly ["package/package.json", "package/README.md", "package/DISCLAIMER.md", "package/dist/src/cli.js", "package/dist/src/cli.d.ts", "package/dist/src/ck.js", "package/dist/src/ck.d.ts", "package/proto/agent/v1/agent.proto", "package/proto/aiserver/v1/aiserver.proto", "package/docs/protocol.md", "package/docs/release-gates.md", "package/docs/testing-harness.md", "package/docs/test-manifest.json", "package/docs/route-contract-manifest.json", "package/docs/release-summary.json"];
+export declare const EXCLUDED_PACKAGE_ENTRY_PREFIXES: readonly ["package/examples/"];
+export declare function runReleaseCheck(repoRoot?: string): number;
+export declare function buildReleaseCategoryStatuses(results: ReleaseGateStatusInput[], optionalSuites?: OptionalLiveSuite[]): ReleaseCategoryStatus[];