@cleocode/cleo 2026.9.7 → 2026.9.10

package/studio-dist/server/chunks/duplicate-detector-CaVFMKdE.js

@@ -1,692 +0,0 @@
-import { s as object, _ as _enum, u as string, v as number, w as boolean } from './paths-CV7S5-Zm.js';
-import 'node:fs';
-import 'node:path';
-import 'node:os';
-import 'node:events';
-import 'node:diagnostics_channel';
-import 'fs';
-import 'events';
-import 'util';
-import 'path';
-import 'assert';
-import 'worker_threads';
-import 'module';
-import 'node:url';
-import 'url';
-import 'buffer';
-import 'node:module';
-import 'node:child_process';
-import 'node:crypto';
-import 'node:process';
-import 'node:async_hooks';
-
-//#region ../core/dist/tasks/duplicate-detector.js
-/**
-* BRAIN-powered tiered duplicate-task detection for `cleo add`.
-*
-* Before a new task is inserted, this module queries active tasks and computes
-* similarity between the incoming title+description and each active task.
-*
-* Three-tier escalation (T1681):
-*
-*   Tier 1 — lexical OR vector similarity. NOT BM25, despite the historical
-*     naming: there is no IDF, no term frequency and no length normalisation.
-*     Two implementations, selected at runtime (see `runDuplicateCheck`):
-*       - lexical: Jaccard over CHARACTER TRIGRAMS of a title-2x-weighted blob
-*       - vector:  cosine over embeddings, when an embedding provider is loaded
-*     score >= 0.92 → reject (clear match)
-*     score <  0.50 → insert (clear different)
-*     score in [0.50, 0.92) → escalate to Tier 2
-*
-*   Tier 2 — Jaccard on word-level n-grams (title+description+labels):
-*     score >= 0.85 → reject
-*     score <  0.40 → insert
-*     score in [0.40, 0.85) → escalate to Tier 3 (LLM, paid)
-*
-*   Tier 3 — LLM reasoning (max 1 call per cleo add):
-*     are_duplicate=true  → reject
-*     are_duplicate=false → insert
-*     LLM error / timeout → fall back to Tier-1-only decision (never block on error)
-*
-* Thresholds (original T1633 behavior preserved for the Tier-1 clear-match path):
-*   Tier-1 score >= 0.85 → warning emitted to stderr (non-blocking)
-*   Tier-1 score >= 0.92 → rejected with E_DUPLICATE_TASK_LIKELY
-*
-* @epic T1627
-* @task T1633
-* @task T1681
-*/
-/** Tier-1 score at which a non-blocking warning is emitted. (Name kept: exported API.) */
-var DUPLICATE_WARN_THRESHOLD = .85;
-/** Tier-1 score at which creation is rejected (clear match). (Name kept: exported API.) */
-var DUPLICATE_REJECT_THRESHOLD = .92;
-/**
-* Tier-1 lower bound for the ambiguous range.
-* Scores below this are considered clear-different and skip Jaccard + LLM.
-*/
-var TIER1_ESCALATE_LOW = .5;
-/**
-* Jaccard reject threshold.
-* Scores >= this after Tier-2 escalation cause rejection without calling LLM.
-*/
-var JACCARD_REJECT_THRESHOLD = .85;
-/**
-* Jaccard lower bound for the ambiguous range.
-* Scores below this after Tier-2 escalation are considered clear-different.
-*/
-var JACCARD_ESCALATE_LOW = .4;
-/** Maximum active tasks to scan per invocation. Prevents runaway cost on huge task lists. */
-var MAX_ACTIVE_TASKS_SCAN = 500;
-/** LLM call timeout in milliseconds. */
-var LLM_TIMEOUT_MS = 15e3;
-/**
-* Maximum candidates that may be scored with local embeddings (T12117).
-*
-* The vector tier used to run inside the per-candidate loop with no bound, so
-* `cleo add` performed one local model inference **per active task** before
-* committing the row — O(active tasks) inferences on the write path. In a
-* project with ~1,000 active tasks that is thousands of inferences to create
-* one row, which is why `cleo add` was observed taking 180-280 s and failing
-* outright on a memory-constrained host (issue #1244).
-*
-* Candidates beyond this budget fall back to the lexical score, which is the
-* same fallback already used whenever embeddings are unavailable — so this
-* bounds cost without introducing a new code path.
-*/
-var MAX_VECTOR_CANDIDATES = 25;
-/**
-* Wall-clock budget for the whole vector-scoring phase, in milliseconds.
-*
-* A second bound beside {@link MAX_VECTOR_CANDIDATES} because the count cap
-* assumes each inference is fast, and a cold model load is not. Whichever
-* bound trips first ends the phase.
-*/
-var VECTOR_PHASE_BUDGET_MS = 5e3;
-/**
-* Structured output schema for the LLM duplicate-reasoning call.
-* @task T1681
-*/
-var DuplicateReasoningSchema = object({
-	are_duplicate: boolean(),
-	confidence: number().min(0).max(1),
-	distinction: string().nullable(),
-	suggestion: _enum([
-		"merge",
-		"keep-both",
-		"block-new"
-	])
-});
-/**
-* Normalise text for comparison: lowercase, collapse whitespace,
-* strip punctuation (except hyphens which carry semantic meaning).
-*
-* @param text - Raw text to normalise.
-* @returns Normalised string.
-*/
-function normalise(text) {
-	return text.toLowerCase().replace(/[^\w\s-]/g, " ").replace(/\s+/g, " ").trim();
-}
-/**
-* Build a Set of character trigrams from normalised text.
-* Trigrams capture local character patterns and are robust to
-* word-order variation and minor phrasing differences.
-*
-* @param text - Normalised text.
-* @returns Set of 3-character substrings.
-*/
-function trigrams(text) {
-	const result = /* @__PURE__ */ new Set();
-	if (text.length < 3) {
-		if (text.length > 0) result.add(text.padEnd(3, " "));
-		return result;
-	}
-	for (let i = 0; i <= text.length - 3; i++) result.add(text.slice(i, i + 3));
-	return result;
-}
-/**
-* Jaccard similarity between two Sets: |A ∩ B| / |A ∪ B|.
-* Returns 0 when both sets are empty.
-*
-* @param a - First set.
-* @param b - Second set.
-* @returns Jaccard score in [0, 1].
-*/
-function jaccard(a, b) {
-	if (a.size === 0 && b.size === 0) return 0;
-	let intersection = 0;
-	for (const v of a) if (b.has(v)) intersection++;
-	const union = a.size + b.size - intersection;
-	return union === 0 ? 0 : intersection / union;
-}
-/**
-* Build a weighted search blob from title and description.
-* Title is given 2× weight by repetition to reflect higher semantic importance.
-*
-* @param title - Task title.
-* @param description - Task description (may be empty).
-* @returns A single normalised string for trigram hashing.
-*/
-function buildSearchBlob(title, description) {
-	return normalise(`${title} ${title} ${description}`);
-}
-/**
-* Compute lexical similarity between two (title, description) pairs.
-*
-* Uses Jaccard similarity over character trigrams of a weighted blob
-* (title 2×, description 1×). This is zero-dependency, deterministic,
-* and symmetrical. This is the LEXICAL Tier-1 measure — it is not BM25.
-*
-* @param titleA - First title.
-* @param descA - First description.
-* @param titleB - Second title.
-* @param descB - Second description.
-* @returns Similarity score in [0, 1].
-*/
-function computeLexicalSimilarity(titleA, descA, titleB, descB) {
-	const blobA = buildSearchBlob(titleA, descA);
-	const blobB = buildSearchBlob(titleB, descB);
-	if (blobA === blobB) return 1;
-	return jaccard(trigrams(blobA), trigrams(blobB));
-}
-/**
-* Build word unigrams and bigrams from a token list.
-* Includes labels as additional tokens to capture tag-level similarity.
-*
-* @param tokens - Array of normalised word tokens.
-* @returns Set of word n-grams (unigrams + bigrams).
-*/
-function wordNgrams(tokens) {
-	const result = /* @__PURE__ */ new Set();
-	for (const tok of tokens) result.add(tok);
-	for (let i = 0; i < tokens.length - 1; i++) result.add(`${tokens[i]} ${tokens[i + 1]}`);
-	return result;
-}
-/**
-* Tokenise a string into normalised word tokens.
-*
-* @param text - Raw text.
-* @returns Array of lowercase non-empty word tokens.
-*/
-function tokenise(text) {
-	return normalise(text).split(/\s+/).filter((t) => t.length > 0);
-}
-/**
-* Build word-level n-gram set from title + description + labels.
-* This differs from the Tier-1 lexical blob (character trigrams, no labels).
-*
-* @param title - Task title.
-* @param description - Task description.
-* @param labels - Task labels (empty array if none).
-* @returns Set of word unigrams + bigrams.
-*/
-function buildWordNgramSet(title, description, labels) {
-	const titleTokens = tokenise(title);
-	const descTokens = tokenise(description);
-	const labelTokens = labels.flatMap((l) => tokenise(l));
-	return wordNgrams([
-		...titleTokens,
-		...titleTokens,
-		...descTokens,
-		...labelTokens
-	]);
-}
-/**
-* Compute Jaccard similarity over word-level n-grams including labels.
-* Used as Tier-2 discriminator when the Tier-1 score is ambiguous.
-*
-* @param titleA - First title.
-* @param descA - First description.
-* @param labelsA - First task labels.
-* @param titleB - Second title.
-* @param descB - Second description.
-* @param labelsB - Second task labels.
-* @returns Jaccard score in [0, 1].
-*/
-function computeJaccardWordSimilarity(titleA, descA, labelsA, titleB, descB, labelsB) {
-	return jaccard(buildWordNgramSet(titleA, descA, labelsA), buildWordNgramSet(titleB, descB, labelsB));
-}
-/**
-* Embed the incoming search blob ONCE for the whole duplicate check.
-*
-* Returns `null` when embedding is unavailable, which makes the caller fall
-* back to the lexical (trigram) measure for every candidate.
-*
-* @param incomingBlob - Normalised search blob for the new task.
-* @returns The incoming embedding, or `null` when embedding is unavailable.
-*/
-async function embedIncomingOnce(incomingBlob) {
-	try {
-		const { isEmbeddingAvailable, embedText } = await import('./brain-embedding-Djw9ekXu.js');
-		if (!isEmbeddingAvailable()) return null;
-		return await embedText(incomingBlob) ?? null;
-	} catch {
-		return null;
-	}
-}
-/**
-* Cosine similarity between a PRE-COMPUTED incoming vector and a candidate blob.
-*
-* The incoming vector is computed once per duplicate check by
-* {@link embedIncomingOnce} and passed in. It used to be embedded inside this
-* function, which ran once per candidate — so a store with 1,126 active tasks
-* embedded the same incoming text 1,126 times per `cleo add`. Only the candidate
-* is embedded here.
-*
-* @param incomingVec - Pre-computed embedding of the incoming blob.
-* @param candidateBlob - Candidate search blob to embed and compare.
-* @returns Cosine similarity in [0, 1], or `null` when embedding is unavailable.
-*/
-async function tryVectorSimilarity(incomingVec, candidateBlob) {
-	try {
-		const { isEmbeddingAvailable, embedText } = await import('./brain-embedding-Djw9ekXu.js');
-		if (!isEmbeddingAvailable()) return null;
-		const vecA = incomingVec;
-		const vecB = await embedText(candidateBlob);
-		if (!vecA || !vecB || vecA.length !== vecB.length) return null;
-		let dot = 0;
-		let normA = 0;
-		let normB = 0;
-		for (let i = 0; i < vecA.length; i++) {
-			dot += (vecA[i] ?? 0) * (vecB[i] ?? 0);
-			normA += (vecA[i] ?? 0) ** 2;
-			normB += (vecB[i] ?? 0) ** 2;
-		}
-		const denom = Math.sqrt(normA) * Math.sqrt(normB);
-		if (denom === 0) return null;
-		return Math.max(0, Math.min(1, dot / denom));
-	} catch {
-		return null;
-	}
-}
-/**
-* Build the system prompt for the LLM duplicate-detection call.
-*/
-function buildDuplicateSystemPrompt() {
-	return [
-		"You are a task-management assistant determining whether two software tasks are semantic duplicates.",
-		"Respond ONLY with valid JSON matching this schema:",
-		"{ \"are_duplicate\": boolean, \"confidence\": number (0-1), \"distinction\": string|null, \"suggestion\": \"merge\"|\"keep-both\"|\"block-new\" }",
-		"",
-		"Rules:",
-		"- are_duplicate=true when both tasks describe the SAME work deliverable (even if worded differently)",
-		"- are_duplicate=false when they target different deliverables, different scopes, or different problem domains",
-		"- distinction must be non-null when are_duplicate=false (explain what makes them different)",
-		"- suggestion: \"merge\"=consolidate into one task, \"keep-both\"=distinct tasks worth tracking separately, \"block-new\"=new task is redundant",
-		"- Do NOT add any explanation outside the JSON object."
-	].join("\n");
-}
-/**
-* Build the user prompt for the LLM duplicate-detection call.
-*/
-function buildDuplicateUserPrompt(incomingTitle, incomingDescription, candidateTitle, candidateDescription, candidateId) {
-	return [
-		`Task A (NEW — being added now):`,
-		`  Title: ${incomingTitle}`,
-		`  Description: ${incomingDescription || "(no description provided)"}`,
-		"",
-		`Task B (EXISTING — ${candidateId}):`,
-		`  Title: ${candidateTitle}`,
-		`  Description: ${candidateDescription || "(no description)"}`,
-		"",
-		"Are these the same task (semantic duplicate)? Respond with JSON only."
-	].join("\n");
-}
-/**
-* Call the daemon LLM to determine whether two tasks are semantic duplicates.
-*
-* Cost cap: max 1 call per `cleo add` invocation (enforced by the caller via
-* a `llmCallMade` flag). Never throws — returns null on error/timeout so the
-* caller can fall back to a Tier-1-only decision.
-*
-* @param incomingTitle - Title of the task being added.
-* @param incomingDescription - Description of the task being added.
-* @param candidate - Best-scoring candidate from Tier 1/2.
-* @param cwd - Project root for credential + config resolution.
-* @returns Structured reasoning result, or null when the call fails/times out.
-* @task T1681
-*/
-async function callLlmDuplicateReasoning(incomingTitle, incomingDescription, candidate, cwd) {
-	try {
-		const { authHeadersFromSealed } = await import('./credentials-C7EJFf5O.js');
-		const { resolveLLMForRole } = await import('./role-resolver2-nkhzS1oy.js');
-		const llm = await resolveLLMForRole("consolidation", { projectRoot: cwd });
-		if (!llm.sealedCredential || !llm.credential) return null;
-		const systemPrompt = buildDuplicateSystemPrompt();
-		const userPrompt = buildDuplicateUserPrompt(incomingTitle, incomingDescription, candidate.title, candidate.description ?? "", candidate.id);
-		const modelConfig = {
-			transport: llm.provider,
-			model: llm.model,
-			apiKey: (await llm.sealedCredential.fetch()).value,
-			extraHeaders: llm.credential.authType === "oauth" ? await authHeadersFromSealed(llm.sealedCredential, llm.credential.authType) : void 0
-		};
-		const { cleoLlmCall } = await import('./api2-CmNQzb0b.js');
-		const callPromise = cleoLlmCall({
-			modelConfig,
-			prompt: userPrompt,
-			maxTokens: 256,
-			jsonMode: true,
-			temperature: 0,
-			enableRetry: false,
-			messages: [{
-				role: "system",
-				content: systemPrompt
-			}]
-		});
-		const timeoutPromise = new Promise((resolve) => {
-			setTimeout(() => resolve(null), LLM_TIMEOUT_MS);
-		});
-		const result = await Promise.race([callPromise, timeoutPromise]);
-		if (!result) return null;
-		const responseContent = typeof result === "object" && result !== null && "content" in result ? result.content : null;
-		if (!responseContent) return null;
-		let parsed;
-		if (typeof responseContent === "string") try {
-			parsed = JSON.parse(responseContent);
-		} catch {
-			const jsonMatch = /\{[\s\S]*\}/.exec(responseContent);
-			if (!jsonMatch) return null;
-			try {
-				parsed = JSON.parse(jsonMatch[0]);
-			} catch {
-				return null;
-			}
-		}
-		else if (typeof responseContent === "object") parsed = responseContent;
-		else return null;
-		const validation = DuplicateReasoningSchema.safeParse(parsed);
-		if (!validation.success) return null;
-		return validation.data;
-	} catch {
-		return null;
-	}
-}
-/**
-* Check whether the incoming task's title and description are similar to any
-* active task in the database using three-tier escalation (T1681).
-*
-* Algorithm:
-*
-* Tier 1 — lexical or vector similarity (per candidate):
-*   For each active task, compute vector cosine similarity (if embedding is available)
-*   Jaccard over character trigrams, or cosine over embeddings when a provider is loaded.
-*   - score >= DUPLICATE_REJECT_THRESHOLD (0.92): clear match → reject immediately.
-*   - score < TIER1_ESCALATE_LOW (0.50): clear different → skip Tier 2 + 3 for this candidate.
-*   - score in [0.50, 0.92): ambiguous → collect for Tier-2 Jaccard evaluation.
-*
-* Tier 2 — Jaccard word n-grams (title+description+labels):
-*   For candidates that were ambiguous in Tier 1, compute Jaccard over word-level n-grams.
-*   Labels are included to surface tag-level similarity that character trigrams miss.
-*   - score >= JACCARD_REJECT_THRESHOLD (0.85): reject.
-*   - score < JACCARD_ESCALATE_LOW (0.40): clear different → skip LLM.
-*   - score in [0.40, 0.85): ambiguous → escalate to LLM (cost cap: 1 call per invocation).
-*
-* Tier 3 — LLM reasoning (max 1 call per `cleo add`):
-*   Call the daemon provider with both task descriptions and the structured-output schema.
-*   On error/timeout: fall back to the Tier-1 decision for the candidate (never block).
-*
-* @param title - Title of the task being added.
-* @param description - Description of the task being added (empty string if not provided).
-* @param accessor - DataAccessor instance to load active tasks from.
-* @param labels - Labels of the task being added (empty array if not provided).
-* @param cwd - Project root for LLM credential resolution (Tier 3).
-* @returns Duplicate check result with tier provenance.
-* @task T1633
-* @task T1681
-*/
-async function checkDuplicates(title, description, accessor, labels, cwd) {
-	const incomingLabels = labels ?? [];
-	const { tasks: activeTasks } = await accessor.queryTasks({
-		status: [
-			"pending",
-			"active",
-			"blocked"
-		],
-		limit: MAX_ACTIVE_TASKS_SCAN
-	});
-	if (activeTasks.length === 0) return {
-		maxScore: 0,
-		candidates: [],
-		shouldReject: false,
-		shouldWarn: false,
-		tier: "bm25"
-	};
-	const incomingBlob = buildSearchBlob(title, description);
-	const incomingVec = await (async () => {
-		try {
-			const { isEmbeddingAvailable } = await import('./brain-embedding-Djw9ekXu.js');
-			return isEmbeddingAvailable();
-		} catch {
-			return false;
-		}
-	})() ? await embedIncomingOnce(incomingBlob) : null;
-	const tier1Ambiguous = [];
-	const clearMatchCandidates = [];
-	let vectorBudget = MAX_VECTOR_CANDIDATES;
-	const vectorDeadline = Date.now() + VECTOR_PHASE_BUDGET_MS;
-	for (const task of activeTasks) {
-		if (task.title === title) {
-			if ((task.description ?? "") === description) continue;
-		}
-		const candidateBlob = buildSearchBlob(task.title, task.description ?? "");
-		let tier1Score;
-		if (incomingVec && vectorBudget > 0 && Date.now() < vectorDeadline) {
-			vectorBudget--;
-			tier1Score = await tryVectorSimilarity(incomingVec, candidateBlob) ?? computeLexicalSimilarity(title, description, task.title, task.description ?? "");
-		} else tier1Score = computeLexicalSimilarity(title, description, task.title, task.description ?? "");
-		if (tier1Score >= .92) clearMatchCandidates.push({
-			id: task.id,
-			title: task.title,
-			score: tier1Score
-		});
-		else if (tier1Score >= TIER1_ESCALATE_LOW) {
-			tier1Ambiguous.push({
-				task,
-				tier1Score
-			});
-			if (tier1Score >= .85) clearMatchCandidates.push({
-				id: task.id,
-				title: task.title,
-				score: tier1Score
-			});
-		}
-	}
-	if (clearMatchCandidates.some((c) => c.score >= .92)) {
-		const sorted = clearMatchCandidates.filter((c) => c.score >= DUPLICATE_REJECT_THRESHOLD).sort((a, b) => b.score - a.score).slice(0, 3);
-		return {
-			maxScore: sorted[0]?.score ?? 0,
-			candidates: sorted,
-			shouldReject: true,
-			shouldWarn: false,
-			tier: "bm25"
-		};
-	}
-	const tier2Ambiguous = [];
-	const tier2Candidates = [];
-	for (const { task, tier1Score: _tier1 } of tier1Ambiguous) {
-		const jScore = computeJaccardWordSimilarity(title, description, incomingLabels, task.title, task.description ?? "", task.labels ?? []);
-		if (jScore >= JACCARD_REJECT_THRESHOLD) tier2Candidates.push({
-			id: task.id,
-			title: task.title,
-			score: jScore
-		});
-		else if (jScore >= JACCARD_ESCALATE_LOW) tier2Ambiguous.push({
-			task,
-			jaccardScore: jScore
-		});
-	}
-	if (tier2Candidates.length > 0) {
-		const sorted = tier2Candidates.sort((a, b) => b.score - a.score).slice(0, 3);
-		return {
-			maxScore: sorted[0]?.score ?? 0,
-			candidates: sorted,
-			shouldReject: true,
-			shouldWarn: false,
-			tier: "jaccard"
-		};
-	}
-	if (tier2Ambiguous.length > 0) {
-		tier2Ambiguous.sort((a, b) => b.jaccardScore - a.jaccardScore);
-		const topCandidate = tier2Ambiguous[0];
-		const reasoning = await callLlmDuplicateReasoning(title, description, {
-			id: topCandidate.task.id,
-			title: topCandidate.task.title,
-			score: topCandidate.jaccardScore,
-			description: topCandidate.task.description ?? ""
-		}, cwd);
-		if (reasoning !== null) {
-			if (reasoning.are_duplicate) {
-				const candidate = {
-					id: topCandidate.task.id,
-					title: topCandidate.task.title,
-					score: reasoning.confidence
-				};
-				return {
-					maxScore: reasoning.confidence,
-					candidates: [candidate],
-					shouldReject: true,
-					shouldWarn: false,
-					tier: "llm"
-				};
-			}
-			return {
-				maxScore: topCandidate.jaccardScore,
-				candidates: [],
-				shouldReject: false,
-				shouldWarn: false,
-				tier: "llm"
-			};
-		}
-		const fallbackScore = tier1Ambiguous.find((e) => e.task.id === topCandidate.task.id)?.tier1Score ?? topCandidate.jaccardScore;
-		if (fallbackScore >= .85) return {
-			maxScore: fallbackScore,
-			candidates: [{
-				id: topCandidate.task.id,
-				title: topCandidate.task.title,
-				score: fallbackScore
-			}],
-			shouldReject: false,
-			shouldWarn: true,
-			tier: "bm25"
-		};
-	}
-	const warnCandidates = clearMatchCandidates.filter((c) => c.score >= .85 && c.score < .92).sort((a, b) => b.score - a.score).slice(0, 3);
-	if (warnCandidates.length > 0) return {
-		maxScore: warnCandidates[0]?.score ?? 0,
-		candidates: warnCandidates,
-		shouldReject: false,
-		shouldWarn: true,
-		tier: "bm25"
-	};
-	return {
-		maxScore: 0,
-		candidates: [],
-		shouldReject: false,
-		shouldWarn: false,
-		tier: "bm25"
-	};
-}
-/**
-* Format a human-readable candidate list for warning/rejection messages.
-*
-* @param candidates - Array of duplicate candidates.
-* @returns Formatted multi-line string listing candidates.
-*/
-function formatCandidateList(candidates) {
-	return candidates.map((c) => `  • ${c.id}: "${c.title}" (similarity: ${(c.score * 100).toFixed(0)}%)`).join("\n");
-}
-/**
-* Build a warning message for candidates above the warn threshold.
-*
-* @param candidates - Candidates to include in the message.
-* @returns Warning string (no newline at end).
-*/
-function buildWarnMessage(candidates) {
-	return `[BRAIN duplicate-check] Similar active tasks found (score >= ${Math.round(DUPLICATE_WARN_THRESHOLD * 100)}%):\n` + formatCandidateList(candidates) + `\nUse --force-duplicate to bypass this warning if the task is intentionally different.`;
-}
-/**
-* Build a rejection message for candidates above the reject threshold.
-*
-* @param candidates - Candidates to include in the message.
-* @returns Rejection string (no newline at end).
-*/
-function buildRejectMessage(candidates) {
-	return `[BRAIN duplicate-check] Task creation REJECTED — very similar active tasks found (score >= ${Math.round(DUPLICATE_REJECT_THRESHOLD * 100)}%):\n` + formatCandidateList(candidates) + `\nRun with --force-duplicate to bypass (audited to .cleo/audit/duplicate-bypass.jsonl).`;
-}
-/**
-* Total wall-clock budget for duplicate detection on the write path, in ms.
-*
-* Detection is three tiers deep and two of them can call out of process (local
-* embeddings, then an LLM). Each has its own bound, but "bounded individually"
-* is not "bounded in aggregate" — and this runs BEFORE the row is inserted.
-*/
-var DUPLICATE_CHECK_BUDGET_MS = 2e4;
-/**
-* Resolve the duplicate-detection budget, honouring an operator override.
-*
-* @param env - environment to read the override from.
-* @returns budget in ms; the default when unset or malformed.
-*/
-function resolveDuplicateCheckBudgetMs(env = process.env) {
-	const raw = Number.parseInt(env["CLEO_DUPLICATE_CHECK_BUDGET_MS"] ?? "", 10);
-	return Number.isFinite(raw) && raw > 0 ? raw : DUPLICATE_CHECK_BUDGET_MS;
-}
-/**
-* {@link checkDuplicates} with a hard deadline and a fail-OPEN result.
-*
-* ## Why fail open (T12117 · issue #1244)
-*
-* Duplicate detection runs before the insert, so anything that stalls it
-* doesn't slow the write down — it *loses* it. Reported from the field: three
-* `cleo add` attempts at 280 s each, none of which created a row, on a host
-* under memory pressure. No error, no id, no task. A silent write failure is
-* the worst failure mode a task tracker has, because the agent that filed the
-* task believes the work is recorded.
-*
-* It is also silent in the dangerous direction relative to CLEO's documented
-* recovery advice. A killed mutation is supposed to mean "query before
-* retrying — the write has usually landed", which was independently confirmed
-* true for a timeout-killed write. But these writes had NOT landed, and nothing
-* in the output distinguishes the two cases. An agent following the contract
-* correctly reaches the wrong conclusion in one direction or the other.
-*
-* So: the row is the product, detection is enrichment. When the budget is
-* blown, report that on stderr and let the insert proceed. A duplicate that
-* slips through is recoverable by a human in seconds; a task that was never
-* created is lost work nobody knows to look for.
-*
-* @param args - forwarded verbatim to {@link checkDuplicates}.
-* @returns the real verdict, or a permissive one when the budget was exceeded.
-*
-* @task T12117
-*/
-async function checkDuplicatesBounded(...args) {
-	let timer;
-	const budgetMs = resolveDuplicateCheckBudgetMs();
-	const timeout = new Promise((resolve) => {
-		timer = setTimeout(() => resolve(null), budgetMs);
-		timer.unref();
-	});
-	try {
-		const verdict = await Promise.race([checkDuplicates(...args), timeout]);
-		if (verdict === null) {
-			process.stderr.write(`cleo: duplicate detection exceeded ${budgetMs}ms and was skipped; creating the task anyway. Run 'cleo find' to check for duplicates.\n`);
-			return {
-				maxScore: 0,
-				candidates: [],
-				shouldReject: false,
-				shouldWarn: false,
-				tier: "bm25",
-				timedOut: true
-			};
-		}
-		return {
-			...verdict,
-			timedOut: false
-		};
-	} finally {
-		if (timer) clearTimeout(timer);
-	}
-}
-
-export { buildRejectMessage, buildWarnMessage, checkDuplicatesBounded };
-//# sourceMappingURL=duplicate-detector-CaVFMKdE.js.map