@coool/pi-adaptive 1.0.0 → 1.0.1

package/dist/index.js

@@ -693,8 +693,13 @@ function updatePreferences(file, patch) {
 	});
 }
 // ../core/src/state/receipts/bound.ts
+/**
+* Agent-written evidence can carry emoji; cutting between the halves of a
+* surrogate pair would persist a lone surrogate that renders as garbage and
+* throws in URI encoders, so the cut backs off to the pair boundary.
+*/
 function boundText(raw) {
-	return raw.length > 128 ? raw.slice(0, 128) : raw;
+	return truncateBounded(raw, 128);
 }
 function boundRef(ref) {
 	return {
@@ -804,8 +809,7 @@ function isRecord$2(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
 }
 function boundString(raw) {
-	if (typeof raw !== "string") return void 0;
-	return raw.length > 128 ? raw.slice(0, 128) : raw;
+	return typeof raw === "string" ? boundText(raw) : void 0;
 }
 function isFiniteNonNegative(raw) {
 	return typeof raw === "number" && Number.isFinite(raw) && raw >= 0;
@@ -1650,6 +1654,15 @@ function classifyFailure(evidence) {
 * refuses. Termination rests on the budget, which the caller must carry
 * across every unit of one task (each escalation continues on a new unit).
 */
+/**
+* Only a well-formed whole-number budget can bound the loop: NaN, infinite,
+* fractional, or negative counters would make `used >= max` unreachable or
+* leave a negative remainder, so they read as exhausted (finite is the
+* invariant, not the caller's good behavior).
+*/
+function hasBudgetLeft({ used, max }) {
+	return Number.isSafeInteger(used) && Number.isSafeInteger(max) && used >= 0 && used < max;
+}
 function escalate(input, target, step, tier) {
 	return {
 		kind: "escalate",
@@ -1669,7 +1682,7 @@ function planEscalation(input) {
 		kind: "defer",
 		reason: "escalation-not-justified"
 	};
-	if (input.budget.max <= 0 || input.budget.used >= input.budget.max) return {
+	if (!hasBudgetLeft(input.budget)) return {
 		kind: "defer",
 		reason: "escalation-budget-exhausted"
 	};
@@ -2811,6 +2824,7 @@ var ResourceHealthRegistry = class {
 		const records = resourceChain(key).map((chainKey) => this.#sweptRecord(chainKey, now));
 		const hard = hardest(records, now);
 		if (hard !== void 0) return blocked(hard.reason, hard.key, hard.retryAtMs);
+		const due = [];
 		for (const record of records) {
 			if (record === void 0) continue;
 			const expired = expireProbe(record.breaker, now, this.#config.breaker);
@@ -2821,14 +2835,20 @@ var ResourceHealthRegistry = class {
 			};
 			if (current !== record) this.#records.set(resourceKeyID(record.key), current);
 			const admission = admitProbe(current.breaker, now);
-			if (admission.kind === "closed") continue;
 			if (admission.kind === "waiting") return blocked("breaker-open", record.key, admission.retryAtMs);
 			if (admission.kind === "in-flight") return blocked("probe-in-flight", record.key, void 0);
+			if (admission.kind === "admitted") due.push({
+				record,
+				breaker: admission.record
+			});
+		}
+		const first = due[0];
+		if (first !== void 0) {
 			const probeId = this.#newProbeId();
-			this.#records.set(resourceKeyID(record.key), {
-				...record,
+			this.#records.set(resourceKeyID(first.record.key), {
+				...first.record,
 				breaker: {
-					...admission.record,
+					...first.breaker,
 					probeId,
 					probeAt: now
 				},
@@ -2838,7 +2858,7 @@ var ResourceHealthRegistry = class {
 				kind: "probe",
 				ticket: {
 					id: probeId,
-					key: record.key
+					key: first.record.key
 				}
 			};
 		}
@@ -3611,7 +3631,7 @@ function planWake(targets, now, fruitless) {
 * waiting for a stated reset is free, only resumed work that failed again
 * counts.
 */
-const MAX_WAKES = 5;
+const MAX_WAKES = 96;
 const PARK_ENTRY = "adaptive.parked";
 var WaitCancelled = class extends Error {
 	constructor() {
@@ -3687,14 +3707,18 @@ function claimPark(file, record, now, manual = false) {
 		};
 	});
 }
+/** Drops the session's records; true when one was still waiting (not yet claimed). */
 function cancelPark(file, session) {
-	return file.update((value) => ({
-		next: {
-			version: 1,
-			records: records(value).filter((row) => row.session !== session)
-		},
-		result: void 0
-	}));
+	return file.update((value) => {
+		const rows = records(value);
+		return {
+			next: {
+				version: 1,
+				records: rows.filter((row) => row.session !== session)
+			},
+			result: rows.some((row) => row.session === session && !row.claimed)
+		};
+	});
 }
 /** Abortable ticks, shared by countdowns and long owned headless waits. */
 async function waitUntil(sources, due, signal, tick) {
@@ -4018,7 +4042,10 @@ function virtualModels(sources, activeTools, parking, dispatched, feedback) {
 				}
 				selectedRef = fallback;
 			} else {
-				if (decision.kind !== "apply") throw new Error(`Adaptive unavailable: ${decision.reason}. Check your tier settings.`);
+				if (decision.kind !== "apply") {
+					const undeclared = decision.reason === "no-compatible-resource" && decision.detail?.includes("tool-use-unsupported") === true;
+					throw new Error(undeclared ? `Adaptive unavailable: ${decision.reason}. Run /adaptive tools to declare which of your models call tools.` : `Adaptive unavailable: ${decision.reason}. Check your tier settings.`);
+				}
 				selectedRef = decision.model;
 			}
 			const selected = prepared.models.find((model) => model.provider === selectedRef.providerID && model.id === selectedRef.id);
@@ -4298,11 +4325,12 @@ function parkingHandlers(pi, sources, tracker = { last: void 0 }) {
 		disarm?.();
 		disarm = void 0;
 	};
+	/** True when a still-waiting record was dropped. */
 	const cancel = async (ctx) => {
 		stop();
 		clearParked(ctx);
 		const session = ctx.sessionManager.getSessionId?.();
-		if (session !== void 0 && ctx.sessionManager.getBranch().some((entry) => entry.customType === "adaptive.parked")) await cancelPark(sources.parking.file, session);
+		return session !== void 0 && ctx.sessionManager.getBranch().some((entry) => entry.customType === "adaptive.parked") && cancelPark(sources.parking.file, session);
 	};
 	const noteResume = async (owned, tier) => {
 		try {
@@ -4320,9 +4348,9 @@ function parkingHandlers(pi, sources, tracker = { last: void 0 }) {
 		const owned = generation;
 		if (!await claimPark(sources.parking.file, record, now, manual)) {
 			clearParked(ctx);
-			return;
+			return false;
 		}
-		if (owned !== generation) return;
+		if (owned !== generation) return false;
 		clearParked(ctx);
 		if (saved.input !== void 0) {
 			resumedInput = {
@@ -4351,6 +4379,7 @@ function parkingHandlers(pi, sources, tracker = { last: void 0 }) {
 			}
 		}, { triggerTurn: true });
 		await noteResume(owned, record.tier);
+		return true;
 	};
 	const arm = (ctx, record, saved) => {
 		showParked(ctx, record);
@@ -4517,12 +4546,9 @@ function parkingHandlers(pi, sources, tracker = { last: void 0 }) {
 		const session = ctx.sessionManager.getSessionId?.();
 		const record = session === void 0 ? void 0 : await findPark(sources.parking.file, session);
 		const saved = record === void 0 ? void 0 : parkedPayload(ctx, record.token);
-		if (record === void 0 || saved === void 0) {
-			ctx.ui?.notify("Nothing is parked in this session.", "info");
-			return;
-		}
+		if (record === void 0 || saved === void 0) return "not-parked";
 		stop();
-		await wake(ctx, record, saved, record.due, true);
+		return await wake(ctx, record, saved, record.due, true) ? "resumed" : "not-parked";
 	};
 	const clearServed = async (task, ctx) => {
 		try {
@@ -4544,7 +4570,7 @@ function parkingHandlers(pi, sources, tracker = { last: void 0 }) {
 		sessionStart,
 		resume,
 		clearServed,
-		cancel,
+		cancel: async (ctx) => await cancel(ctx) ? "cancelled" : "not-parked",
 		shutdown: stop,
 		async recover(recovery, ctx) {
 			const id = selectedVirtual(ctx.model);
@@ -4638,31 +4664,6 @@ function parkingHandlers(pi, sources, tracker = { last: void 0 }) {
 		}
 	};
 }
-// ../core/src/flow/waiting.ts
-const DAY_MS = 864e5;
-const WEEK_DAYS = 6;
-function startOfDay(at) {
-	const date = new Date(at);
-	return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
-}
-function clock(date) {
-	return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
-}
-/**
-* Short human text for a parked session (ADP-024): "waiting · resumes 18:42". Weekly limits reset days away, so
-* a later day gains its weekday, and beyond a week its date. Local fields, not the locale formatter, keep the
-* text identical across hosts.
-*/
-function waitingLabel(resumeAt, now) {
-	if (resumeAt === null) return "waiting";
-	if (resumeAt <= now) return "waiting · resuming";
-	const date = new Date(resumeAt);
-	const days = Math.round((startOfDay(resumeAt) - startOfDay(now)) / DAY_MS);
-	if (days === 0) return `waiting · resumes ${clock(date)}`;
-	const day = date.toDateString();
-	if (days <= WEEK_DAYS) return `waiting · resumes ${day.slice(0, 3)} ${clock(date)}`;
-	return `waiting · resumes ${day.slice(4, 7)} ${String(date.getDate())} ${clock(date)}`;
-}
 // src/health-actions.ts
 function parseSharedHealth(raw) {
 	if (raw === void 0) return [];
@@ -4712,76 +4713,86 @@ const PI_COPY = {
 	receiptExplanation: (reason) => defer[reason],
 	parkExplanation: (reason) => park[reason]
 };
-// src/ui/doctor.ts
-function parts(version) {
-	if (!/^\d+\.\d+\.\d+$/.test(version)) return void 0;
-	const [major, minor, patch] = version.split(".");
-	return [
-		Number(major),
-		Number(minor),
-		Number(patch)
-	];
+// ../core/src/flow/status.ts
+/**
+* Status-view helpers (ADP-033): flatten the status snapshot into one page
+* showing every configured model with its state, grouped by tier in priority
+* order. Pure and deterministic; local wall-clock rendering is derived from
+* the snapshot's own timestamps.
+*/
+/** Configured resources in tier order (quick → standard → advanced). */
+function healthEntries(snapshot) {
+	const entries = [];
+	for (const tier of TIERS) for (const status of snapshot.tiers[tier]) entries.push({
+		tier,
+		status
+	});
+	return entries;
 }
-function compare(a, b) {
-	for (const index of [
-		0,
-		1,
-		2
-	]) {
-		const difference = a[index] - b[index];
-		if (difference !== 0) return difference;
+/** Local date and time: quota windows may reset days or weeks from now. */
+function clockTime(until) {
+	const at = new Date(until);
+	const hours = String(at.getHours()).padStart(2, "0");
+	const minutes = String(at.getMinutes()).padStart(2, "0");
+	const month = String(at.getMonth() + 1).padStart(2, "0");
+	const day = String(at.getDate()).padStart(2, "0");
+	return `${String(at.getFullYear())}-${month}-${day} ${hours}:${minutes}`;
+}
+function pinnedTo(ref, pin) {
+	if (pin === null) return false;
+	return pin.providerID === ref.providerID && pin.id === ref.id && pin.variant === ref.variant;
+}
+/** Everything after the health state: capacity usage, window, breaker, pin. */
+function stateSuffix(status, pin) {
+	let suffix = "";
+	if (status.windowed) suffix += status.windowUntil === null ? ", windowed (deadline unknown)" : `, windowed until ${clockTime(status.windowUntil)}`;
+	if (status.usedPercent !== null) {
+		suffix += `, used ${String(status.usedPercent)}%`;
+		if (status.resetAt !== null) suffix += `, resets ${clockTime(status.resetAt)}`;
 	}
-	return 0;
+	if (status.breaker === "open") suffix += ", breaker open";
+	else if (status.breaker === "half_open") suffix += ", probing";
+	if (pinnedTo(status.ref, pin)) suffix += " (pinned)";
+	return suffix;
 }
-function versionChecks(version, minimum, testedUpTo) {
-	const actual = parts(version);
-	const floor = parts(minimum);
-	const tested = testedUpTo === void 0 ? void 0 : parts(testedUpTo);
-	if (actual === void 0 || floor === void 0) return [{
-		state: "warning",
-		message: `Pi ${version}: version support could not be checked`,
-		action: "Pick a normal model and report this version."
-	}];
-	if (actual[0] !== 1 || compare(actual, floor) < 0) return [{
-		state: "error",
-		message: `Pi ${version} is unsupported (requires ≥${minimum} <2)`,
-		action: "Install a supported Pi version or pick a normal model."
-	}];
-	const checks = [{
-		state: "ok",
-		message: `Pi ${version} (supported: ≥${minimum} <2)`
-	}];
-	if (tested === void 0) checks.push({
-		state: "warning",
-		message: "Packed-host tested-up-to evidence is not recorded",
-		action: "Run the complete Pi host matrix before release."
-	});
-	else if (compare(actual, tested) > 0) checks.push({
-		state: "warning",
-		message: `Pi ${version} is newer than last tested ${String(testedUpTo)}`,
-		action: "If routing misbehaves, pick a normal model and report it."
-	});
-	else checks.push({
-		state: "ok",
-		message: `Packed hosts tested up to ${String(testedUpTo)}`
-	});
-	return checks;
+/** The STATE column of the status table: window, breaker, pin markers. */
+function stateCell(status, pin) {
+	return stateSuffix(status, pin).replace(/^[, ]+/, "") || "-";
 }
-const LABELS = {
-	ok: "OK",
-	warning: "CHECK",
-	error: "FIX"
-};
-const SEVERITY = [
-	"error",
-	"warning",
-	"ok"
-];
-/** Problems first: the first screen answers "is anything wrong, and what do I do". */
-function doctorLines(checks) {
-	const count = (state) => checks.filter((check) => check.state === state).length;
-	return [count("error") + count("warning") === 0 ? `All ${String(checks.length)} checks OK` : `${String(count("error"))} to fix · ${String(count("warning"))} to check · ${String(count("ok"))} OK`, ...SEVERITY.flatMap((state) => checks.filter((check) => check.state === state)).flatMap((check) => [`${LABELS[check.state]} ${check.message}`, ...check.action === void 0 ? [] : [`  ${check.action}`]])];
+/**
+* The whole inventory as a column-aligned table (header row first): models
+* grouped in tier order (quick → standard → advanced), one row per model,
+* columns padded to the widest cell so the grid reads at a glance. There is
+* no per-resource selection step: the table IS the view.
+*/
+function statusTable(snapshot) {
+	const header = [
+		"MODEL",
+		"TIER",
+		"HEALTH",
+		"STATE"
+	];
+	const rows = healthEntries(snapshot).map(({ tier, status }) => [
+		resourceLabel(status.ref),
+		tier,
+		status.health,
+		stateCell(status, snapshot.pin)
+	]);
+	const widths = header.map((cell, column) => Math.max(cell.length, ...rows.map((row) => row[column].length)));
+	const render = (cells) => cells.map((cell, column) => cell.padEnd(widths[column])).join("  ").trimEnd();
+	return [render(header), ...rows.map(render)];
 }
+/** Narrow hosts keep health and capacity visible instead of clipping wide model columns. */
+function compactStatus(snapshot) {
+	return healthEntries(snapshot).flatMap(({ tier, status }) => [
+		resourceLabel(status.ref),
+		`${tier} · ${status.health}`,
+		...stateCell(status, snapshot.pin).split(", ").map((part) => `  ${part}`),
+		""
+	]);
+}
+/** Empty-state copy for the status view when nothing is configured. */
+const STATUS_EMPTY_MESSAGE = "No models configured yet — open Models to add some.";
 // src/capabilities.ts
 function object(value) {
 	return typeof value === "object" && value !== null && !Array.isArray(value);
@@ -4829,6 +4840,22 @@ function parseToolCapabilities(raw) {
 		};
 	});
 }
+function updateToolCapability(file, ref, tools) {
+	return file.update((current) => {
+		const entries = current === void 0 ? [] : parseToolCapabilities(current);
+		const entry = {
+			providerID: ref.providerID,
+			id: ref.id,
+			tools
+		};
+		const models = [...entries.filter((model) => model.providerID !== ref.providerID || model.id !== ref.id), entry];
+		parseToolCapabilities({ models });
+		return {
+			next: { models },
+			result: void 0
+		};
+	});
+}
 // src/host/actions.ts
 const DEFAULT_MODEL_HELP = "In Pi settings.json, set:\n{\n  \"defaultProvider\": \"adaptive\",\n  \"defaultModel\": \"auto\"\n}\nPi exposes no extension API to save this default. Your current model is unchanged.";
 async function preferencesAction(view, file) {
@@ -4862,103 +4889,266 @@ async function preferencesAction(view, file) {
 	} else return;
 	view.toast("Preferences saved", "success");
 }
-async function healthAction(view, models, reset) {
+function declaredLabel(declared, ref) {
+	const entry = declared.find((model) => model.providerID === ref.providerID && model.id === ref.id);
+	if (entry === void 0) return "not declared · skipped on tool turns";
+	return entry.tools ? "calls tools" : "no tool calls";
+}
+/**
+* Pi's catalog does not say which models call tools, and Adaptive never
+* guesses from a name: an undeclared model is skipped on every tool turn.
+*/
+async function toolSupportAction(view, file, models, declared) {
+	const unique = [...new Map(models.map((model) => [`${model.providerID}/${model.id}`, {
+		providerID: model.providerID,
+		id: model.id
+	}]))];
+	if (unique.length === 0) {
+		await view.alert({
+			title: "Tool support",
+			message: STATUS_EMPTY_MESSAGE
+		});
+		return;
+	}
 	const ref = await view.select({
-		title: "Health · select a resource to reset",
-		options: models.map((model) => ({
-			title: resourceLabel(model),
+		title: "Tool support · select a model",
+		options: unique.map(([label, model]) => ({
+			title: label,
 			value: model,
-			description: "Mark healthy (also clears inherited provider limits)"
+			description: declaredLabel(declared, model)
 		}))
 	});
 	if (ref === void 0) return;
+	const tools = await view.select({
+		title: `${ref.providerID}/${ref.id}`,
+		options: [{
+			title: "Calls tools",
+			value: true,
+			description: "eligible for tool turns"
+		}, {
+			title: "No tool calls",
+			value: false,
+			description: "never routed to on tool turns"
+		}]
+	});
+	if (tools === void 0) return;
 	if (!await view.confirm({
-		title: "Reset resource health?",
-		message: `Reset ${resourceLabel(ref)} and its inherited provider limits? Other models on this provider may be affected. This does not restore actual provider quota.`
+		title: "Confirm tool capability",
+		message: `${ref.providerID}/${ref.id}: record tool support as ${tools ? "supported" : "unsupported"}? Only confirm this from provider documentation or a verified request.`
 	})) return;
-	await reset(ref);
-	view.toast("Health reset", "success");
+	await updateToolCapability(file, ref, tools);
+	view.toast("Tool capability saved", "success");
 }
-// ../core/src/flow/status.ts
+// ../core/src/flow/doctor.ts
 /**
-* Status-view helpers (ADP-033): flatten the status snapshot into one page
-* showing every configured model with its state, grouped by tier in priority
-* order. Pure and deterministic; local wall-clock rendering is derived from
-* the snapshot's own timestamps.
+* Doctor report (ADP-062): host checks plus the checks every host can derive
+* from the status snapshot, rendered problems-first so the first screen
+* answers "is anything wrong, and what do I do".
 */
-/** Configured resources in tier order (quick → standard → advanced). */
-function healthEntries(snapshot) {
-	const entries = [];
-	for (const tier of TIERS) for (const status of snapshot.tiers[tier]) entries.push({
-		tier,
-		status
-	});
-	return entries;
+function plural(count, noun) {
+	return `${String(count)} ${noun}${count === 1 ? "" : "s"}`;
 }
-/** Local date and time: quota windows may reset days or weeks from now. */
-function clockTime(until) {
-	const at = new Date(until);
-	const hours = String(at.getHours()).padStart(2, "0");
-	const minutes = String(at.getMinutes()).padStart(2, "0");
-	const month = String(at.getMonth() + 1).padStart(2, "0");
-	const day = String(at.getDate()).padStart(2, "0");
-	return `${String(at.getFullYear())}-${month}-${day} ${hours}:${minutes}`;
+/** Empty tiers, limited models and parked work, from one status snapshot. */
+function statusChecks(snapshot) {
+	const empty = TIERS.filter((tier) => snapshot.tiers[tier].length === 0).map((tier) => ({
+		state: "warning",
+		message: `${tier}: no configured models`,
+		action: "Open /adaptive tiers to add a model."
+	}));
+	const limited = new Set(healthEntries(snapshot).filter(({ status }) => status.health !== "healthy").map(({ status }) => resourceLabel(status.ref))).size;
+	return [
+		...empty,
+		limited === 0 ? {
+			state: "ok",
+			message: "Health: no models limited"
+		} : {
+			state: "ok",
+			message: `Health: ${plural(limited, "model")} limited`,
+			action: "Inspect /adaptive health; reset only after checking the provider."
+		},
+		snapshot.parked === 0 ? {
+			state: "ok",
+			message: "No parked work"
+		} : {
+			state: "ok",
+			message: plural(snapshot.parked, "parked task"),
+			action: "Use /adaptive resume or /adaptive cancel in the waiting session."
+		}
+	];
 }
-function pinnedTo(ref, pin) {
-	if (pin === null) return false;
-	return pin.providerID === ref.providerID && pin.id === ref.id && pin.variant === ref.variant;
+const LABELS = {
+	ok: "OK",
+	warning: "CHECK",
+	error: "FIX"
+};
+const SEVERITY = [
+	"error",
+	"warning",
+	"ok"
+];
+/** Problems first: the first screen answers "is anything wrong, and what do I do". */
+function doctorLines(checks) {
+	const count = (state) => checks.filter((check) => check.state === state).length;
+	return [count("error") + count("warning") === 0 ? `All ${String(checks.length)} checks OK` : `${String(count("error"))} to fix · ${String(count("warning"))} to check · ${String(count("ok"))} OK`, ...SEVERITY.flatMap((state) => checks.filter((check) => check.state === state)).flatMap((check) => [`${LABELS[check.state]} ${check.message}`, ...check.action === void 0 ? [] : [`  ${check.action}`]])];
 }
-/** Everything after the health state: capacity usage, window, breaker, pin. */
-function stateSuffix(status, pin) {
-	let suffix = "";
-	if (status.windowed) suffix += status.windowUntil === null ? ", windowed (deadline unknown)" : `, windowed until ${clockTime(status.windowUntil)}`;
-	if (status.usedPercent !== null) {
-		suffix += `, used ${String(status.usedPercent)}%`;
-		if (status.resetAt !== null) suffix += `, resets ${clockTime(status.resetAt)}`;
+// ../core/src/flow/waiting.ts
+const DAY_MS = 864e5;
+const WEEK_DAYS = 6;
+function startOfDay(at) {
+	const date = new Date(at);
+	return new Date(date.getFullYear(), date.getMonth(), date.getDate()).getTime();
+}
+function clock(date) {
+	return `${String(date.getHours()).padStart(2, "0")}:${String(date.getMinutes()).padStart(2, "0")}`;
+}
+/**
+* Short human text for a parked session (ADP-024): "waiting · resumes 18:42". Weekly limits reset days away, so
+* a later day gains its weekday, and beyond a week its date. Local fields, not the locale formatter, keep the
+* text identical across hosts.
+*/
+function waitingLabel(resumeAt, now) {
+	if (resumeAt === null) return "waiting";
+	if (resumeAt <= now) return "waiting · resuming";
+	const date = new Date(resumeAt);
+	const days = Math.round((startOfDay(resumeAt) - startOfDay(now)) / DAY_MS);
+	if (days === 0) return `waiting · resumes ${clock(date)}`;
+	const day = date.toDateString();
+	if (days <= WEEK_DAYS) return `waiting · resumes ${day.slice(0, 3)} ${clock(date)}`;
+	return `waiting · resumes ${day.slice(4, 7)} ${String(date.getDate())} ${clock(date)}`;
+}
+// ../core/src/flow/actions.ts
+const PARKED_TITLE = "Parked work";
+const NOTHING_PARKED = "Nothing is parked in this session.";
+const OPEN_SESSION = "Open the waiting session and run /adaptive there to resume or cancel it.";
+/** Pick a configured model, confirm, reset. Lists each model once, with its state. */
+async function runHealthReset(env, reset) {
+	const snapshot = await env.api.status();
+	const models = /* @__PURE__ */ new Map();
+	for (const { status } of healthEntries(snapshot)) models.set(resourceLabel(status.ref), status);
+	if (models.size === 0) {
+		await env.view.alert({
+			title: "Health",
+			message: STATUS_EMPTY_MESSAGE
+		});
+		return;
+	}
+	const model = await env.view.select({
+		title: "Health · select a model to reset",
+		options: [...models].map(([label, status]) => {
+			const state = stateCell(status, snapshot.pin);
+			return {
+				title: label,
+				value: status.ref,
+				description: state === "-" ? status.health : `${status.health} · ${state}`
+			};
+		})
+	});
+	if (model === void 0) return;
+	const label = resourceLabel(model);
+	if (await env.view.confirm({
+		title: "Reset model health?",
+		message: `Reset ${label} and its inherited provider limits? Other models on this provider may be affected. This does not restore actual provider quota.`
+	}) !== true) return;
+	await reset(model);
+	env.view.toast("Health reset", "success");
+}
+/** Resume this session's parked work. True when the run continues and the menu should close. */
+async function resumeHere(env, resume) {
+	if (env.sessionID === void 0) {
+		await env.view.alert({
+			title: PARKED_TITLE,
+			message: OPEN_SESSION
+		});
+		return false;
+	}
+	switch (await resume(env.sessionID)) {
+		case "resumed":
+			env.view.toast("Resuming parked work", "success");
+			return true;
+		case "waiting":
+			await env.view.alert({
+				title: PARKED_TITLE,
+				message: "No model in this tier is available yet. Adaptive keeps waiting and retries."
+			});
+			return false;
+		case "not-parked":
+			await env.view.alert({
+				title: PARKED_TITLE,
+				message: NOTHING_PARKED
+			});
+			return false;
 	}
-	if (status.breaker === "open") suffix += ", breaker open";
-	else if (status.breaker === "half_open") suffix += ", probing";
-	if (pinnedTo(status.ref, pin)) suffix += " (pinned)";
-	return suffix;
 }
-/** The STATE column of the status table: window, breaker, pin markers. */
-function stateCell(status, pin) {
-	return stateSuffix(status, pin).replace(/^[, ]+/, "") || "-";
+/** Drop this session's parked work. */
+async function cancelHere(env, cancel) {
+	if (env.sessionID === void 0) {
+		await env.view.alert({
+			title: PARKED_TITLE,
+			message: OPEN_SESSION
+		});
+		return;
+	}
+	if (await cancel(env.sessionID) === "cancelled") env.view.toast("Parked work cancelled", "success");
+	else await env.view.alert({
+		title: PARKED_TITLE,
+		message: NOTHING_PARKED
+	});
 }
 /**
-* The whole inventory as a column-aligned table (header row first): models
-* grouped in tier order (quick → standard → advanced), one row per model,
-* columns padded to the widest cell so the grid reads at a glance. There is
-* no per-resource selection step: the table IS the view.
+* Waiting sessions, then what to do with this session's wait. Other sessions
+* are listed but act only from inside: a host can only continue the session
+* it runs in. True when a resumed run continues and the menu should close.
 */
-function statusTable(snapshot) {
-	const header = [
-		"MODEL",
-		"TIER",
-		"HEALTH",
-		"STATE"
-	];
-	const rows = healthEntries(snapshot).map(({ tier, status }) => [
-		resourceLabel(status.ref),
-		tier,
-		status.health,
-		stateCell(status, snapshot.pin)
-	]);
-	const widths = header.map((cell, column) => Math.max(cell.length, ...rows.map((row) => row[column].length)));
-	const render = (cells) => cells.map((cell, column) => cell.padEnd(widths[column])).join("  ").trimEnd();
-	return [render(header), ...rows.map(render)];
+async function runParkedWork(env, actions) {
+	const { waiting } = await env.api.status();
+	if (waiting.length === 0) {
+		await env.view.alert({
+			title: PARKED_TITLE,
+			message: "No parked work."
+		});
+		return false;
+	}
+	const now = (env.clock ?? Date.now)();
+	const picked = await env.view.select({
+		title: PARKED_TITLE,
+		options: waiting.map((entry) => ({
+			title: entry.sessionID === env.sessionID ? "This session" : entry.sessionID,
+			value: entry.sessionID,
+			description: `${entry.tier} · ${waitingLabel(entry.resumeAt, now)}`
+		}))
+	});
+	if (picked === void 0) return false;
+	if (picked !== env.sessionID) {
+		await env.view.alert({
+			title: PARKED_TITLE,
+			message: OPEN_SESSION
+		});
+		return false;
+	}
+	const { resume, cancel } = actions;
+	const run = await env.view.select({
+		title: "This session's parked work",
+		options: [...resume === void 0 ? [] : [{
+			title: "Resume now",
+			value: () => resumeHere(env, resume),
+			description: "try the tier again"
+		}], ...cancel === void 0 ? [] : [{
+			title: "Cancel",
+			value: async () => {
+				await cancelHere(env, cancel);
+				return false;
+			},
+			description: "drop the wait; your next prompt starts fresh"
+		}]]
+	});
+	return run === void 0 ? false : run();
 }
-/** Narrow hosts keep health and capacity visible instead of clipping wide model columns. */
-function compactStatus(snapshot) {
-	return healthEntries(snapshot).flatMap(({ tier, status }) => [
-		resourceLabel(status.ref),
-		`${tier} · ${status.health}`,
-		...stateCell(status, snapshot.pin).split(", ").map((part) => `  ${part}`),
-		""
-	]);
+async function runDoctor(env, doctor) {
+	await env.view.table({
+		title: "Adaptive doctor",
+		lines: doctorLines(await doctor())
+	});
 }
-/** Empty-state copy for the status view when nothing is configured. */
-const STATUS_EMPTY_MESSAGE = "No models configured yet — open Models to add some.";
 // ../core/src/flow/menu.ts
 /**
 * Main-menu and mode-menu view models for `/adaptive` (ADP-033): pure data
@@ -5293,6 +5483,46 @@ async function applyTierRequest(env, sessionID, tier, feedback) {
 	}
 	return result;
 }
+function actionOptions(env) {
+	const actions = env.actions ?? {};
+	const { resetHealth, resume, cancel, tools, doctor, preferences, defaults } = actions;
+	const done = (run) => async () => {
+		await run();
+		return false;
+	};
+	return [
+		resetHealth !== void 0 && {
+			title: "Health",
+			value: done(() => runHealthReset(env, resetHealth)),
+			description: "reset a model marked limited"
+		},
+		(resume !== void 0 || cancel !== void 0) && {
+			title: "Parked work",
+			value: () => runParkedWork(env, actions),
+			description: "resume or cancel waiting work"
+		},
+		tools !== void 0 && {
+			title: "Tool support",
+			value: done(tools),
+			description: "declare which models can call tools"
+		},
+		doctor !== void 0 && {
+			title: "Doctor",
+			value: done(() => runDoctor(env, doctor)),
+			description: "check setup and compatibility"
+		},
+		preferences !== void 0 && {
+			title: "Preferences",
+			value: done(preferences),
+			description: "transcript notes and pinned-tier escalation"
+		},
+		defaults !== void 0 && {
+			title: "Use Adaptive for new sessions",
+			value: done(defaults),
+			description: "Pi settings to copy"
+		}
+	].filter((row) => row !== false);
+}
 async function runAdaptive(env, initial) {
 	const loaded = await tryApi(env, () => env.api.settings());
 	if (loaded === void 0) return;
@@ -5326,40 +5556,12 @@ async function runAdaptive(env, initial) {
 		const tierPinned = sessionID === void 0 ? void 0 : await env.api.tierRequest(sessionID).catch(() => void 0);
 		const choice = next ?? await env.view.select({
 			title: `Adaptive (${override ?? settings.mode})`,
-			options: [...mainMenuOptions(settings, status, tierPinned, override ?? settings.mode), ...env.actions === void 0 ? [] : [
-				{
-					title: "Health",
-					value: "health",
-					description: "inspect or reset resource health"
-				},
-				{
-					title: "Parked work",
-					value: "parked",
-					description: "resume or cancel waiting work"
-				},
-				{
-					title: "Doctor",
-					value: "doctor",
-					description: "check setup and compatibility"
-				},
-				{
-					title: "Preferences",
-					value: "preferences",
-					description: "transcript notes and pinned-tier escalation"
-				},
-				{
-					title: "Use Adaptive for new sessions",
-					value: "defaults",
-					description: "Pi settings to copy"
-				}
-			]]
+			options: [...mainMenuOptions(settings, status, tierPinned, override ?? settings.mode), ...actionOptions(env)]
 		});
 		next = void 0;
 		if (choice === void 0) return;
-		if (choice === "health" || choice === "parked" || choice === "doctor" || choice === "preferences" || choice === "defaults") {
-			await tryApi(env, async () => {
-				await env.actions?.[choice]();
-			});
+		if (typeof choice === "function") {
+			if (await tryApi(env, choice) === true) return;
 			continue;
 		}
 		if (choice === "status") {
@@ -5675,11 +5877,17 @@ async function runReceiptsView(env) {
 		});
 	}
 }
-// src/host/commands.ts
-const SUBCOMMANDS = [
+// ../core/src/flow/command.ts
+/**
+* `/adaptive <subcommand>`, shared by every host (ADP-062): one parser, one
+* copy, so a subcommand typed in Pi behaves the same in OpenCode. Action-backed
+* subcommands exist only where the host wires the action.
+*/
+const ADAPTIVE_SUBCOMMANDS = [
 	"status",
 	"why",
 	"tiers",
+	"tools",
 	"health",
 	"resume",
 	"cancel",
@@ -5687,49 +5895,83 @@ const SUBCOMMANDS = [
 	"observe off",
 	"doctor"
 ];
+const REQUIRES = {
+	tools: "tools",
+	health: "resetHealth",
+	resume: "resume",
+	cancel: "cancel",
+	doctor: "doctor"
+};
+/** The subcommands a host with these actions can run, in menu order. */
+function adaptiveSubcommands(actions) {
+	return ADAPTIVE_SUBCOMMANDS.filter((command) => {
+		const needs = REQUIRES[command];
+		return needs === void 0 || actions?.[needs] !== void 0;
+	});
+}
+/** Runs `/adaptive <input>`; an empty input opens the menu. API failures propagate to the host. */
+async function runAdaptiveCommand(env, input) {
+	const command = input.trim().replace(/\s+/g, " ");
+	const { resetHealth, resume, cancel, tools, doctor } = env.actions ?? {};
+	switch (command) {
+		case "":
+			await runAdaptive(env);
+			return;
+		case "status":
+			await runAdaptive(env, "status");
+			return;
+		case "tiers":
+			await runAdaptive(env, "models");
+			return;
+		case "why": {
+			const latest = (await env.api.receipts()).find((receipt) => receipt.sessionID === env.sessionID);
+			await env.view.alert({
+				title: "Latest decision",
+				message: latest === void 0 ? "No decisions recorded in this session yet." : receiptDetail(latest, env.copy, (env.clock ?? Date.now)())
+			});
+			return;
+		}
+		case "observe on":
+		case "observe off": {
+			const result = await env.api.setSettings({ mode: command === "observe on" ? "observe" : "off" });
+			env.view.toast(result.ok ? "Observation setting saved. Your selected model is unchanged." : result.errors.join("; "), result.ok ? "success" : "error");
+			return;
+		}
+		case "tools":
+			if (tools === void 0) break;
+			await tools();
+			return;
+		case "health":
+			if (resetHealth === void 0) break;
+			await runHealthReset(env, resetHealth);
+			return;
+		case "resume":
+			if (resume === void 0) break;
+			await resumeHere(env, resume);
+			return;
+		case "cancel":
+			if (cancel === void 0) break;
+			await cancelHere(env, cancel);
+			return;
+		case "doctor":
+			if (doctor === void 0) break;
+			await runDoctor(env, doctor);
+			return;
+	}
+	env.view.toast(`Unknown adaptive command. Use: ${adaptiveSubcommands(env.actions).join(", ")}.`, "error");
+}
+// src/host/commands.ts
 async function runCommand(args, ctx, options) {
 	if (!ctx.hasUI) {
 		ctx.ui.notify("Open /adaptive in an interactive or RPC session.", "warning");
 		return;
 	}
-	const command = args.trim().replace(/\s+/g, " ");
-	const env = await options.env(ctx);
-	if (command === "resume") {
-		await options.resume(ctx);
-		return;
-	}
-	if (command === "cancel") {
-		await options.cancel(ctx);
-		return;
-	}
-	if (command === "doctor" || command === "health") {
-		await env.actions?.[command]();
-		return;
-	}
-	if (command === "observe on" || command === "observe off") {
-		const result = await env.api.setSettings({ mode: command === "observe on" ? "observe" : "off" });
-		env.view.toast(result.ok ? "Observation setting saved. Your selected model is unchanged." : result.errors.join("; "), result.ok ? "success" : "error");
-		return;
-	}
-	if (command === "why") {
-		const latest = (await env.api.receipts()).find((receipt) => receipt.sessionID === env.sessionID);
-		await env.view.alert({
-			title: "Latest decision",
-			message: latest === void 0 ? "No decisions recorded in this session yet." : receiptDetail(latest, PI_COPY, options.clock())
-		});
-		return;
-	}
-	if (command === "" || command === "status" || command === "tiers") {
-		if (command === "") await runAdaptive(env, void 0);
-		else await runAdaptive(env, command === "tiers" ? "models" : "status");
-		return;
-	}
-	env.view.toast(`Unknown adaptive command. Use: ${SUBCOMMANDS.join(", ")}.`, "error");
+	await runAdaptiveCommand(await options.env(ctx), args);
 }
 function registerCommands(pi, options) {
 	pi.registerCommand("adaptive", {
 		description: "Adaptive settings, decisions and diagnostics",
-		getArgumentCompletions: (prefix) => SUBCOMMANDS.filter((command) => command.startsWith(prefix)).map((command) => ({
+		getArgumentCompletions: (prefix) => ADAPTIVE_SUBCOMMANDS.filter((command) => command.startsWith(prefix)).map((command) => ({
 			value: command,
 			label: command
 		})),
@@ -5824,6 +6066,61 @@ function controlApi(options) {
 		}
 	};
 }
+// src/ui/doctor.ts
+function parts(version) {
+	if (!/^\d+\.\d+\.\d+$/.test(version)) return void 0;
+	const [major, minor, patch] = version.split(".");
+	return [
+		Number(major),
+		Number(minor),
+		Number(patch)
+	];
+}
+function compare(a, b) {
+	for (const index of [
+		0,
+		1,
+		2
+	]) {
+		const difference = a[index] - b[index];
+		if (difference !== 0) return difference;
+	}
+	return 0;
+}
+function versionChecks(version, minimum, testedUpTo) {
+	const actual = parts(version);
+	const floor = parts(minimum);
+	const tested = testedUpTo === void 0 ? void 0 : parts(testedUpTo);
+	if (actual === void 0 || floor === void 0) return [{
+		state: "warning",
+		message: `Pi ${version}: version support could not be checked`,
+		action: "Pick a normal model and report this version."
+	}];
+	if (actual[0] !== 1 || compare(actual, floor) < 0) return [{
+		state: "error",
+		message: `Pi ${version} is unsupported (requires ≥${minimum} <2)`,
+		action: "Install a supported Pi version or pick a normal model."
+	}];
+	const checks = [{
+		state: "ok",
+		message: `Pi ${version} (supported: ≥${minimum} <2)`
+	}];
+	if (tested === void 0) checks.push({
+		state: "warning",
+		message: "Packed-host tested-up-to evidence is not recorded",
+		action: "Run the complete Pi host matrix before release."
+	});
+	else if (compare(actual, tested) > 0) checks.push({
+		state: "warning",
+		message: `Pi ${version} is newer than last tested ${String(testedUpTo)}`,
+		action: "If routing misbehaves, pick a normal model and report it."
+	});
+	else checks.push({
+		state: "ok",
+		message: `Packed hosts tested up to ${String(testedUpTo)}`
+	});
+	return checks;
+}
 // src/host/doctor.ts
 /** Probe failures use fixed copy: upstream errors/configs may contain credentials. */
 async function doctorChecks(options) {
@@ -5842,27 +6139,20 @@ async function doctorChecks(options) {
 		const capabilities = await options.capabilities();
 		const credentialed = [];
 		const undeclared = /* @__PURE__ */ new Set();
-		for (const tier of TIERS) {
-			if (settings.tiers[tier].length === 0) checks.push({
-				state: "warning",
-				message: `${tier}: no configured models`,
-				action: "Open /adaptive tiers to add a model."
+		for (const tier of TIERS) for (const ref of settings.tiers[tier]) {
+			const model = options.registry.find(ref.providerID, ref.id);
+			if (model === void 0) checks.push({
+				state: "error",
+				message: `${resourceLabel(ref)} (${tier}): model missing`,
+				action: "Refresh Pi's model catalog or remove this tier entry."
 			});
-			for (const ref of settings.tiers[tier]) {
-				const model = options.registry.find(ref.providerID, ref.id);
-				if (model === void 0) checks.push({
-					state: "error",
-					message: `${resourceLabel(ref)} (${tier}): model missing`,
-					action: "Refresh Pi's model catalog or remove this tier entry."
-				});
-				else if (!options.registry.hasConfiguredAuth(model)) checks.push({
-					state: "error",
-					message: `${resourceLabel(ref)} (${tier}): no credentials configured`,
-					action: `Run /login ${ref.providerID}, or remove it from the tier.`
-				});
-				else credentialed.push(resourceLabel(ref));
-				if (!capabilities.some((entry) => entry.providerID === ref.providerID && entry.id === ref.id && entry.tools)) undeclared.add(resourceLabel(ref));
-			}
+			else if (!options.registry.hasConfiguredAuth(model)) checks.push({
+				state: "error",
+				message: `${resourceLabel(ref)} (${tier}): no credentials configured`,
+				action: `Run /login ${ref.providerID}, or remove it from the tier.`
+			});
+			else credentialed.push(resourceLabel(ref));
+			if (!capabilities.some((entry) => entry.providerID === ref.providerID && entry.id === ref.id && entry.tools)) undeclared.add(resourceLabel(ref));
 		}
 		if (credentialed.length > 0) checks.push({
 			state: "ok",
@@ -5871,7 +6161,7 @@ async function doctorChecks(options) {
 		if (undeclared.size > 0) checks.push({
 			state: "warning",
 			message: `Tool support not declared: ${[...undeclared].join(", ")}`,
-			action: "List them in adaptive/capabilities.json; Adaptive never guesses from a name."
+			action: "Open /adaptive tools to declare them; Adaptive never guesses from a name."
 		});
 	} catch {
 		checks.push({
@@ -5909,31 +6199,12 @@ async function doctorChecks(options) {
 		});
 	}
 	try {
-		const limited = await options.health();
-		checks.push({
-			state: "ok",
-			message: limited === 0 ? "Health: no resources limited" : `Health: ${String(limited)} ${limited === 1 ? "resource" : "resources"} limited`,
-			...limited === 0 ? {} : { action: "Inspect /adaptive health; reset only after checking the provider." }
-		});
+		checks.push(...statusChecks(await options.status()));
 	} catch {
 		checks.push({
 			state: "error",
-			message: "Shared health could not be read",
-			action: "Inspect adaptive/health.json; do not delete it while another Pi process is running."
-		});
-	}
-	try {
-		const parked = await options.parked();
-		checks.push({
-			state: "ok",
-			message: parked === 0 ? "No parked work" : `${String(parked)} parked ${parked === 1 ? "task" : "tasks"}`,
-			...parked === 0 ? {} : { action: "Use /adaptive resume or /adaptive cancel in the waiting session." }
-		});
-	} catch {
-		checks.push({
-			state: "error",
-			message: "Parked work could not be read",
-			action: "Inspect adaptive/parked.json before resuming; no task was dispatched."
+			message: "Health or parked work could not be read",
+			action: "Inspect adaptive/health.json and parked.json; do not delete them while another Pi process is running."
 		});
 	}
 	return checks;
@@ -5955,6 +6226,9 @@ function order(left, right) {
 	if (l !== r) return l < r ? -1 : 1;
 	return Number(left.reasoning) - Number(right.reasoning) || left.contextWindow - right.contextWindow || Number(left.thinkingLevels.includes("high")) - Number(right.thinkingLevels.includes("high"));
 }
+/** A proposal is a starting point, not the catalog: a primary and a fallback per tier keep
+* the first-run decision small; the tier editor offers every configured model. */
+const PROPOSAL_TIER_CAP = 2;
 /** Settings bootstrap only: never consulted during routing, and never persists. */
 function proposeTiers(models) {
 	const unique = /* @__PURE__ */ new Map();
@@ -5962,7 +6236,7 @@ function proposeTiers(models) {
 	const ordered = [...unique.values()];
 	const first = Math.ceil(ordered.length / 3);
 	const second = Math.ceil(ordered.length * 2 / 3);
-	const refs = (group, advanced) => group.slice(0, 32).map((model) => ({
+	const refs = (group, advanced) => group.slice(0, PROPOSAL_TIER_CAP).map((model) => ({
 		providerID: model.ref.providerID,
 		id: model.ref.id,
 		...advanced && model.reasoning && model.thinkingLevels.includes("high") ? { variant: "high" } : {}
@@ -6368,38 +6642,27 @@ function adaptiveSurface(pi, sources, host, parking, feedback) {
 			view,
 			models: () => modelSummaries(availablePhysicalModels(ctx.modelRegistry)),
 			sessionID: ctx.sessionManager.getSessionId(),
+			clock: sources.parking.clock,
 			actions: {
-				health: async () => {
-					await healthAction(view, await configured(), (ref) => resetResourceHealth(sources.health.file, ref));
-				},
-				parked: async () => {
-					const { waiting } = await api.status();
-					const now = sources.parking.clock();
-					await view.alert({
-						title: "Parked work",
-						message: waiting.length === 0 ? "No parked work." : [...waiting.map((entry) => `${entry.sessionID === ctx.sessionManager.getSessionId() ? "This session" : entry.sessionID} · ${entry.tier} · ${waitingLabel(entry.resumeAt, now)}`), "Use /adaptive resume or /adaptive cancel in the waiting session."].join("\n")
-					});
-				},
-				doctor: async () => {
-					const checks = await doctorChecks({
-						version: host.version,
-						minimum: host.minimum,
-						testedUpTo: host.testedUpTo,
-						registry: ctx.modelRegistry,
-						settings: () => readSettings(host.settings),
-						capabilities: sources.capabilities,
-						storage: () => host.settings.update(() => ({
-							next: void 0,
-							result: void 0
-						})),
-						health: async () => (await readSharedHealth(sources.health.file)).filter((record) => record.health !== "healthy").length,
-						parked: async () => (await readParked(sources.parking.file)).length
-					});
-					await view.table({
-						title: "Adaptive doctor",
-						lines: doctorLines(checks)
-					});
+				resetHealth: (ref) => resetResourceHealth(sources.health.file, ref),
+				resume: () => parking.resume(ctx),
+				cancel: () => parking.cancel(ctx),
+				tools: async () => {
+					await toolSupportAction(view, host.capabilities, await configured(), await sources.capabilities());
 				},
+				doctor: () => doctorChecks({
+					version: host.version,
+					minimum: host.minimum,
+					testedUpTo: host.testedUpTo,
+					registry: ctx.modelRegistry,
+					settings: () => readSettings(host.settings),
+					capabilities: sources.capabilities,
+					storage: () => host.settings.update(() => ({
+						next: void 0,
+						result: void 0
+					})),
+					status: api.status
+				}),
 				preferences: () => preferencesAction(view, sources.preferences),
 				defaults: () => view.alert({
 					title: "Use Adaptive for new sessions",
@@ -6408,12 +6671,7 @@ function adaptiveSurface(pi, sources, host, parking, feedback) {
 			}
 		});
 	};
-	registerCommands(pi, {
-		env: environment,
-		resume: (ctx) => parking.resume(ctx),
-		cancel: (ctx) => parking.cancel(ctx),
-		clock: sources.health.clock
-	});
+	registerCommands(pi, { env: environment });
 	return { async onboard(ctx) {
 		const env = await environment(ctx);
 		await runOnboarding({
@@ -6795,9 +7053,10 @@ async function acquire(lock, clock) {
 		} catch (error) {
 			if (errorCode(error) !== "EEXIST") throw error;
 		}
+		const seen = await readFile(lock, "utf8").catch(() => void 0);
 		const held = await stat(lock).catch(() => void 0);
-		if (held !== void 0 && clock() - held.mtimeMs > STALE_LOCK_MS) {
-			await rm(lock, { force: true });
+		if (seen !== void 0 && held !== void 0 && clock() - held.mtimeMs > STALE_LOCK_MS) {
+			if (await readFile(lock, "utf8").catch(() => void 0) === seen) await rm(lock, { force: true });
 			continue;
 		}
 		if (clock() >= deadline) throw new Error(`Adaptive state: ${lock} is held by another Pi process`);
@@ -6881,6 +7140,7 @@ function adaptive(pi) {
 		capabilities: () => loadToolCapabilities(join(getAgentDir(), "adaptive", "capabilities.json"), (file) => readFile(file, "utf8"))
 	}, {
 		settings: jsonFile(path),
+		capabilities: jsonFile(join(getAgentDir(), "adaptive", "capabilities.json")),
 		version: VERSION,
 		minimum,
 		testedUpTo