@bastani/atomic 0.9.16-alpha.2 → 0.9.16-alpha.4

package/dist/builtin/subagents/src/runs/shared/mcp-direct-tool-allowlist.ts

@@ -1,391 +0,0 @@
-import { createHash } from "node:crypto";
-import * as fs from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { getProjectConfigDirs } from "@bastani/atomic";
-import { getAgentDir } from "../../shared/utils.js";
-
-const CACHE_VERSION = 1;
-const CACHE_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
-const BUILTIN_TOOL_NAMES = new Set(["read", "bash", "edit", "write", "grep", "find", "search", "ls", "mcp"]);
-const GENERIC_GLOBAL_CONFIG_PATH = path.join(os.homedir(), ".config", "mcp", "mcp.json");
-const IMPORT_PATHS = {
-	"claude-code": [
-		path.join(os.homedir(), ".claude", "mcp.json"),
-		path.join(os.homedir(), ".claude.json"),
-		path.join(os.homedir(), ".claude", "claude_desktop_config.json"),
-	],
-	"claude-desktop": [
-		path.join(os.homedir(), "Library", "Application Support", "Claude", "claude_desktop_config.json"),
-	],
-	codex: [path.join(os.homedir(), ".codex", "config.json")],
-	windsurf: [path.join(os.homedir(), ".windsurf", "mcp.json")],
-	vscode: [".vscode/mcp.json"],
-} as const;
-
-export type ToolPrefix = "server" | "none" | "short";
-type ImportKind = keyof typeof IMPORT_PATHS;
-
-export interface ServerEntry {
-	command?: string;
-	args?: string[];
-	env?: Record<string, string>;
-	cwd?: string;
-	url?: string;
-	headers?: Record<string, string>;
-	auth?: "oauth" | "bearer" | false;
-	bearerToken?: string;
-	bearerTokenEnv?: string;
-	exposeResources?: boolean;
-	excludeTools?: string[];
-	directTools?: boolean | string[];
-}
-
-export interface McpConfig {
-	mcpServers: Record<string, ServerEntry>;
-	imports?: ImportKind[];
-	settings?: {
-		toolPrefix?: ToolPrefix;
-		directTools?: boolean;
-	};
-}
-
-export interface CachedTool {
-	name?: string;
-}
-
-export interface CachedResource {
-	uri?: string;
-	name?: string;
-}
-
-export interface ServerCacheEntry {
-	configHash?: string;
-	tools?: CachedTool[];
-	resources?: CachedResource[];
-	cachedAt?: number;
-}
-
-export interface MetadataCache {
-	version: number;
-	servers: Record<string, ServerCacheEntry>;
-}
-
-export function resolveMcpDirectToolNames(mcpDirectTools: string[] | undefined, cwd = process.cwd()): string[] {
-	if (!mcpDirectTools?.length) return [];
-
-	try {
-		const config = loadMcpConfig(cwd);
-		const cache = loadMetadataCache();
-		if (!cache) return [];
-		return resolveMcpDirectToolNamesFromConfig(
-			config,
-			cache,
-			getToolPrefix(config.settings?.toolPrefix),
-			mcpDirectTools,
-		);
-	} catch (error) {
-		console.error("Failed to resolve direct MCP tool names for subagent child allowlist:", error);
-		return [];
-	}
-}
-
-function loadMetadataCache(): MetadataCache | null {
-	const cachePath = path.join(getAgentDir(), "mcp-cache.json");
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(fs.readFileSync(cachePath, "utf-8"));
-	} catch {
-		return null;
-	}
-
-	if (!parsed || typeof parsed !== "object") return null;
-	const raw = parsed as Record<string, unknown>;
-	if (raw.version !== CACHE_VERSION || !raw.servers || typeof raw.servers !== "object" || Array.isArray(raw.servers)) {
-		return null;
-	}
-	return raw as unknown as MetadataCache;
-}
-
-function loadMcpConfig(cwd: string): McpConfig {
-	let config: McpConfig = { mcpServers: {} };
-	for (const sourcePath of getConfigPaths(cwd)) {
-		const loaded = readConfig(sourcePath);
-		if (!loaded) continue;
-		config = mergeConfigs(config, expandImports(loaded, cwd));
-	}
-	return config;
-}
-
-function getConfigPaths(cwd: string): string[] {
-	const piGlobalPath = path.join(getAgentDir(), "mcp.json");
-	const projectPath = path.resolve(cwd, ".mcp.json");
-	const projectConfigPaths = getProjectConfigDirs(cwd).map((configDir) => path.resolve(configDir, "mcp.json"));
-	const sources: string[] = [];
-	if (GENERIC_GLOBAL_CONFIG_PATH !== piGlobalPath) sources.push(GENERIC_GLOBAL_CONFIG_PATH);
-	sources.push(piGlobalPath);
-	if (projectPath !== piGlobalPath) sources.push(projectPath);
-	for (const projectConfigPath of projectConfigPaths) {
-		if (projectConfigPath !== piGlobalPath && projectConfigPath !== projectPath) sources.push(projectConfigPath);
-	}
-	return sources;
-}
-
-function readConfig(configPath: string): McpConfig | null {
-	let parsed: unknown;
-	try {
-		parsed = JSON.parse(fs.readFileSync(configPath, "utf-8"));
-	} catch {
-		return null;
-	}
-	return validateConfig(parsed);
-}
-
-function validateConfig(raw: unknown): McpConfig {
-	if (!raw || typeof raw !== "object" || Array.isArray(raw)) return { mcpServers: {} };
-	const obj = raw as Record<string, unknown>;
-	const servers = obj.mcpServers ?? obj["mcp-servers"] ?? {};
-	return {
-		mcpServers:
-			servers && typeof servers === "object" && !Array.isArray(servers)
-				? (servers as Record<string, ServerEntry>)
-				: {},
-		imports: Array.isArray(obj.imports)
-			? obj.imports.filter((value): value is ImportKind => isImportKind(value))
-			: undefined,
-		settings:
-			obj.settings && typeof obj.settings === "object" && !Array.isArray(obj.settings)
-				? (obj.settings as McpConfig["settings"])
-				: undefined,
-	};
-}
-
-function mergeConfigs(base: McpConfig, next: McpConfig): McpConfig {
-	const imports = [...(base.imports ?? []), ...(next.imports ?? [])];
-	return {
-		mcpServers: { ...base.mcpServers, ...next.mcpServers },
-		imports: imports.length ? [...new Set(imports)] : undefined,
-		settings: next.settings ? { ...base.settings, ...next.settings } : base.settings,
-	};
-}
-
-function expandImports(config: McpConfig, cwd: string): McpConfig {
-	if (!config.imports?.length) return config;
-
-	const importedServers: Record<string, ServerEntry> = {};
-	for (const importKind of config.imports) {
-		const importPath = resolveImportPath(importKind, cwd);
-		if (!importPath) continue;
-		let imported: unknown;
-		try {
-			imported = JSON.parse(fs.readFileSync(importPath, "utf-8"));
-		} catch {
-			continue;
-		}
-		for (const [name, definition] of Object.entries(extractServers(imported, importKind))) {
-			if (!importedServers[name]) importedServers[name] = definition;
-		}
-	}
-
-	return {
-		imports: config.imports,
-		settings: config.settings,
-		mcpServers: { ...importedServers, ...config.mcpServers },
-	};
-}
-
-function resolveImportPath(importKind: ImportKind, cwd: string): string | null {
-	for (const candidate of IMPORT_PATHS[importKind]) {
-		const fullPath = candidate.startsWith(".") ? path.resolve(cwd, candidate) : candidate;
-		if (fs.existsSync(fullPath)) return fullPath;
-	}
-	return null;
-}
-
-function extractServers(config: unknown, kind: ImportKind): Record<string, ServerEntry> {
-	if (!config || typeof config !== "object" || Array.isArray(config)) return {};
-	const obj = config as Record<string, unknown>;
-	const servers = kind === "windsurf" || kind === "vscode" ? (obj.mcpServers ?? obj["mcp-servers"]) : obj.mcpServers;
-	return servers && typeof servers === "object" && !Array.isArray(servers)
-		? (servers as Record<string, ServerEntry>)
-		: {};
-}
-
-export function resolveMcpDirectToolNamesFromConfig(
-	config: McpConfig,
-	cache: MetadataCache,
-	prefix: ToolPrefix,
-	envOverride: string[],
-): string[] {
-	const names: string[] = [];
-	const seenNames = new Set<string>();
-	const { servers: selectedServers, tools: selectedTools } = parseMcpDirectToolSelections(envOverride);
-
-	for (const [serverName, definition] of Object.entries(config.mcpServers)) {
-		const serverCache = cache.servers[serverName];
-		if (!isServerCacheValid(serverCache, definition)) continue;
-
-		const toolFilter = selectedServers.has(serverName) ? true : selectedTools.get(serverName);
-		if (!toolFilter) continue;
-
-		for (const tool of Array.isArray(serverCache.tools) ? serverCache.tools : []) {
-			if (typeof tool?.name !== "string" || !tool.name) continue;
-			if (toolFilter !== true && !toolFilter.has(tool.name)) continue;
-			if (isToolExcluded(tool.name, serverName, prefix, definition.excludeTools)) continue;
-			const prefixedName = formatToolName(tool.name, serverName, prefix);
-			if (BUILTIN_TOOL_NAMES.has(prefixedName) || seenNames.has(prefixedName)) continue;
-			seenNames.add(prefixedName);
-			names.push(prefixedName);
-		}
-
-		if (definition.exposeResources === false) continue;
-		for (const resource of Array.isArray(serverCache.resources) ? serverCache.resources : []) {
-			if (typeof resource?.name !== "string" || !resource.name || typeof resource.uri !== "string" || !resource.uri)
-				continue;
-			const baseName = `get_${resourceNameToToolName(resource.name)}`;
-			if (toolFilter !== true && !toolFilter.has(baseName)) continue;
-			if (isToolExcluded(baseName, serverName, prefix, definition.excludeTools)) continue;
-			const prefixedName = formatToolName(baseName, serverName, prefix);
-			if (BUILTIN_TOOL_NAMES.has(prefixedName) || seenNames.has(prefixedName)) continue;
-			seenNames.add(prefixedName);
-			names.push(prefixedName);
-		}
-	}
-
-	return names;
-}
-
-export function parseMcpDirectToolSelections(selections: string[]): {
-	servers: Set<string>;
-	tools: Map<string, Set<string>>;
-} {
-	const servers = new Set<string>();
-	const tools = new Map<string, Set<string>>();
-	for (let item of selections) {
-		item = item.replace(/\/+$/, "");
-		if (item.includes("/")) {
-			const [server, tool] = item.split("/", 2);
-			if (server && tool) {
-				if (!tools.has(server)) tools.set(server, new Set());
-				tools.get(server)!.add(tool);
-			} else if (server) {
-				servers.add(server);
-			}
-		} else if (item) {
-			servers.add(item);
-		}
-	}
-	return { servers, tools };
-}
-
-function isServerCacheValid(entry: ServerCacheEntry | undefined, definition: ServerEntry): entry is ServerCacheEntry {
-	if (!entry || entry.configHash !== computeMcpServerHash(definition)) return false;
-	if (!entry.cachedAt || typeof entry.cachedAt !== "number") return false;
-	return Date.now() - entry.cachedAt <= CACHE_MAX_AGE_MS;
-}
-
-export function computeMcpServerHash(definition: ServerEntry): string {
-	const identity: Record<string, unknown> = {
-		command: definition.command,
-		args: definition.args,
-		env: interpolateEnvRecord(definition.env),
-		cwd: resolveConfigPath(definition.cwd),
-		url: definition.url,
-		headers: interpolateEnvRecord(definition.headers),
-		auth: definition.auth,
-		bearerTokenPresent: hasBearerToken(definition),
-		bearerTokenEnv: definition.bearerTokenEnv,
-		exposeResources: definition.exposeResources,
-		excludeTools: definition.excludeTools,
-	};
-	return createHash("sha256").update(stableStringify(identity)).digest("hex");
-}
-
-function getToolPrefix(value: unknown): ToolPrefix {
-	return value === "none" || value === "short" || value === "server" ? value : "server";
-}
-
-function isImportKind(value: unknown): value is ImportKind {
-	return typeof value === "string" && Object.hasOwn(IMPORT_PATHS, value);
-}
-
-function getServerPrefix(serverName: string, mode: ToolPrefix): string {
-	if (mode === "none") return "";
-	if (mode === "short") {
-		const short = serverName.replace(/-?mcp$/i, "").replace(/-/g, "_");
-		return short || "mcp";
-	}
-	return serverName.replace(/-/g, "_");
-}
-
-function formatToolName(toolName: string, serverName: string, prefix: ToolPrefix): string {
-	const serverPrefix = getServerPrefix(serverName, prefix);
-	return serverPrefix ? `${serverPrefix}_${toolName}` : toolName;
-}
-
-function isToolExcluded(toolName: string, serverName: string, prefix: ToolPrefix, excludeTools: unknown): boolean {
-	if (!Array.isArray(excludeTools) || excludeTools.length === 0) return false;
-	const candidates = new Set([
-		normalizeToolName(toolName),
-		normalizeToolName(formatToolName(toolName, serverName, prefix)),
-		normalizeToolName(formatToolName(toolName, serverName, "server")),
-		normalizeToolName(formatToolName(toolName, serverName, "short")),
-	]);
-	return excludeTools.some((excluded) => typeof excluded === "string" && candidates.has(normalizeToolName(excluded)));
-}
-
-function normalizeToolName(value: string): string {
-	return value.replace(/-/g, "_");
-}
-
-function resourceNameToToolName(name: string): string {
-	let result = name
-		.replace(/[^a-zA-Z0-9]/g, "_")
-		.replace(/_+/g, "_")
-		.replace(/^_+/, "")
-		.replace(/_+$/, "")
-		.toLowerCase();
-	if (!result || /^\d/.test(result)) result = `resource${result ? `_${result}` : ""}`;
-	return result;
-}
-
-function interpolateEnvRecord(values: Record<string, string> | undefined): Record<string, string> | undefined {
-	if (!values || typeof values !== "object" || Array.isArray(values)) return undefined;
-	const resolved: Record<string, string> = {};
-	for (const [key, value] of Object.entries(values)) {
-		if (typeof value === "string") resolved[key] = interpolateEnvVars(value);
-	}
-	return resolved;
-}
-
-function interpolateEnvVars(value: string): string {
-	return value
-		.replace(/\$\{(\w+)\}/g, (_, name: string) => process.env[name] ?? "")
-		.replace(/\$env:(\w+)/g, (_, name: string) => process.env[name] ?? "");
-}
-
-function resolveConfigPath(value: string | undefined): string | undefined {
-	if (typeof value !== "string") return undefined;
-	const resolved = interpolateEnvVars(value);
-	if (resolved === "~") return os.homedir();
-	if (resolved.startsWith("~/") || resolved.startsWith("~\\")) return path.join(os.homedir(), resolved.slice(2));
-	return resolved;
-}
-
-function hasBearerToken(definition: Pick<ServerEntry, "bearerToken" | "bearerTokenEnv">): boolean {
-	if (typeof definition.bearerToken === "string") return interpolateEnvVars(definition.bearerToken).length > 0;
-	return typeof definition.bearerTokenEnv === "string" && Boolean(process.env[definition.bearerTokenEnv]);
-}
-
-function stableStringify(value: unknown): string {
-	if (value === null || value === undefined || typeof value !== "object") {
-		const serialized = JSON.stringify(value);
-		return serialized === undefined ? "undefined" : serialized;
-	}
-	if (Array.isArray(value)) return `[${value.map((entry) => stableStringify(entry)).join(",")}]`;
-	const obj = value as Record<string, unknown>;
-	return `{${Object.keys(obj)
-		.sort()
-		.map((key) => `${JSON.stringify(key)}:${stableStringify(obj[key])}`)
-		.join(",")}}`;
-}

package/dist/builtin/subagents/src/runs/shared/model-candidate-filter.ts

@@ -1,56 +0,0 @@
-import { splitKnownThinkingSuffix } from "../../shared/model-info.js";
-import type { ModelAttempt } from "../../shared/types.js";
-import type { AvailableModelInfo } from "./model-fallback.js";
-
-export interface FilteredModelCandidates {
-	candidates: string[];
-	skippedAttempts: ModelAttempt[];
-}
-
-function providerFromModel(model: string | undefined): string | undefined {
-	if (!model) return undefined;
-	const { baseModel } = splitKnownThinkingSuffix(model);
-	const slash = baseModel.indexOf("/");
-	return slash > 0 ? baseModel.slice(0, slash) : undefined;
-}
-
-export function skippedModelAttempt(model: string, reason: string): ModelAttempt {
-	return {
-		model,
-		success: false,
-		error: reason,
-	};
-}
-
-export function filterSpawnableModelCandidates(params: {
-	candidates: string[];
-	availableModels?: AvailableModelInfo[];
-	knownModelProviders?: string[];
-	currentModel?: string;
-}): FilteredModelCandidates {
-	const providersWithAvailableAuth = new Set((params.availableModels ?? []).map((model) => model.provider));
-	const knownProviders = new Set(params.knownModelProviders ?? []);
-	const currentModel = params.currentModel;
-	const filtered: string[] = [];
-	const skippedAttempts: ModelAttempt[] = [];
-	for (const candidate of params.candidates) {
-		if (currentModel && candidate === currentModel) {
-			filtered.push(candidate);
-			continue;
-		}
-		const provider = providerFromModel(candidate);
-		const shouldSkip =
-			provider !== undefined && knownProviders.has(provider) && !providersWithAvailableAuth.has(provider);
-		if (!shouldSkip) {
-			filtered.push(candidate);
-			continue;
-		}
-		skippedAttempts.push(
-			skippedModelAttempt(
-				candidate,
-				`Skipped ${candidate}: provider '${provider}' has no configured API key/auth in the current session.`,
-			),
-		);
-	}
-	return { candidates: filtered, skippedAttempts };
-}

package/dist/builtin/subagents/src/runs/shared/model-fallback.ts

@@ -1,88 +0,0 @@
-import type { ModelFallbackFailureKind, ModelFallbackFailureSignal, ModelFallbackFailureSource } from "@bastani/atomic";
-import {
-	errorMessage,
-	isRetryableModelFailure,
-	modelFailureMessage,
-	normalizeModelFailureSignal,
-} from "@bastani/atomic";
-import {
-	type ModelInfo as AvailableModelInfo,
-	splitKnownThinkingSuffix,
-	THINKING_LEVELS,
-} from "../../shared/model-info.js";
-import type { Usage } from "../../shared/types.js";
-
-export type { AvailableModelInfo, ModelFallbackFailureKind, ModelFallbackFailureSignal, ModelFallbackFailureSource };
-export { errorMessage, isRetryableModelFailure, modelFailureMessage, normalizeModelFailureSignal };
-
-interface ModelAttemptSummary {
-	model: string;
-	success: boolean;
-	error?: string;
-	usage?: Usage;
-}
-
-function applyFallbackThinkingLevel(model: string, thinkingLevel: string | undefined): string {
-	if (!thinkingLevel || !THINKING_LEVELS.some((level) => level === thinkingLevel)) return model;
-	const { thinkingSuffix } = splitKnownThinkingSuffix(model);
-	return thinkingSuffix ? model : `${model}:${thinkingLevel}`;
-}
-
-export function applyThinkingSuffix(model: string | undefined, thinking: string | undefined): string | undefined {
-	if (!model || !thinking || thinking === "off") return model;
-	return applyFallbackThinkingLevel(model, thinking);
-}
-
-export function resolveModelCandidate(
-	model: string | undefined,
-	availableModels: AvailableModelInfo[] | undefined,
-	preferredProvider?: string,
-): string | undefined {
-	if (!model) return undefined;
-	if (model.includes("/")) return model;
-	if (!availableModels || availableModels.length === 0) return model;
-
-	const { baseModel, thinkingSuffix } = splitKnownThinkingSuffix(model);
-	const matches = availableModels.filter((entry) => entry.id === baseModel);
-	if (preferredProvider) {
-		const preferredMatch = matches.find((entry) => entry.provider === preferredProvider);
-		if (preferredMatch) return `${preferredMatch.fullId}${thinkingSuffix}`;
-	}
-	if (matches.length !== 1) return model;
-	return `${matches[0]!.fullId}${thinkingSuffix}`;
-}
-
-export function buildModelCandidates(
-	primaryModel: string | undefined,
-	fallbackModels: string[] | undefined,
-	availableModels: AvailableModelInfo[] | undefined,
-	preferredProvider?: string,
-	currentModel?: string,
-	fallbackThinkingLevels?: string[],
-): string[] {
-	const seen = new Set<string>();
-	const candidates: string[] = [];
-	const fallbackEntries = (fallbackModels ?? []).map((model, index) =>
-		applyFallbackThinkingLevel(model, fallbackThinkingLevels?.[index]),
-	);
-	for (const raw of [primaryModel, ...fallbackEntries, currentModel]) {
-		if (!raw) continue;
-		const normalized = resolveModelCandidate(raw.trim(), availableModels, preferredProvider);
-		if (!normalized || seen.has(normalized)) continue;
-		seen.add(normalized);
-		candidates.push(normalized);
-	}
-	return candidates;
-}
-
-export function currentModelFullId(model: { provider: string; id: string } | undefined): string | undefined {
-	if (!model) return undefined;
-	return `${String(model.provider)}/${model.id}`;
-}
-
-export function formatModelAttemptNote(attempt: ModelAttemptSummary, nextModel?: string): string {
-	const failure = attempt.error?.trim() || "model failure";
-	return nextModel
-		? `[fallback] ${attempt.model} failed: ${failure}. Retrying with ${nextModel}.`
-		: `[fallback] ${attempt.model} failed: ${failure}.`;
-}

package/dist/builtin/subagents/src/runs/shared/parallel-utils.ts

@@ -1,70 +0,0 @@
-export async function mapConcurrent<T, R>(
-	items: T[],
-	limit: number,
-	fn: (item: T, i: number) => Promise<R>,
-): Promise<R[]> {
-	const safeLimit = Math.max(1, Math.floor(limit) || 1);
-	const results: R[] = new Array(items.length);
-	let next = 0;
-
-	async function worker(_workerIndex: number): Promise<void> {
-		while (next < items.length) {
-			const i = next++;
-			results[i] = await fn(items[i], i);
-		}
-	}
-
-	await Promise.all(Array.from({ length: Math.min(safeLimit, items.length) }, (_, wi) => worker(wi)));
-	return results;
-}
-
-export interface ParallelTaskResult {
-	agent: string;
-	taskIndex?: number;
-	output: string;
-	status: import("../../shared/types.js").SubagentAttemptStatus;
-	error?: string;
-	model?: string;
-	fastMode?: boolean;
-	attemptedModels?: string[];
-	outputTargetPath?: string;
-	outputTargetExists?: boolean;
-}
-
-export function aggregateParallelOutputs(
-	results: ParallelTaskResult[],
-	headerFormat: (index: number, agent: string) => string = (i, agent) => `=== Parallel Task ${i + 1} (${agent}) ===`,
-): string {
-	return results
-		.map((r, i) => {
-			const header = headerFormat(r.taskIndex ?? i, r.agent);
-			const hasOutput = Boolean(r.output?.trim());
-			const status =
-				r.status === "skipped"
-					? "SKIPPED"
-					: r.status === "continued"
-						? "CONTINUED"
-						: r.status === "error"
-							? `FAILED${r.error ? `: ${r.error}` : ""}`
-							: r.error
-								? `WARNING: ${r.error}`
-								: !hasOutput && r.outputTargetPath && r.outputTargetExists === false
-									? `EMPTY OUTPUT (expected output file missing: ${r.outputTargetPath})`
-									: !hasOutput && !r.outputTargetPath
-										? "EMPTY OUTPUT (no textual response returned)"
-										: "";
-			const body = status ? (hasOutput ? `${status}\n${r.output}` : status) : r.output;
-			return `${header}\n${body}`;
-		})
-		.join("\n\n");
-}
-
-export function formatParallelResultContent(
-	results: ParallelTaskResult[],
-	headerFormat: (index: number, agent: string) => string,
-): string {
-	const ok = results.filter((result) => result.status === "ok").length;
-	return `${ok}/${results.length} succeeded\n\n${aggregateParallelOutputs(results, headerFormat)}`;
-}
-
-export const MAX_PARALLEL_CONCURRENCY = 4;

package/dist/builtin/subagents/src/runs/shared/progress-trend.ts

@@ -1,69 +0,0 @@
-/** Pure progress-trend evidence shared by subagent control decisions. */
-
-export const DEFAULT_TREND_WINDOW = 3;
-export const DEFAULT_RISE_DELTA = 1.5;
-export const DEFAULT_FALL_DELTA = -1.5;
-export const FLAT_LOW_SCORE_CEILING = 8;
-export const PROGRESS_ATTENTION_THRESHOLD_FRACTION = 0.5;
-
-export type TrendConfig = {
-	window?: number;
-	riseDelta?: number;
-	fallDelta?: number;
-};
-
-export type Trend = "rising" | "flat" | "regressing";
-
-export type TrendResult = {
-	trend: Trend;
-	evidence: {
-		series: readonly number[];
-		window: number;
-		delta: number;
-	};
-};
-
-function mean(values: readonly number[]): number {
-	if (values.length === 0) return 0;
-	return values.reduce((total, value) => total + value, 0) / values.length;
-}
-
-/**
- * Classify a score series using the same deterministic hysteresis as workflows.
- * The result is evidence only: it carries no run action or terminal status.
- */
-export function classify_trend(series: readonly number[], config: TrendConfig = {}): TrendResult {
-	const window = config.window ?? DEFAULT_TREND_WINDOW;
-	const riseDelta = config.riseDelta ?? DEFAULT_RISE_DELTA;
-	const fallDelta = config.fallDelta ?? DEFAULT_FALL_DELTA;
-	if (series.length < window + 1) {
-		return { trend: "flat", evidence: { series, window, delta: 0 } };
-	}
-	const sample = series.slice(-2 * window);
-	const usableLength = sample.length % 2 === 1 ? sample.length - 1 : sample.length;
-	const halfLength = usableLength / 2;
-	const leading = sample.slice(0, halfLength);
-	const trailing = sample.slice(sample.length - halfLength);
-	const delta = halfLength === 0 ? 0 : mean(trailing) - mean(leading);
-	const trend: Trend = delta >= riseDelta ? "rising" : delta <= fallDelta ? "regressing" : "flat";
-	return { trend, evidence: { series, window, delta } };
-}
-
-function hasFiniteProgressScores(series: readonly number[] | undefined): series is readonly number[] {
-	return series !== undefined && series.length > 0 && series.every((score) => Number.isFinite(score));
-}
-
-export function hasProgressAttentionSignal(series: readonly number[] | undefined): boolean {
-	if (!hasFiniteProgressScores(series)) return false;
-	const result = classify_trend(series);
-	const latest = series.at(-1);
-	return (
-		result.trend === "regressing" ||
-		(result.trend === "flat" && latest !== undefined && latest <= FLAT_LOW_SCORE_CEILING)
-	);
-}
-
-/** Lower a wall-clock threshold only when progress evidence raises priority. */
-export function progressAwareThreshold(baseMs: number, series: readonly number[] | undefined): number {
-	return hasProgressAttentionSignal(series) ? Math.max(1, baseMs * PROGRESS_ATTENTION_THRESHOLD_FRACTION) : baseMs;
-}