knodin 0.8.7 → 0.9.0

package/dist/src/release-preflight.js

@@ -5,15 +5,6 @@ import path from "node:path";
 import { compareBytes } from "./compare.js";
 import { validateRootCeremonyManifest } from "./update-ceremony.js";
 import { canonicalizeUpdateMetadata, verifyUpdateRootChain, } from "./update-trust.js";
-export const RELEASE_PREFLIGHT_DEPENDENCIES = [
-    "C60",
-    "C62",
-    "C63",
-    "C64",
-    "C65",
-    "C66",
-    "C75",
-];
 export const RELEASE_PREFLIGHT_REPOSITORY_COMMANDS = [
     "npm ci --ignore-scripts",
     "npm run lint",
@@ -47,6 +38,20 @@ const COMMAND_CATEGORIES = [
     "attestation",
 ];
 const TARGET_PLATFORMS = ["macOS", "Linux", "Windows"];
+const VERIFIER_COVERAGE = [
+    "typescript",
+    "javascript",
+    "python",
+    "java",
+    "csharp",
+    "apex",
+    "sql",
+    "prisma",
+    "xml",
+    "salesforce",
+    "terraform",
+    "dbt",
+];
 const MAX_MANIFEST_BYTES = 1 * 1_024 * 1_024;
 const MAX_EVIDENCE_BYTES = 16 * 1_024 * 1_024;
 const MAX_TOTAL_EVIDENCE_BYTES = 128 * 1_024 * 1_024;
@@ -54,10 +59,8 @@ const COMMIT = /^(?:[a-f0-9]{40}|[a-f0-9]{64})$/;
 const SHA256 = /^[a-f0-9]{64}$/;
 const SEMVER = /^(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)\.(?:0|[1-9]\d*)(?:-(?:0|[1-9]\d*|[A-Za-z-][0-9A-Za-z-]*)(?:\.(?:0|[1-9]\d*|[A-Za-z-][0-9A-Za-z-]*))*)?(?:\+[0-9A-Za-z-]+(?:\.[0-9A-Za-z-]+)*)?$/;
 const REPOSITORY_PATH = /^[A-Za-z0-9._+/-]+$/;
-const IMMUTABLE_EVIDENCE_PATH = /^(?:docs\/evidence|benchmarks\/evaluations)\//;
 const RUNTIME_NAME = /^[a-z][a-z0-9._-]{0,31}$/;
 const RUNTIME_VERSION = /^[0-9A-Za-z][0-9A-Za-z._+-]{0,63}$/;
-const TERMINAL_STATUS = /^(?:implemented(?: \([^()\n]+\)| — [^\n]+)?|evaluated — [^\n]+|certified(?: with [^\n]+| — [^\n]+)?|closed(?:; [^\n]+| — [^\n]+)?|done(?: — [^\n]+)?)$/;
 function fail(message) {
     throw new Error(`release preflight failed: ${message}`);
 }
@@ -110,7 +113,7 @@ function parsePlan(value) {
         "trustCeremonyManifestPath",
         "trustReviewReceiptPath",
         "verificationCommands",
-        "dependencyEvidence",
+        "technicalEvidence",
         "evidenceDirectory",
     ], "release plan");
     if (plan.schemaVersion !== 1)
@@ -151,9 +154,8 @@ function parsePlan(value) {
         !runtimeNames.includes("npm"))
         fail("runtimes must uniquely include node and npm");
     const certifiedTargetPlatforms = boundedStringArray(plan.certifiedTargetPlatforms, "certified target platforms", { maximumItems: 3, maximumLength: 16 });
-    if (certifiedTargetPlatforms.length !== TARGET_PLATFORMS.length ||
-        TARGET_PLATFORMS.some((platform) => !certifiedTargetPlatforms.includes(platform)))
-        fail("certified target platforms must contain exactly macOS, Linux, and Windows");
+    if (certifiedTargetPlatforms.some((platform) => !TARGET_PLATFORMS.includes(platform)))
+        fail("certified target platforms may contain only macOS, Linux, or Windows");
     const trustRootSha256 = text(plan.trustRootSha256, "trust-root digest", 64);
     if (!SHA256.test(trustRootSha256))
         fail("trust-root digest must be a lowercase SHA-256 digest");
@@ -179,12 +181,23 @@ function parsePlan(value) {
             expected.some((command, index) => verificationCommands[category][index] !== command))
             fail(`${category} verification commands must equal the canonical ordered replay set`);
     }
-    const evidenceRecord = record(plan.dependencyEvidence, "dependency evidence");
-    exactKeys(evidenceRecord, RELEASE_PREFLIGHT_DEPENDENCIES, "dependency evidence");
-    const dependencyEvidence = {};
-    for (const dependency of RELEASE_PREFLIGHT_DEPENDENCIES) {
-        dependencyEvidence[dependency] = boundedStringArray(evidenceRecord[dependency], `${dependency} evidence paths`, { maximumItems: 32, maximumLength: 512 }).map((candidate, index) => safeRelativePath(candidate, `${dependency} evidence paths[${index}]`));
-    }
+    const technicalEvidenceRecord = record(plan.technicalEvidence, "technical evidence");
+    exactKeys(technicalEvidenceRecord, ["repository", "platforms"], "technical evidence");
+    const repositoryEvidencePath = safeRelativePath(technicalEvidenceRecord.repository, "repository technical evidence path");
+    if (!Array.isArray(technicalEvidenceRecord.platforms))
+        fail("platform technical evidence must be an array");
+    const platformEvidence = technicalEvidenceRecord.platforms.map((candidate, index) => {
+        const item = record(candidate, `platform technical evidence[${index}]`);
+        exactKeys(item, ["platform", "path"], `platform technical evidence[${index}]`);
+        return {
+            platform: text(item.platform, `platform technical evidence[${index}].platform`, 16),
+            path: safeRelativePath(item.path, `platform technical evidence[${index}].path`),
+        };
+    });
+    if (platformEvidence.length !== certifiedTargetPlatforms.length ||
+        new Set(platformEvidence.map(({ platform }) => platform)).size !== platformEvidence.length ||
+        certifiedTargetPlatforms.some((platform) => !platformEvidence.some((evidence) => evidence.platform === platform)))
+        fail("platform technical evidence must exactly cover certified target platforms");
     return {
         schemaVersion: 1,
         version,
@@ -198,7 +211,10 @@ function parsePlan(value) {
         trustCeremonyManifestPath,
         trustReviewReceiptPath,
         verificationCommands,
-        dependencyEvidence,
+        technicalEvidence: {
+            repository: repositoryEvidencePath,
+            platforms: platformEvidence,
+        },
         evidenceDirectory: safeRelativePath(plan.evidenceDirectory, "evidence directory"),
     };
 }
@@ -318,42 +334,6 @@ function requireTaggedBytes(git, commit, relativePath, bytes, label) {
     if (!tagged.equals(bytes))
         fail(`${label} bytes do not equal the exact source-commit blob`);
 }
-function verifyRoadmap(roadmap) {
-    const activeLedger = /### Track A — Active local-work ledger\n[\s\S]*?\n\| ID \| State \| Previous state \| Depends on \| Exit evidence \|\n\|---\|---\|---\|---\|---\|\n((?:\| C[^\n]+\n)*)\n### Track B — Parked external-evidence ledger/.exec(roadmap);
-    const parkedLedger = /### Track B — Parked external-evidence ledger\n[\s\S]*?\n\| ID \| State \| Previous state \| Depends on \| Exit evidence \|\n\|---\|---\|---\|---\|---\|\n((?:\| C[^\n]+\n)*)\n### Goal-loop ordering/.exec(roadmap);
-    if (!activeLedger || !parkedLedger)
-        fail("two-track roadmap ledger is missing or malformed");
-    const activeIds = new Set([...activeLedger[1].matchAll(/^\| (C\d+) \|/gm)].map((match) => match[1]));
-    const parkedIds = new Set([...parkedLedger[1].matchAll(/^\| (C\d+) \|/gm)].map((match) => match[1]));
-    if (parkedIds.size > 0)
-        fail(`Track B remains parked (${parkedIds.size} external item${parkedIds.size === 1 ? "" : "s"}: ${[...parkedIds].join(", ")})`);
-    const evidencePaths = new Map();
-    for (const dependency of RELEASE_PREFLIGHT_DEPENDENCIES) {
-        if (activeIds.has(dependency))
-            fail(`${dependency} remains in Track A`);
-        const header = dependency === "C75" ? "C69–C75" : dependency;
-        const section = new RegExp(String.raw `(^#{2,3} ${header} —[^\n]*\n[\s\S]*?)(?=^#{2,3} C(?:\d+|\d+–C\d+) —|(?![\s\S]))`, "m").exec(roadmap);
-        if (!section)
-            fail(`${dependency} has no authoritative item status`);
-        const statusMatch = /^- Status: ([^\n]+)$/m.exec(section[1]);
-        if (!statusMatch)
-            fail(`${dependency} has no authoritative item status`);
-        const status = statusMatch[1].trim();
-        if (!TERMINAL_STATUS.test(status))
-            fail(`${dependency} has nonterminal status ${JSON.stringify(status)}`);
-        const evidenceLabel = dependency === "C75" ? "C75 Evidence" : "Evidence";
-        const evidenceField = new RegExp(String.raw `^- ${evidenceLabel}: ([\s\S]*?)(?=\n\n|\n- [A-Z][^\n]*:|(?![\s\S]))`, "m").exec(section[1]);
-        if (!evidenceField)
-            fail(`${dependency} has no explicit authoritative evidence field`);
-        const paths = [...evidenceField[1].matchAll(/`([^`]+)`/g)].map((match) => match[1]);
-        if (paths.length === 0 || new Set(paths).size !== paths.length)
-            fail(`${dependency} authoritative evidence field must name distinct paths`);
-        if (!paths.some((candidate) => IMMUTABLE_EVIDENCE_PATH.test(candidate)))
-            fail(`${dependency} must declare at least one immutable evidence or evaluation path`);
-        evidencePaths.set(dependency, paths);
-    }
-    return evidencePaths;
-}
 function verifyFreshEvidenceDirectory(repositoryRoot, plan) {
     const expected = `docs/evidence/releases/${plan.version}`;
     if (plan.evidenceDirectory !== expected)
@@ -381,9 +361,8 @@ function verifyFreshEvidenceDirectory(repositoryRoot, plan) {
 }
 function verifyProductionTrust(plan, evidence) {
     const paths = [plan.trustRootPath, plan.trustCeremonyManifestPath, plan.trustReviewReceiptPath];
-    if (new Set(paths).size !== paths.length ||
-        paths.some((candidate) => !plan.dependencyEvidence.C62.includes(candidate)))
-        fail("production trust artifacts must be three distinct C62 dependency-evidence paths");
+    if (new Set(paths).size !== paths.length)
+        fail("production trust artifacts must be three distinct paths");
     const rootBytes = evidence.get(plan.trustRootPath);
     const manifestBytes = evidence.get(plan.trustCeremonyManifestPath);
     const receiptBytes = evidence.get(plan.trustReviewReceiptPath);
@@ -416,7 +395,7 @@ function verifyProductionTrust(plan, evidence) {
         fail(`production trust root must be a valid self-threshold-signed root envelope: ${error instanceof Error ? error.message : "invalid root"}`);
     }
     if (digest !== plan.trustRootSha256)
-        fail("trust-root digest does not match the canonical C62 root envelope");
+        fail("trust-root digest does not match the canonical root envelope");
     const receipt = record(parseJson(receiptBytes, "production root review receipt"), "production root review receipt");
     exactKeys(receipt, [
         "schemaVersion",
@@ -434,14 +413,58 @@ function verifyProductionTrust(plan, evidence) {
         receipt.ceremonyId !== manifest.ceremonyId ||
         receipt.rootEnvelopeSha256 !== digest ||
         typeof receipt.reviewerId !== "string" ||
-        manifest.custodians.some(({ id }) => id === receipt.reviewerId) ||
+        !manifest.custodians.some(({ id }) => id === receipt.reviewerId) ||
         receipt.decision !== "approved" ||
-        receipt.authentication !== "externally-authenticated" ||
+        receipt.authentication !== "maintainer-attested" ||
         receipt.productionActivation !== false ||
         !Number.isFinite(reviewedTime.getTime()) ||
         reviewedTime.toISOString() !== reviewedAt ||
         reviewedTime.getTime() > Date.now())
-        fail("production root review receipt is not independent, authenticated, and digest-bound");
+        fail("production root attestation is not maintainer-owned, timestamped, and digest-bound");
+}
+function verifyTechnicalEvidence(plan, evidence) {
+    const repository = record(parseJson(evidence.get(plan.technicalEvidence.repository) ?? Buffer.alloc(0), "repository technical evidence"), "repository technical evidence");
+    if (repository.schemaVersion !== 1 ||
+        repository.sourceCommit !== plan.sourceCommit ||
+        repository.passed !== true ||
+        repository.sonarQualityGate !== "passed")
+        fail("repository technical evidence must be source-bound with passing gates and Sonar");
+    const commandResults = repository.commands;
+    const expectedCommands = COMMAND_CATEGORIES.flatMap((category) => plan.verificationCommands[category].map((command) => ({ category, command })));
+    if (!Array.isArray(commandResults) ||
+        commandResults.length !== expectedCommands.length ||
+        expectedCommands.some((expected, index) => {
+            const actual = commandResults[index];
+            return (!actual ||
+                typeof actual !== "object" ||
+                actual.category !== expected.category ||
+                actual.command !== expected.command ||
+                actual.exitCode !== 0);
+        }))
+        fail("repository technical evidence must record every canonical command with exit code zero");
+    for (const declared of plan.technicalEvidence.platforms) {
+        const platform = record(parseJson(evidence.get(declared.path) ?? Buffer.alloc(0), `${declared.platform} technical evidence`), `${declared.platform} technical evidence`);
+        const runs = platform.runsMs;
+        const coverage = platform.coverage;
+        if (platform.schemaVersion !== 1 ||
+            platform.sourceCommit !== plan.sourceCommit ||
+            platform.platform !== declared.platform ||
+            platform.passed !== true ||
+            platform.fixtureVersion !== "2026-08-14.2" ||
+            platform.silentEmptyControl !== "failed-as-expected" ||
+            !Array.isArray(runs) ||
+            runs.length !== 5 ||
+            runs.some((run) => typeof run !== "number" || run < 0 || run > 60_000) ||
+            typeof platform.verifierP95Ms !== "number" ||
+            platform.verifierP95Ms < 0 ||
+            platform.verifierP95Ms > 20_000 ||
+            platform.verifierP95Ms !== Math.max(...runs) ||
+            platform.verifierHardLimitMs !== 60_000 ||
+            !coverage ||
+            typeof coverage !== "object" ||
+            VERIFIER_COVERAGE.some((language) => coverage[language] !== "passed"))
+            fail(`${declared.platform} technical evidence does not satisfy the verifier budget`);
+    }
 }
 export function evaluateReleasePreflight(options) {
     const repositoryRoot = fs.realpathSync(options.repositoryRoot);
@@ -467,39 +490,28 @@ export function evaluateReleasePreflight(options) {
     if (!git.isTracked(workflowFile.relativePath))
         fail("C64 candidate workflow must be checked in");
     requireTaggedBytes(git, plan.sourceCommit, workflowFile.relativePath, workflowFile.bytes, "C64 candidate workflow");
-    const roadmapFile = readBoundedRegularFile(repositoryRoot, path.join(repositoryRoot, "roadmap/competitive-roadmap.md"), "authoritative roadmap", MAX_EVIDENCE_BYTES);
-    if (!git.isTracked(roadmapFile.relativePath))
-        fail("authoritative roadmap must be checked in");
-    requireTaggedBytes(git, plan.sourceCommit, roadmapFile.relativePath, roadmapFile.bytes, "authoritative roadmap");
-    const roadmapEvidence = verifyRoadmap(roadmapFile.bytes.toString("utf8"));
     let totalEvidenceBytes = 0;
-    const uniquePaths = new Set();
     const evidenceBytes = new Map();
-    for (const dependency of RELEASE_PREFLIGHT_DEPENDENCIES) {
-        const declared = plan.dependencyEvidence[dependency];
-        const authoritative = roadmapEvidence.get(dependency) ?? [];
-        if (declared.length !== authoritative.length ||
-            [...declared]
-                .sort(compareBytes)
-                .some((candidate, index) => candidate !== [...authoritative].sort(compareBytes)[index]))
-            fail(`${dependency} evidence paths must equal its complete authoritative Evidence field`);
-        for (const relativePath of plan.dependencyEvidence[dependency]) {
-            if (uniquePaths.has(relativePath))
-                fail(`evidence path is declared more than once: ${relativePath}`);
-            uniquePaths.add(relativePath);
-            const evidence = readBoundedRegularFile(repositoryRoot, path.join(repositoryRoot, relativePath), `${dependency} evidence ${relativePath}`, MAX_EVIDENCE_BYTES);
-            if (evidence.relativePath !== relativePath)
-                fail(`${dependency} evidence path must be normalized`);
-            if (!git.isTracked(relativePath))
-                fail(`${dependency} evidence must be checked in: ${relativePath}`);
-            requireTaggedBytes(git, plan.sourceCommit, relativePath, evidence.bytes, `${dependency} evidence ${relativePath}`);
-            evidenceBytes.set(relativePath, evidence.bytes);
-            totalEvidenceBytes += evidence.size;
-            if (totalEvidenceBytes > MAX_TOTAL_EVIDENCE_BYTES)
-                fail("dependency evidence exceeds the aggregate byte budget");
-        }
+    for (const relativePath of [
+        plan.trustRootPath,
+        plan.trustCeremonyManifestPath,
+        plan.trustReviewReceiptPath,
+        plan.technicalEvidence.repository,
+        ...plan.technicalEvidence.platforms.map(({ path: evidencePath }) => evidencePath),
+    ]) {
+        const evidence = readBoundedRegularFile(repositoryRoot, path.join(repositoryRoot, relativePath), `production trust artifact ${relativePath}`, MAX_EVIDENCE_BYTES);
+        if (evidence.relativePath !== relativePath)
+            fail("production trust artifact path must be normalized");
+        if (!git.isTracked(relativePath))
+            fail(`production trust artifact must be checked in: ${relativePath}`);
+        requireTaggedBytes(git, plan.sourceCommit, relativePath, evidence.bytes, `production trust artifact ${relativePath}`);
+        evidenceBytes.set(relativePath, evidence.bytes);
+        totalEvidenceBytes += evidence.size;
+        if (totalEvidenceBytes > MAX_TOTAL_EVIDENCE_BYTES)
+            fail("production trust artifacts exceed the aggregate byte budget");
     }
     verifyProductionTrust(plan, evidenceBytes);
+    verifyTechnicalEvidence(plan, evidenceBytes);
     verifyFreshEvidenceDirectory(repositoryRoot, plan);
     return {
         ok: true,
@@ -508,6 +520,5 @@ export function evaluateReleasePreflight(options) {
         sourceCommit: plan.sourceCommit,
         workflowCommit: plan.workflow.commit,
         evidenceDirectory: plan.evidenceDirectory,
-        dependencies: [...RELEASE_PREFLIGHT_DEPENDENCIES],
     };
 }

package/dist/src/repair-lease.js

@@ -1,10 +1,24 @@
+import child_process from "node:child_process";
 import crypto from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
+import { acquireLifecycleCoordination } from "./update-coordination.js";
 const MAX_LEASE_BYTES = 4_096;
 function leasePath(repo) {
     return path.join(path.resolve(repo), ".knodin", "repair.lock");
 }
+function activityPath(repo) {
+    return path.join(path.resolve(repo), ".knodin", "lifecycle-activity.json");
+}
+function writeActivity(repo, record, finishedAt) {
+    const target = activityPath(repo);
+    const temporary = `${target}.${record.nonce}.tmp`;
+    fs.writeFileSync(temporary, `${JSON.stringify({ ...record, finishedAt: finishedAt ?? null })}\n`, {
+        encoding: "utf8",
+        mode: 0o600,
+    });
+    fs.renameSync(temporary, target);
+}
 function processIsAlive(pid) {
     try {
         process.kill(pid, 0);
@@ -14,17 +28,36 @@ function processIsAlive(pid) {
         return false;
     }
 }
+function processStartToken(pid) {
+    try {
+        return (child_process
+            .execFileSync("ps", ["-o", "lstart=", "-p", String(pid)], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"],
+        })
+            .trim() || null);
+    }
+    catch {
+        return null;
+    }
+}
 function readLease(target) {
     try {
         const stat = fs.statSync(target);
         if (!stat.isFile() || stat.size <= 0 || stat.size > MAX_LEASE_BYTES)
             return null;
         const value = JSON.parse(fs.readFileSync(target, "utf8"));
-        if (value.schemaVersion !== 1 ||
+        if (value.schemaVersion !== 2 ||
             !Number.isInteger(value.pid) ||
             (value.pid ?? 0) <= 0 ||
             typeof value.startedAt !== "string" ||
             !Number.isFinite(Date.parse(value.startedAt)) ||
+            typeof value.processStartToken !== "string" ||
+            !value.processStartToken ||
+            typeof value.command !== "string" ||
+            !value.command ||
+            typeof value.repository !== "string" ||
+            !path.isAbsolute(value.repository) ||
             typeof value.nonce !== "string" ||
             !value.nonce)
             return null;
@@ -43,7 +76,9 @@ function writeLease(target, record) {
 }
 function removeStaleLeaseOrThrow(target, operation) {
     const current = readLease(target);
-    if (current && processIsAlive(current.pid)) {
+    if (current &&
+        processIsAlive(current.pid) &&
+        processStartToken(current.pid) === current.processStartToken) {
         const contention = operation === "repair"
             ? "another repair is already in progress"
             : "another lifecycle mutation is already in progress";
@@ -61,28 +96,62 @@ function removeStaleLeaseOrThrow(target, operation) {
 export function acquireRepairLease(repo, operation = "repair") {
     const target = leasePath(repo);
     fs.mkdirSync(path.dirname(target), { recursive: true });
+    const lifecycleCommand = [
+        "repair",
+        "init",
+        "configure",
+        "index",
+        "lifecycle-hook",
+    ].includes(operation)
+        ? operation
+        : "repair";
+    const coordination = acquireLifecycleCoordination({
+        command: lifecycleCommand,
+        repository: repo,
+        verificationToken: process.env.KNODIN_UPDATE_VERIFICATION_TOKEN,
+    });
     const record = {
-        schemaVersion: 1,
+        schemaVersion: 2,
         pid: process.pid,
         startedAt: new Date().toISOString(),
+        processStartToken: processStartToken(process.pid) ?? `node-start-${Date.now() - process.uptime() * 1000}`,
+        command: operation,
+        repository: path.resolve(repo),
         nonce: crypto.randomUUID(),
     };
     for (let attempt = 0; attempt < 2; attempt += 1) {
         try {
             writeLease(target, record);
+            writeActivity(repo, record);
             return {
                 release() {
-                    const current = readLease(target);
-                    if (current?.nonce === record.nonce)
-                        fs.rmSync(target, { force: true });
+                    try {
+                        const current = readLease(target);
+                        if (current?.nonce === record.nonce) {
+                            writeActivity(repo, record, new Date().toISOString());
+                            fs.rmSync(target, { force: true });
+                        }
+                    }
+                    finally {
+                        coordination.release();
+                    }
                 },
             };
         }
         catch (error) {
-            if (error.code !== "EEXIST")
+            if (error.code !== "EEXIST") {
+                coordination.release();
                 throw error;
-            removeStaleLeaseOrThrow(target, operation);
+            }
+            try {
+                removeStaleLeaseOrThrow(target, operation);
+            }
+            catch (error_) {
+                coordination.release();
+                throw error_;
+            }
         }
     }
+    coordination.release();
     throw new Error(`knodin ${operation}: could not acquire the repository lifecycle lease; retry shortly`);
 }

package/dist/src/response-budget.js

@@ -42,9 +42,11 @@ const PROTECTED_CONTRACT_KEYS = new Set([
     "operation",
     "kind",
     "name",
+    "client",
     "target",
     "to",
 ]);
+const PROTECTED_CONTRACT_ARRAY_PATHS = new Set(["$/agents/clients"]);
 function isTruncatableDetail(entry) {
     return (!entry.path.startsWith("$/sharedIndex/") &&
         (typeof entry.key !== "string" || !PROTECTED_CONTRACT_KEYS.has(entry.key)));
@@ -105,7 +107,9 @@ function truncatePayloadToBytes(root, byteLimit) {
     }
     while (bytes(root) > byteLimit) {
         const candidate = collectArrays(root)
-            .filter((entry) => !entry.path.startsWith("$/responseBudget") && entry.value.length > 0)
+            .filter((entry) => !entry.path.startsWith("$/responseBudget") &&
+            !PROTECTED_CONTRACT_ARRAY_PATHS.has(entry.path) &&
+            entry.value.length > 0)
             .sort((a, b) => bytes(b.value) - bytes(a.value))[0];
         if (!candidate)
             break;

package/dist/src/server.js

@@ -23,6 +23,7 @@ const RETRY_SAFE_OPERATIONS = new Set([
     "explain",
     "map",
     "query",
+    "query_batch",
     "review",
     "search",
     "status",
@@ -69,7 +70,9 @@ export function recordMcpDiagnosticFailure(args, error, defaultRepo = process.cw
     });
     const message = error instanceof Error ? error.message : String(error);
     return diagnostic.recorded
-        ? new Error(`${message} [diagnostic ${diagnostic.correlationId}]`, { cause: error })
+        ? new Error(`${message} [diagnostic ${diagnostic.correlationId}]`, {
+            cause: error,
+        })
         : error;
 }
 export function createServer(dispatch = handleKnodinTool) {
@@ -111,7 +114,11 @@ export function createServer(dispatch = handleKnodinTool) {
                         void extra
                             .sendNotification({
                             method: "notifications/progress",
-                            params: { progressToken, progress: sequence, message: phase },
+                            params: {
+                                progressToken,
+                                progress: sequence,
+                                message: phase,
+                            },
                         })
                             .catch(ignoreNotificationFailure);
                 })
@@ -121,7 +128,9 @@ export function createServer(dispatch = handleKnodinTool) {
                             if (progressToken === undefined)
                                 return;
                             progressSequence++;
-                            recordMcpLifecycle(context, "progress", { sequence: progressSequence });
+                            recordMcpLifecycle(context, "progress", {
+                                sequence: progressSequence,
+                            });
                             await extra.sendNotification({
                                 method: "notifications/progress",
                                 params: {
@@ -143,7 +152,9 @@ export function createServer(dispatch = handleKnodinTool) {
                     }, { cooperativeCancellation: operation === "repair" })),
                 };
             const result = execution.result;
-            recordMcpLifecycle(context, "success", { elapsedMs: Date.now() - startedAt });
+            recordMcpLifecycle(context, "success", {
+                elapsedMs: Date.now() - startedAt,
+            });
             return {
                 _meta: {
                     requestId: context.requestId,
@@ -192,7 +203,9 @@ export function createServer(dispatch = handleKnodinTool) {
         finally {
             if (heartbeat)
                 clearInterval(heartbeat);
-            recordMcpLifecycle(context, "cleanup", { elapsedMs: Date.now() - startedAt });
+            recordMcpLifecycle(context, "cleanup", {
+                elapsedMs: Date.now() - startedAt,
+            });
         }
     });
     return server;

package/dist/src/shared-index/compatibility.js

@@ -2,7 +2,7 @@ import fs from "node:fs";
 import { createRequire } from "node:module";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
-import { EMBEDDING_DIMENSIONS, EMBEDDING_MODEL_ID, EMBEDDING_MODEL_REVISION, } from "../engine/embeddings.js";
+import { EMBEDDING_DIMENSIONS, EMBEDDING_MODEL_DTYPE, EMBEDDING_MODEL_ID, EMBEDDING_MODEL_REVISION, } from "../engine/embeddings.js";
 import { KNODIN_SCHEMA_VERSION } from "../engine/index.js";
 import { prunePolicyDescriptor } from "../engine/prune.js";
 import { KNODIN_VERSION } from "../version.js";
@@ -44,6 +44,7 @@ export function currentSharedIndexCompatibility() {
         id: EMBEDDING_MODEL_ID,
         revision: EMBEDDING_MODEL_REVISION,
         dimensions: EMBEDDING_DIMENSIONS,
+        dtype: EMBEDDING_MODEL_DTYPE,
         runtime: `@huggingface/transformers@${packageVersion("@huggingface/transformers")}`,
     };
     const parsers = {
@@ -61,9 +62,10 @@ export function currentSharedIndexCompatibility() {
         modelDigest: digest(model),
         parserBundleDigest: digest(parsers),
         indexConfigDigest: digest({
-            policyVersion: 1,
+            policyVersion: 2,
             databaseSchemaVersion: KNODIN_SCHEMA_VERSION,
             embeddingDimensions: EMBEDDING_DIMENSIONS,
+            embeddingDtype: EMBEDDING_MODEL_DTYPE,
         }),
         prunePolicyDigest: digest(prunePolicyDescriptor()),
     };