akm-cli 0.9.31 → 0.10.26101001-alpha

package/dist/commands/health/checks.js

@@ -11,6 +11,8 @@ import { withEngineFallback } from "../../integrations/agent/engine-fallback.js"
 import { isLlmCredentialAvailable, resolveEngine, } from "../../integrations/agent/engine-resolution.js";
 import { executionEngineDefinitionsFromConfig } from "../../integrations/agent/execution.js";
 import { loadModelMap, mergeModelMapLayers, parseModelMapLayer, readInstalledModelMapText, resolveModelMapAlias, userModelMapPath, } from "../../integrations/agent/model-map.js";
+import { detectOpencodeMajor, resolveOpencodeBin, } from "../../integrations/harnesses/opencode/version.js";
+import { OPENCODE_CLIENT_PACKAGE } from "../../integrations/harnesses/opencode-sdk/wire.js";
 import { probeEndpointOnce } from "../../llm/client.js";
 import { STATE_DB_FREELIST_WARN_RATIO, } from "../../storage/state-db-integrity.js";
 import { listKeys } from "../env/env.js";
@@ -116,20 +118,15 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
     const env = deps.env ?? process.env;
     const configuredEngine = config.engines?.[engineName];
     if (configuredEngine?.kind === "agent" && configuredEngine.platform === "opencode-sdk") {
-        let packageAvailable = false;
+        const binary = resolveOpencodeBin(configuredEngine.bin);
+        let detected;
         try {
-            const resolvePackage = deps.resolvePackage ?? ((name) => import.meta.resolve(name));
-            resolvePackage("@opencode-ai/sdk");
-            packageAvailable = true;
-        }
-        catch {
-            packageAvailable = false;
-        }
-        const binary = configuredEngine.bin ?? "opencode";
-        let binaryAvailable;
-        try {
-            const version = (deps.spawnSync ?? spawnSync)(binary, ["--version"], { encoding: "utf8", timeout: 5_000 });
-            binaryAvailable = (version.status ?? 1) === 0;
+            detected = detectOpencodeMajor(binary, {
+                probe: (bin) => {
+                    const run = (deps.spawnSync ?? spawnSync)(bin, ["--version"], { encoding: "utf8", timeout: 5_000 });
+                    return (run.status ?? 1) === 0 ? String(run.stdout ?? "").trim() : undefined;
+                },
+            });
         }
         catch {
             return {
@@ -141,6 +138,18 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
                 evidence: { engine: engineName, runtimeKind: "sdk", binaryAvailable: false },
             };
         }
+        const binaryAvailable = detected.runnable;
+        // The client package of the OpenCode major the binary reports; never the other major's.
+        const clientPackage = OPENCODE_CLIENT_PACKAGE[detected.major];
+        let packageAvailable = false;
+        try {
+            const resolvePackage = deps.resolvePackage ?? ((name) => import.meta.resolve(name));
+            resolvePackage(clientPackage);
+            packageAvailable = true;
+        }
+        catch {
+            packageAvailable = false;
+        }
         const fallbackEngine = configuredEngine.llmEngine;
         let fallback;
         let fallbackCredential;
@@ -183,7 +192,7 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
             ? findSuppliedByEnvAsset(fallbackCredential, deps)
             : null;
         const missing = [
-            !packageAvailable ? "@opencode-ai/sdk package" : undefined,
+            !packageAvailable ? `${clientPackage} package` : undefined,
             !binaryAvailable ? `${binary} binary` : undefined,
             fallbackEngine && !fallback ? "configured fallback LLM connection" : undefined,
             !fallbackCredentialAvailable
@@ -198,7 +207,9 @@ async function runConfiguredEngineProbe(checkName, engineName, config, deps, rea
             runtimeKind: "sdk",
             binary,
             binaryAvailable,
-            package: "@opencode-ai/sdk",
+            package: clientPackage,
+            detectedVersion: detected.version || null,
+            detectedMajor: detected.major,
             packageAvailable,
             model: effectiveModel ?? null,
             configuredModel: configuredModel ?? null,
@@ -533,7 +544,21 @@ export function probeActiveImproveStrategy(deps = {}) {
         const requiredModelProcessNames = modelProcessNames.filter((name) => plan.processes[name].enabled || plan.engineUnavailable.some((item) => item.process === name));
         const availableModelProcessNames = modelProcessNames.filter((name) => plan.processes[name].enabled);
         const allRequiredUnavailable = requiredModelProcessNames.length > 0 && availableModelProcessNames.length === 0;
-        const status = unavailableProcesses.length === 0 ? "pass" : allRequiredUnavailable ? "fail" : "warn";
+        // No engine configured at all (no unavailable item carries a resolved engine)
+        // is "not set up yet", not a broken credential: it keeps the unknown/warn
+        // result it had when the plan threw for it. Engine-free deterministic triage
+        // (#1143) now lets such a plan resolve, so this has to be explicit.
+        const noEngineConfigured = plan.engineUnavailable.length > 0 && plan.engineUnavailable.every((i) => !i.engine);
+        const explicitlyConfigured = config.defaults?.improveStrategy !== undefined || Object.keys(config.improve?.strategies ?? {}).length > 0;
+        const status = unavailableProcesses.length === 0
+            ? "pass"
+            : allRequiredUnavailable
+                ? noEngineConfigured
+                    ? explicitlyConfigured
+                        ? "warn"
+                        : "unknown"
+                    : "fail"
+                : "warn";
         return {
             check: {
                 name: "active-improve-strategy",

package/dist/commands/health/plugin-staleness.js

@@ -52,6 +52,7 @@ import { spawnSync } from "node:child_process";
 import fs from "node:fs";
 import os from "node:os";
 import path from "node:path";
+import { OPENCODE_V1, OPENCODE_V2, readPackageVersion, } from "../../integrations/harnesses/opencode/plugin-layout.js";
 import { isExactSemver, isSemverRange, maxSatisfying, satisfiesRange } from "../../registry/semver.js";
 /**
  * Root directory holding Claude Code's plugin cache + marketplace clones.
@@ -66,41 +67,69 @@ function claudePluginsDir() {
 /**
  * Root of OpenCode's package cache, same override pattern as
  * {@link claudePluginsDir} (`AKM_OPENCODE_CACHE_DIR` for tests).
- * The OpenCode plugin (`akm-opencode`) bundles its own `akm-cli` under
- * `packages/akm-opencode/node_modules/akm-cli` and runs it in-process,
+ * The OpenCode plugins (`akm-opencode`, and `akm-opencode-v2` for OpenCode 2) bundle their own `akm-cli`
+ * (layout: `integrations/harnesses/opencode/plugin-layout.ts`) and run it in-process,
  * sharing the host's databases with every other akm install — its version
  * lag matters the same way a stale Claude plugin's does.
  */
 function opencodeCacheDir() {
     return process.env.AKM_OPENCODE_CACHE_DIR ?? path.join(os.homedir(), ".cache", "opencode");
 }
+const OPENCODE_PLUGIN_LOCATIONS = [
+    {
+        // OpenCode 1: <cache>/packages/akm-opencode/node_modules/akm-cli (the folder read since this check began).
+        flavor: OPENCODE_V1,
+        advisory: "opencode-plugin-version",
+        label: "OpenCode's",
+        remedy: "update the OpenCode plugin",
+        folders: (cacheRoot) => [{ folder: path.join(cacheRoot, OPENCODE_V1.cacheFolder(OPENCODE_V1.pkg)) }],
+    },
+    {
+        // OpenCode 2: <cache>/npm/akm-opencode-v2@<spec>/<epoch-ms>/node_modules/akm-cli, newest build per spec.
+        flavor: OPENCODE_V2,
+        advisory: "opencode-v2-plugin-version",
+        label: "OpenCode 2's akm-opencode-v2",
+        remedy: "update the akm-opencode-v2 plugin",
+        folders: (cacheRoot) => {
+            const npmDir = path.join(cacheRoot, OPENCODE_V2.cacheFolder(""));
+            let specs;
+            try {
+                specs = fs.readdirSync(npmDir).filter((name) => name.startsWith(`${OPENCODE_V2.pkg}@`));
+            }
+            catch {
+                return [];
+            }
+            return specs.sort().map((spec) => ({ spec, folder: path.join(npmDir, spec) }));
+        },
+    },
+];
 /**
- * Read the OpenCode plugin's bundled `akm-cli` version from its
- * `package.json` — never executed, just parsed, mirroring
- * {@link detectInstalledPlugins}'s manifest read. `undefined` when the
- * OpenCode plugin, or its bundled akm-cli, is not installed.
+ * The bundled `akm-cli` of each cached copy of `plugin`: its `package.json` is read, never executed,
+ * mirroring {@link detectInstalledPlugins}'s manifest read. Copies with no bundled akm-cli are skipped.
  */
-function detectOpencodeBundledAkmVersion(cacheRoot) {
-    const pkgPath = path.join(cacheRoot, "packages", "akm-opencode", "node_modules", "akm-cli", "package.json");
-    try {
-        const pkg = JSON.parse(fs.readFileSync(pkgPath, "utf8"));
-        return typeof pkg.version === "string" ? pkg.version : undefined;
-    }
-    catch {
-        return undefined;
+function findBundledAkm(plugin, cacheRoot) {
+    const found = [];
+    for (const { spec, folder } of plugin.folders(cacheRoot)) {
+        const nodeModules = plugin.flavor.nodeModulesDir(folder);
+        const version = nodeModules && readPackageVersion(path.join(nodeModules, "akm-cli", "package.json"));
+        if (version !== undefined)
+            found.push(spec ? { spec, version } : { version });
     }
+    return found;
 }
-function buildOpencodeBundledAdvisory(bundledVersion, cliVersion) {
+function buildOpencodeBundledAdvisory(plugin, bundled, cliVersion) {
+    const bundledVersion = bundled.version;
     const stale = bundledVersion !== cliVersion;
+    const where = bundled.spec ? ` (${bundled.spec})` : "";
     return {
-        name: "opencode-plugin-version",
+        name: plugin.advisory,
         kind: "deterministic",
         status: stale ? "warn" : "pass",
         confidence: "high",
         message: stale
-            ? `OpenCode's bundled akm-cli is v${bundledVersion}, but the running CLI is v${cliVersion} — it shares the same databases in-process; update the OpenCode plugin.`
-            : `OpenCode's bundled akm-cli matches the running v${cliVersion}.`,
-        evidence: { bundledVersion, cliVersion },
+            ? `${plugin.label} bundled akm-cli${where} is v${bundledVersion}, but the running CLI is v${cliVersion} — it shares the same databases in-process; ${plugin.remedy}.`
+            : `${plugin.label} bundled akm-cli${where} matches the running v${cliVersion}.`,
+        evidence: bundled.spec ? { bundledVersion, cliVersion, spec: bundled.spec } : { bundledVersion, cliVersion },
     };
 }
 /**
@@ -218,9 +247,10 @@ export function collectPluginStalenessAdvisories(options) {
     const plugins = detectInstalledPlugins(pluginsRoot);
     const results = plugins.map((plugin) => buildAdvisory(plugin, options.cliVersion, pluginsRoot, listRemoteTags));
     const opencodeCacheRoot = options.opencodeCacheRoot ?? opencodeCacheDir();
-    const bundledVersion = detectOpencodeBundledAkmVersion(opencodeCacheRoot);
-    if (bundledVersion !== undefined) {
-        results.push(buildOpencodeBundledAdvisory(bundledVersion, options.cliVersion));
+    for (const plugin of OPENCODE_PLUGIN_LOCATIONS) {
+        for (const bundled of findBundledAkm(plugin, opencodeCacheRoot)) {
+            results.push(buildOpencodeBundledAdvisory(plugin, bundled, options.cliVersion));
+        }
     }
     return results;
 }

package/dist/commands/improve/autonomy-gate.js

@@ -6,7 +6,7 @@ import { IMPROVE_AUTONOMY_CONFIG_KEY, isImproveAutonomyEnabled, } from "../../co
 export const AUTONOMY_LANES = ["memoryInference", "triagePromote", "memoryCleanup"];
 const LANE_REASONS = {
     memoryInference: "writes derived memory children and rewrites parent frontmatter",
-    triagePromote: "auto-accepts queued proposals into the stash (downgraded to queue)",
+    triagePromote: "auto-accepts queued proposals the triage judgment tier approves (downgraded to queue)",
     memoryCleanup: "rewrites belief-state frontmatter and moves files into the cleanup archive",
 };
 /**
@@ -59,8 +59,10 @@ export function applyAutonomyGate(strategy, config) {
     }
     // Triage stays ENABLED — queued proposals are still triaged, they just are not
     // auto-accepted. Disabling it would remove review work the user asked for,
-    // which is the opposite of what a review-first default should do.
-    if (processes.triage?.applyMode === "promote") {
+    // which is the opposite of what a review-first default should do. Only a
+    // promote that runs the judgment tier is gated (#1143); a deterministic-only
+    // promote is the default and needs no opt-in.
+    if (processes.triage?.applyMode === "promote" && processes.triage.judgment?.enabled === true) {
         processes.triage = { ...processes.triage, applyMode: "queue" };
         gated.push(gatedLane("triagePromote"));
     }

package/dist/commands/improve/consolidate/pair-pass.js

@@ -465,7 +465,13 @@ function orderByAge(x, y) {
 }
 /** The user message: dates decide "A (older)" / "B (newer)" (plan Appendix A), matching the calibration sample's own ordering. */
 export function buildPairUserPrompt(older, newer) {
-    return [...sideSection("A (older)", older), ...sideSection("B (newer)", newer)].join("\n");
+    // Equal dates (a batch added in one commit, notes from one file time) make neither side newer: say so, or the judge
+    // reads "B (newer)" as proof that B replaces A (#1134).
+    const tied = Date.parse(older.createdIso) === Date.parse(newer.createdIso);
+    return [
+        ...sideSection(tied ? "A (same age as B)" : "A (older)", older),
+        ...sideSection(tied ? "B (same age as A)" : "B (newer)", newer),
+    ].join("\n");
 }
 /** The tombstone-vocabulary reason a judge label maps to (`supersedes` -> `superseded`; the rest unchanged). */
 export function tombstoneReason(label) {

package/dist/commands/improve/consolidate.js

@@ -28,7 +28,7 @@ import { detectAdapterId } from "../../core/adapter/detect-adapter.js";
 import { assembleAssetFromString, serializeFrontmatter } from "../../core/asset/asset-serialize.js";
 import { parseFrontmatter } from "../../core/asset/frontmatter.js";
 import { conceptIdFromTypeName, displayRef, parseRefInput } from "../../core/asset/resolve-ref.js";
-import { getImproveProcessConfig, loadConfig } from "../../core/config/config.js";
+import { loadConfig } from "../../core/config/config.js";
 import { parseEmbeddedJsonResponse } from "../../core/parse.js";
 import { openStateDatabase } from "../../core/state-db.js";
 import { warn, warnVerbose } from "../../core/warn.js";
@@ -210,36 +210,6 @@ async function clusterMemoriesBySimilarity(memories, config, stateDb, signal) {
     }
     return { ordered, embedTelemetry: telemetry };
 }
-/**
- * Anti-collapse (default on, `antiCollapse.enabled: false` opts out): a small
- * deterministic sample of the pool is spread through the similarity order so
- * consolidation is not purely similarity-driven.
- */
-function injectRandomClusterMembers(memories, profile, warnings) {
-    const config = getImproveProcessConfig("consolidate", profile)?.antiCollapse ?? {};
-    if (config.enabled === false || memories.length <= 2)
-        return memories;
-    const fraction = config.randomClusterFraction ?? 0.05;
-    const randomCount = Math.max(1, Math.floor(memories.length * fraction));
-    const sample = [...memories]
-        .sort((a, b) => contentHash(a.name).localeCompare(contentHash(b.name)))
-        .slice(0, randomCount);
-    const sampled = new Set(sample.map((m) => m.name));
-    const interval = Math.max(2, Math.floor(memories.length / randomCount));
-    const out = [];
-    let next = 0;
-    for (let i = 0; i < memories.length; i++) {
-        const m = memories[i];
-        if (m && !sampled.has(m.name))
-            out.push(m);
-        if (i > 0 && i % interval === 0 && next < sample.length)
-            out.push(sample[next++]);
-    }
-    while (next < sample.length)
-        out.push(sample[next++]);
-    warnings.push(`Anti-collapse: injected ${randomCount} random (non-similarity-driven) cluster member(s) into consolidation pool (fraction=${fraction}).`);
-    return out;
-}
 /** Body hashes of pending consolidate proposals, so the prompt can mark memories already queued. */
 function loadPendingConsolidateProposalHashes(stashDir, proposalsCtx) {
     const hashes = new Set();
@@ -670,11 +640,12 @@ async function judgeConsolidationChunks(args) {
     }
     return planned;
 }
+/** Assumed wall-clock seconds per consolidation chunk for the up-front budget cap. */
+const CHUNK_SECONDS_ESTIMATE = 30;
 /**
  * The model's plan for the narrowed pool: chunk size from the context window,
  * an up-front cap when the remaining budget cannot cover every chunk (oldest
- * first, the rest deferred), similarity clustering, anti-collapse, then the
- * chunk loop.
+ * first, the rest deferred), similarity clustering, then the chunk loop.
  */
 async function planConsolidation(opts, config, stashDir, memories, warnings, stateDb, acc) {
     const llmRunner = opts.llmRunner ?? undefined;
@@ -685,7 +656,7 @@ async function planConsolidation(opts, config, stashDir, memories, warnings, sta
     let budgeted = memories;
     const budgetMs = opts.signal?.remainingBudgetMs;
     if (opts.signal && budgetMs !== undefined) {
-        const safeChunks = Math.max(0, Math.floor((Math.max(0, budgetMs) / 1000 / (opts.p90ChunkSecondsDefault ?? 30)) * 0.6));
+        const safeChunks = Math.max(0, Math.floor((Math.max(0, budgetMs) / 1000 / CHUNK_SECONDS_ESTIMATE) * 0.6));
         if (safeChunks * chunkSize < memories.length) {
             budgeted = [...memories]
                 .sort((a, b) => mtimeMsOf(a) - mtimeMsOf(b) || a.name.localeCompare(b.name))
@@ -700,7 +671,7 @@ async function planConsolidation(opts, config, stashDir, memories, warnings, sta
     if (llmRunner && willDispatch)
         assertRunnerCredentials(llmRunner);
     const { ordered, embedTelemetry } = await clusterMemoriesBySimilarity(budgeted, config, stateDb, opts.signal);
-    const chunks = slice(injectRandomClusterMembers(ordered, opts.improveProfile, warnings));
+    const chunks = slice(ordered);
     const pendingProposalBodyHashes = loadPendingConsolidateProposalHashes(stashDir, opts.proposalsCtx);
     warn(`[consolidate] ${budgeted.length} memories / ${chunks.length} chunk(s) / chunk_size=${chunkSize}` +
         ` / pending-proposal hashes: ${pendingProposalBodyHashes.size}`);

package/dist/commands/improve/distill/lesson-update.js

@@ -0,0 +1,91 @@
+// This Source Code Form is subject to the terms of the Mozilla Public
+// License, v. 2.0. If a copy of the MPL was not distributed with this
+// file, You can obtain one at https://mozilla.org/MPL/2.0/.
+/**
+ * Distill's lesson update (#1090): when a memory's lesson repeats a lesson the library already holds, the writer
+ * is asked to extend that lesson with what the memory adds instead of the duplicate being thrown away. These are
+ * the prompt, the reply schema and the two deterministic checks; the call, the judge and the proposal are in
+ * `../distill`.
+ */
+import { parseEmbeddedJsonResponse } from "../../../core/parse.js";
+export const DISTILL_LESSON_UPDATE_JSON_SCHEMA = {
+    type: "object",
+    required: ["reason", "new_facts", "decision", "ref", "body"],
+    additionalProperties: false,
+    properties: {
+        reason: {
+            type: "string",
+            description: "One sentence: which listed lesson states the rule and what the memory adds to it, or why nothing.",
+        },
+        new_facts: {
+            type: "array",
+            items: { type: "string" },
+            description: "Written before the body: each cause, step, number, limit or consequence the memory states and the lesson lacks, one short phrase each. Empty when there is none.",
+        },
+        decision: {
+            type: "string",
+            enum: ["update", "none"],
+            description: "`none` when no listed lesson states the memory's rule, or `new_facts` is empty: leave `ref` and `body` empty. Otherwise `update`.",
+        },
+        ref: { type: "string", description: "The `Existing lesson ref:` of the lesson to extend. Empty for `none`." },
+        body: {
+            type: "string",
+            description: "That lesson's whole body with the new lines added, every existing line unchanged. No frontmatter. Empty for `none`.",
+        },
+    },
+};
+export function buildLessonUpdatePrompt(memory, feedback, candidates) {
+    const lines = [
+        "A lesson written from the memory below would repeat a lesson the library already holds. Do not write a new lesson. Extend the existing one with what the memory adds.",
+        "",
+        "Memory:",
+        "```",
+        memory.slice(0, 3000),
+        "```",
+    ];
+    if (feedback.length > 0)
+        lines.push("", "Feedback recorded about the memory:", "```", feedback.join("\n").slice(0, 1500), "```");
+    lines.push("", "Existing lessons, nearest first (they may be on another subject):");
+    for (const candidate of candidates) {
+        lines.push(`\nExisting lesson ref: ${candidate.ref}`, "```", candidate.body.slice(0, 3000), "```");
+    }
+    lines.push("", "Pick the one existing lesson that already states the rule the memory gives. Write its whole body again with the new lines added:", "- Copy every existing line unchanged, in its place. Do not reword, shorten, reorder or drop any of them.", "First list in new_facts each cause, step, number, limit or consequence the memory states and the lesson lacks, one short phrase each: check every sentence of the memory against the lesson. The memory's own incident retold (what happened in one test, project or day) is not a new fact unless it carries one of these. Then add one line to the body for each new fact, and say nothing the memory does not say.", "- If the memory contradicts a line of the lesson, answer none.", "- If no listed lesson states the memory's rule, or the memory adds nothing the lesson lacks, answer none.", "", 'Return ONLY valid JSON, no prose: {"reason": "...", "new_facts": ["..."], "decision": "update" | "none", "ref": "<the existing lesson ref>", "body": "<the whole body>"}');
+    return lines.join("\n");
+}
+/** The writer's chosen update, or `null` for `none` and for any reply that names no listed lesson, no new fact or no body. */
+export function parseLessonUpdate(raw, candidates) {
+    const payload = parseEmbeddedJsonResponse(raw);
+    if (!payload || typeof payload !== "object" || Array.isArray(payload) || payload.decision !== "update")
+        return null;
+    const ref = typeof payload.ref === "string" ? payload.ref.trim() : "";
+    const body = typeof payload.body === "string" ? payload.body.trim() : "";
+    const candidate = candidates.find((c) => c.ref === ref);
+    const facts = Array.isArray(payload.new_facts)
+        ? payload.new_facts.filter((f) => typeof f === "string" && f.trim() !== "")
+        : [];
+    if (!candidate || !body || facts.length === 0)
+        return null;
+    return { candidate, body, reason: typeof payload.reason === "string" ? payload.reason.trim() : "" };
+}
+const normalizeLine = (line) => line.trim().replace(/\s+/g, " ").toLowerCase();
+const bodyLines = (body) => body
+    .split("\n")
+    .map(normalizeLine)
+    .filter((line) => line !== "");
+/**
+ * What an update does to a lesson's body: the existing lines it no longer holds (compared by words, in any case
+ * and spacing, anywhere in the new body) and the lines it adds.
+ */
+export function diffLessonBody(existingBody, mergedBody) {
+    const existing = bodyLines(existingBody);
+    const merged = bodyLines(mergedBody);
+    const kept = new Set(merged);
+    const had = new Set(existing);
+    return {
+        dropped: existing.filter((line) => !kept.has(line)),
+        added: mergedBody
+            .split("\n")
+            .filter((line) => line.trim() !== "" && !had.has(normalizeLine(line)))
+            .map((line) => line.trim()),
+    };
+}

package/dist/commands/improve/distill-guards.js

@@ -3,8 +3,7 @@
 // file, You can obtain one at https://mozilla.org/MPL/2.0/.
 /**
  * Distill guards: the related lessons, knowledge notes and skills shown to the
- * writer so it does not repeat or overwrite them (CLS context), and a cheap check
- * that a proposal does not contradict the memories it came from.
+ * writer so it does not repeat or overwrite them (CLS context).
  */
 export const DEFAULT_CLS_ADJACENT_COUNT = 3;
 /** The CLS prompt section (each entry capped at 600 chars); empty when disabled (on unless `enabled: false`) or nothing is related. */
@@ -22,44 +21,3 @@ export function buildClsContext(adjacentItems, config) {
         lines.push(`### ${item.ref}`, item.content.trim().slice(0, 600), "");
     return lines.join("\n");
 }
-/**
- * Flag a proposal whose "always/must X" (or "never/must not X") claim meets
- * the opposite claim about X in a source. Deliberately conservative: a flag
- * only costs a human review, while a model call per proposal is expensive.
- */
-export function checkDistillFidelity(proposalBody, sourceBodies, config) {
-    if (!config.enabled || sourceBodies.length === 0)
-        return { contradictionDetected: false };
-    const strongClaims = extractStrongClaims(proposalBody.toLowerCase());
-    for (const sourceBody of sourceBodies) {
-        const sourceLow = sourceBody.toLowerCase();
-        for (const { polarity, term } of strongClaims) {
-            if (hasStrongClaim(sourceLow, term, polarity === "positive" ? "negative" : "positive")) {
-                return {
-                    contradictionDetected: true,
-                    reason: `Proposal makes a ${polarity} strong claim about "${term}" that conflicts with an opposing claim in a cited source. Route to human review.`,
-                };
-            }
-        }
-    }
-    return { contradictionDetected: false };
-}
-const CLAIM_PATTERNS = [
-    { polarity: "positive", re: /\b(?:always|must)\s+(\w+)/g },
-    { polarity: "negative", re: /\b(?:never|must\s+not|should\s+not)\s+(\w+)/g },
-];
-function extractStrongClaims(text) {
-    const claims = [];
-    for (const { polarity, re } of CLAIM_PATTERNS) {
-        for (const m of text.matchAll(re)) {
-            const term = m[1];
-            if (term && term.length > 2)
-                claims.push({ polarity, term });
-        }
-    }
-    return claims;
-}
-function hasStrongClaim(text, term, polarity) {
-    const marker = polarity === "positive" ? /\b(?:always|must)\s/ : /\b(?:never|must\s+not|should\s+not)\s/;
-    return marker.test(text) && text.includes(term);
-}