@selesai/code 0.14.0 → 0.14.4

package/dist/extensions/jev/decisions.ts

@@ -7,12 +7,16 @@ import { fitsClassifierRequest, toClassifierContext } from "./classifier-context
 // Advisory configuration (one opt-in area, per-route enablement)
 // ---------------------------------------------------------------------------
 
-export const JEV_ROUTE_NAMES = ["memory", "recommendations", "ask", "subagent"] as const;
+export const JEV_ROUTE_NAMES = ["memory", "recommendations", "ask", "subagent", "toolSearch"] as const;
 export type JevRouteName = (typeof JEV_ROUTE_NAMES)[number];
 
 export interface JevRouteConfig {
 	/** Host-side routes are off unless the user turns them on; the agent's `ask` route is on. */
 	enabled: boolean;
+	/** Classifier model this route asks instead of the shared `jevAdvisory.model`. */
+	model?: string;
+	/** Provider of that model; defaults to the shared `jevAdvisory.provider`. */
+	provider?: string;
 	timeoutMs: number;
 	/** Below this confidence the answer is an abstention, not a decision. */
 	minConfidence: number;
@@ -73,6 +77,23 @@ export const DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG: JevRouteConfig = {
 	payloadBytes: 16 * 1024,
 };
 
+/**
+ * The `toolSearch` route ranks tools for `tool_search` and codemode's `searchTools()`: one yes/no
+ * question per candidate tool, batched. It asks the shared Jev model unless the route sets its own
+ * `model` (any Token-In decisions model, e.g. `cloudflare/clef-flash`). On by default like `ask`: it
+ * runs only when the agent searches for tools, and a missing Token-In credential falls back to the
+ * local BM25 ranking.
+ *
+ * `payloadBytes` bounds one request; `timeoutMs` is per request (batches run in parallel).
+ * `minConfidence`, `contextTurns`, and `contextChars` are unused.
+ */
+export const DEFAULT_JEV_TOOL_SEARCH_ROUTE_CONFIG: JevRouteConfig = {
+	...DEFAULT_JEV_ROUTE_CONFIG,
+	enabled: true,
+	timeoutMs: 6_000,
+	payloadBytes: 32 * 1024,
+};
+
 export const DEFAULT_JEV_ADVISORY_CONFIG: JevAdvisoryConfig = {
 	provider: "tokenin",
 	model: "jev-1.13",
@@ -81,6 +102,7 @@ export const DEFAULT_JEV_ADVISORY_CONFIG: JevAdvisoryConfig = {
 		recommendations: { ...DEFAULT_JEV_ROUTE_CONFIG },
 		ask: { ...DEFAULT_JEV_ASK_ROUTE_CONFIG },
 		subagent: { ...DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG },
+		toolSearch: { ...DEFAULT_JEV_TOOL_SEARCH_ROUTE_CONFIG },
 	},
 };
 
@@ -112,7 +134,11 @@ function numberOr(value: unknown, fallback: number): number {
 
 function routeOr(value: unknown, fallback: JevRouteConfig = DEFAULT_JEV_ROUTE_CONFIG): JevRouteConfig {
 	if (!isRecord(value)) return { ...fallback };
+	const model = stringOr(value.model, fallback.model ?? "");
+	const provider = stringOr(value.provider, fallback.provider ?? "");
 	return {
+		...(model ? { model } : {}),
+		...(provider ? { provider } : {}),
 		enabled: value.enabled === undefined ? fallback.enabled : value.enabled === true,
 		timeoutMs: numberOr(value.timeoutMs, fallback.timeoutMs),
 		minConfidence: numberOr(value.minConfidence, fallback.minConfidence),
@@ -145,19 +171,24 @@ export function readJevAdvisoryConfig(settingsPath: string): JevAdvisoryConfig {
 			recommendations: routeOr(routes.recommendations),
 			ask: routeOr(routes.ask, DEFAULT_JEV_ASK_ROUTE_CONFIG),
 			subagent: routeOr(routes.subagent, DEFAULT_JEV_SUBAGENT_ROUTE_CONFIG),
+			toolSearch: routeOr(routes.toolSearch, DEFAULT_JEV_TOOL_SEARCH_ROUTE_CONFIG),
 		},
 	};
 }
 
-/** The transport settings one route uses: shared Jev endpoint plus route timing. */
+/**
+ * The transport settings one route uses: the shared endpoint plus route timing. A route that names
+ * its own model keeps that model's registered endpoint: `jevAdvisory.baseUrl` overrides the shared
+ * Jev deployment's URL, not another model's.
+ */
 export function jevConnection(
 	config: JevAdvisoryConfig,
 	route: JevRouteConfig,
 ): JevConnection {
 	return {
-		provider: config.provider,
-		model: config.model,
-		baseUrl: config.baseUrl,
+		provider: route.provider ?? config.provider,
+		model: route.model ?? config.model,
+		baseUrl: route.model === undefined ? config.baseUrl : undefined,
 		timeoutMs: route.timeoutMs,
 		minConfidence: route.minConfidence,
 	};

package/dist/extensions/jev-ask-tool.ts

@@ -673,7 +673,7 @@ interface JudgeOutcome {
 }
 
 /** Ask one noul per item, batched and fitted, within the stage's request caps. */
-async function judgeNouls(
+export async function judgeNouls(
 	requests: FindRequests,
 	stage: JudgeStage,
 	items: readonly JudgeItem[],

package/dist/extensions/jev-tool-ranker.test.ts

@@ -0,0 +1,185 @@
+/**
+ * The Jev tool ranker: what tool_search and searchTools() get back, what Jev is sent, and that
+ * discovery keeps working (BM25) whenever Jev cannot answer.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+
+const state = vi.hoisted(() => ({ settingsPath: "" }));
+
+vi.mock("@selesai/code", async () => ({
+	...(await import("./tool-search/tool.ts")),
+	getSettingsPath: () => state.settingsPath,
+}));
+
+import { TOKENIN_JEV_CLASSIFIER } from "./jev/classifier.ts";
+import { JEV_ROUTING_EVENT } from "./jev/decisions.ts";
+import { classifierResponse, providerTemplate } from "./jev/test-support.ts";
+import { createJevToolRanker, TOOL_RANK_MAX_REQUESTS } from "./jev-tool-ranker.ts";
+import { FIND_BATCH } from "./jev-ask-tool.ts";
+import { Bm25Ranker, createToolSearchDocument, type ToolSearchDocument } from "./tool-search/tool.ts";
+
+let root: string;
+beforeAll(() => {
+	root = mkdtempSync(join(tmpdir(), "jev-tool-ranker-"));
+	mkdirSync(join(root, "agent"), { recursive: true });
+	state.settingsPath = join(root, "agent", "settings.json");
+});
+afterAll(() => rmSync(root, { recursive: true, force: true }));
+
+const tool = (name: string, description: string): ToolSearchDocument =>
+	createToolSearchDocument({ name, description, parameters: {} as never });
+
+const TOOLS = [
+	tool("mcp__gh__create_issue", "Open a new issue in a repository to track a defect or task."),
+	tool("mcp__db__run_query", "Run a read-only SQL query against the analytics database."),
+	tool("mcp__cal__add_event", "Add an event to the calendar."),
+];
+
+interface Sent {
+	state: { request: string; tools: Record<string, string> };
+	questions: Record<string, { instructions: string }>;
+}
+
+function setup(options: { enabled?: boolean; credential?: boolean; relevant?: string[]; score?: number } = {}) {
+	writeFileSync(
+		state.settingsPath,
+		JSON.stringify({ jevAdvisory: { routes: { toolSearch: { enabled: options.enabled ?? true } } } }),
+		"utf-8",
+	);
+	const relevant = new Set(options.relevant ?? []);
+	const sent: Sent[] = [];
+	const classify = vi.fn(async (_model: unknown, context: Sent) => {
+		sent.push(context);
+		const names = Object.keys(context.state.tools);
+		const answers = Object.fromEntries(
+			Object.keys(context.questions).map((id, index) => [
+				id,
+				{ noul: relevant.has(names[Number(id.slice(1))]) ? (options.score ?? 0.92) : 0.08 },
+			]),
+		);
+		return classifierResponse(JSON.stringify({ answers }));
+	});
+	const events: Record<string, unknown>[] = [];
+	const ranker = createJevToolRanker({
+		events: { emit: (channel, data) => channel === JEV_ROUTING_EVENT && events.push(data as Record<string, unknown>) },
+	});
+	const ctx = {
+		modelRegistry: {
+			getAll: () => [providerTemplate()],
+			// Only Jev is registered: asking for any other model would find none and fall back to BM25.
+			findOfType: (type: string, provider: string, id: string) =>
+				type === "classifier" && provider === "tokenin" && id === "jev-1.13"
+					? { ...TOKENIN_JEV_CLASSIFIER }
+					: undefined,
+			getApiKeyAndHeaders: async () => (options.credential === false ? { ok: false } : { ok: true, apiKey: "key", headers: {} }),
+			classify,
+		},
+	};
+	return { ranker, ctx: ctx as never, classify, sent, events };
+}
+
+beforeEach(() => vi.clearAllMocks());
+
+describe("Jev tool ranker", () => {
+	it("finds a tool whose words the query never uses", async () => {
+		const query = "file a bug report for the crash";
+		expect(new Bm25Ranker().rank(query, TOOLS, 5)).toEqual([]);
+		const { ranker, ctx, classify, sent, events } = setup({ relevant: ["mcp__gh__create_issue"] });
+
+		const matches = await ranker.rank(query, TOOLS, 5, { ctx });
+
+		expect(matches.map((match) => match.name)).toEqual(["mcp__gh__create_issue"]);
+		expect(classify.mock.calls[0][0]).toMatchObject({ id: "jev-1.13", api: "typesafe-system-one" });
+		expect(sent).toHaveLength(1);
+		expect(sent[0].state.request).toBe(query);
+		expect(Object.keys(sent[0].state.tools)).toEqual(TOOLS.map((document) => document.name));
+		expect(sent[0].state.tools["mcp__cal__add_event"]).toContain("Add an event to the calendar.");
+		expect(events).toEqual([
+			expect.objectContaining({ route: "toolSearch", outcome: "jev", candidates: 3, judged: 3, matched: 1, confidence: "high" }),
+		]);
+		// Telemetry is shape only.
+		expect(JSON.stringify(events)).not.toContain("bug report");
+	});
+
+	it("orders matches by Jev's probability and honors the limit", async () => {
+		const { ranker, ctx } = setup({ relevant: ["mcp__db__run_query", "mcp__cal__add_event"] });
+		const matches = await ranker.rank("anything", TOOLS, 1, { ctx });
+		expect(matches).toHaveLength(1);
+	});
+
+	it("treats Jev as the judge: low probabilities mean no match", async () => {
+		const { ranker, ctx } = setup({ relevant: [] });
+		expect(await ranker.rank("calendar event", TOOLS, 5, { ctx })).toEqual([]);
+	});
+
+	it("ranks with BM25 and sends nothing without a session", async () => {
+		const { ranker, classify } = setup({ relevant: ["mcp__gh__create_issue"] });
+		const matches = await ranker.rank("calendar event", TOOLS, 5);
+		expect(matches.map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(classify).not.toHaveBeenCalled();
+	});
+
+	it("ranks with BM25 when the route is off", async () => {
+		const { ranker, ctx, classify } = setup({ enabled: false });
+		expect((await ranker.rank("calendar event", TOOLS, 5, { ctx })).map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(classify).not.toHaveBeenCalled();
+	});
+
+	it("ranks with BM25 without a Token-In credential", async () => {
+		const { ranker, ctx, classify, events } = setup({ credential: false });
+		expect((await ranker.rank("calendar event", TOOLS, 5, { ctx })).map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(classify).not.toHaveBeenCalled();
+		expect(events).toEqual([expect.objectContaining({ route: "toolSearch", outcome: "fallback", reason: "no-credential" })]);
+	});
+
+	it("ranks with BM25 when every request fails", async () => {
+		const { ranker, ctx, classify, events } = setup();
+		classify.mockRejectedValue(new Error("down"));
+		expect((await ranker.rank("calendar event", TOOLS, 5, { ctx })).map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+		expect(events).toEqual([expect.objectContaining({ outcome: "fallback" })]);
+	});
+
+	it("ranks with BM25 when the caller already aborted", async () => {
+		const { ranker, ctx } = setup({ relevant: ["mcp__gh__create_issue"] });
+		const controller = new AbortController();
+		controller.abort();
+		const matches = await ranker.rank("calendar event", TOOLS, 5, { ctx, signal: controller.signal });
+		expect(matches.map((match) => match.name)).toEqual(["mcp__cal__add_event"]);
+	});
+
+	it("keeps BM25 hits for tools whose batch failed", async () => {
+		// 18 BM25 hits fill one batch of 16 and spill two into a second batch.
+		const documents = Array.from({ length: FIND_BATCH + 2 }, (_, index) => tool(`mcp__x__gadget_${index}`, `A gadget, number ${index}.`));
+		const { ranker, ctx, classify } = setup({ relevant: ["mcp__x__gadget_3"] });
+		const answer = classify.getMockImplementation()!;
+		classify.mockImplementation(async (model, context) => {
+			if ("mcp__x__gadget_16" in context.state.tools) throw new Error("down");
+			return answer(model, context);
+		});
+
+		const matches = await ranker.rank("gadget", documents, 30, { ctx });
+
+		// Jev's verdicts come first, then the tools Jev never scored in BM25 order; scored-and-rejected tools are gone.
+		expect(matches.map((match) => match.name)).toEqual(["mcp__x__gadget_3", "mcp__x__gadget_16", "mcp__x__gadget_17"]);
+	});
+
+	it("sends at most TOOL_RANK_MAX_REQUESTS requests, choosing by BM25 past the cap", async () => {
+		const cap = TOOL_RANK_MAX_REQUESTS * FIND_BATCH;
+		const documents = [
+			...Array.from({ length: cap + 50 }, (_, index) => tool(`mcp__bulk__tool_${index}`, `Generic helper ${index}.`)),
+			tool("mcp__late__quokka", "Pet the quokka."),
+		];
+		const { ranker, ctx, classify, sent } = setup({ relevant: ["mcp__late__quokka"] });
+
+		const matches = await ranker.rank("quokka", documents, 3, { ctx });
+
+		expect(classify.mock.calls.length).toBeLessThanOrEqual(TOOL_RANK_MAX_REQUESTS);
+		const judged = sent.flatMap((request) => Object.keys(request.state.tools));
+		expect(judged).toHaveLength(cap);
+		expect(judged).toContain("mcp__late__quokka");
+		expect(matches.map((match) => match.name)).toEqual(["mcp__late__quokka"]);
+	});
+});

package/dist/extensions/jev-tool-ranker.ts

@@ -0,0 +1,169 @@
+/**
+ * jev-tool-ranker — ranks tools for `tool_search` and codemode's `searchTools()` with Jev.
+ *
+ * Each candidate tool is one yes/no question ("would this tool help with the request?"), batched
+ * into parallel requests; the model's probability is the score. This is the `toolSearch` route of
+ * `jevAdvisory` (on by default). It asks the shared Jev model; set
+ * `jevAdvisory.routes.toolSearch.model` to use another decisions model from `jev/classifier.ts`.
+ * The ranker never throws and never blocks discovery: with no
+ * session, the route off, no Token-In credential, or any request failing, it returns the local
+ * BM25 ranking, and tools the model did not score are appended in BM25 order.
+ *
+ * Which tools are sent: every candidate, up to TOOL_RANK_MAX_REQUESTS * FIND_BATCH. Past that cap
+ * the BM25 order decides which candidates are sent; the rest keep their BM25 place.
+ */
+import { Bm25Ranker, getSettingsPath, registerToolRanker } from "@selesai/code";
+import type {
+	ExtensionAPI,
+	ToolRankOptions,
+	ToolRanker,
+	ToolSearchDocument,
+	ToolSearchMatch,
+} from "@selesai/code";
+import { FIND_BATCH, FindRequests, type JudgeItem, type JudgeStage, judgeNouls } from "./jev-ask-tool.ts";
+import {
+	askJevAnswers,
+	confidenceBucket,
+	emitJevTelemetry,
+	type JevAdvisoryConfig,
+	jevConnection,
+	type JevRuntime,
+	jevUnavailable,
+	readJevAdvisoryConfig,
+} from "./jev/decisions.ts";
+
+/** Parallel Jev requests one ranking may send (16 tools each). */
+export const TOOL_RANK_MAX_REQUESTS = 12;
+/** Spare requests for retrying transport failures. */
+export const TOOL_RANK_RETRIES = 2;
+/** A tool is a match at this probability or above: matches become part of the model's context. */
+export const TOOL_RANK_KEEP = 0.5;
+/** Characters of a tool's summary shown to Jev. */
+export const TOOL_RANK_SUMMARY_CHARS = 480;
+
+const STAGE: Pick<JudgeStage, "stateKey" | "criteria"> = {
+	stateKey: "tools",
+	criteria: {
+		true: "The tool's name and description show it can do what the request asks for, or is a direct step toward it.",
+		false: "The tool does something unrelated to the request.",
+	},
+};
+
+export interface JevToolRankerOptions {
+	/** Receives route telemetry (shape and outcome only; never the query or tool text). */
+	events?: { emit(channel: string, data: unknown): void };
+	/** Ranks when Jev cannot, and orders the candidates sent past the cap. Default: BM25. */
+	fallback?: ToolRanker;
+	/** Reads the `jevAdvisory` settings. Default: the agent settings file. */
+	readConfig?: () => JevAdvisoryConfig;
+}
+
+/** Resolves with `work`, or rejects if `signal` aborts first. The request itself is not cancelled. */
+function abortable<T>(work: Promise<T>, signal: AbortSignal | undefined): Promise<T> {
+	if (!signal) return work;
+	return new Promise<T>((resolve, reject) => {
+		const onAbort = () => reject(new Error("aborted"));
+		if (signal.aborted) return onAbort();
+		signal.addEventListener("abort", onAbort, { once: true });
+		work.then(resolve, reject).finally(() => signal.removeEventListener("abort", onAbort));
+	});
+}
+
+export function createJevToolRanker(options: JevToolRankerOptions = {}): ToolRanker {
+	const fallback = options.fallback ?? new Bm25Ranker();
+	const readConfig = options.readConfig ?? (() => readJevAdvisoryConfig(getSettingsPath()));
+
+	return {
+		async rank(
+			query: string,
+			documents: readonly ToolSearchDocument[],
+			limit: number,
+			rankOptions?: ToolRankOptions,
+		): Promise<ToolSearchMatch[]> {
+			const local = await fallback.rank(query, documents, documents.length, rankOptions);
+			const ctx = rankOptions?.ctx;
+			if (!ctx || documents.length === 0 || limit <= 0 || query.trim() === "") return local.slice(0, limit);
+
+			const started = Date.now();
+			const telemetry = (outcome: "jev" | "fallback", extra: Record<string, unknown> = {}) =>
+				emitJevTelemetry(options.events, "decision", {
+					route: "toolSearch",
+					outcome,
+					candidates: documents.length,
+					elapsedMs: Date.now() - started,
+					...extra,
+				});
+
+			try {
+				// Same cast as ask_jev: the session registry is wider than JevRuntime's header type.
+				const runtime = ctx as unknown as JevRuntime;
+				const config = readConfig();
+				const route = config.routes.toolSearch;
+				if (!route.enabled) return local.slice(0, limit);
+				const connection = jevConnection(config, route);
+				const unreachable = await jevUnavailable(runtime, connection);
+				if (unreachable) {
+					telemetry("fallback", { confidence: confidenceBucket(undefined), reason: unreachable });
+					return local.slice(0, limit);
+				}
+
+				// BM25 hits first, then the rest in document order: the cap drops the least likely tools.
+				const byName = new Map(documents.map((document) => [document.name, document]));
+				const hits = new Set(local.map((match) => match.name));
+				const order = [...local.map((match) => match.name), ...documents.map((d) => d.name).filter((n) => !hits.has(n))];
+				const judged = order.slice(0, TOOL_RANK_MAX_REQUESTS * FIND_BATCH).map((name) => byName.get(name)!);
+				const items: JudgeItem[] = judged.map((document) => ({
+					key: document.name,
+					text: (document.summary ?? document.text).slice(0, TOOL_RANK_SUMMARY_CHARS),
+					question: `Would calling the tool "${document.name}" help carry out the request?`,
+				}));
+
+				const requests = new FindRequests(
+					(payload) => askJevAnswers(runtime, connection, { payload, maxBytes: route.payloadBytes }),
+					TOOL_RANK_MAX_REQUESTS + TOOL_RANK_RETRIES,
+				);
+				const outcome = await abortable(
+					judgeNouls(requests, { request: query, ...STAGE }, items, route.payloadBytes, {
+						send: TOOL_RANK_MAX_REQUESTS,
+						retry: TOOL_RANK_MAX_REQUESTS + TOOL_RANK_RETRIES,
+					}),
+					rankOptions?.signal,
+				);
+
+				const unscored = new Set(documents.map((document) => document.name));
+				const position = new Map(order.map((name, index) => [name, index]));
+				const scored: ToolSearchMatch[] = [];
+				items.forEach((item, index) => {
+					const score = outcome.scores[index];
+					if (typeof score !== "number" || !Number.isFinite(score)) return;
+					unscored.delete(item.key);
+					if (score >= TOOL_RANK_KEEP) scored.push({ name: item.key, score });
+				});
+				if (unscored.size === documents.length) {
+					telemetry("fallback", { confidence: confidenceBucket(undefined), reason: outcome.reasons[0] ?? "missing" });
+					return local.slice(0, limit);
+				}
+				scored.sort((a, b) => b.score - a.score || (position.get(a.name) ?? 0) - (position.get(b.name) ?? 0));
+				const extras = local.filter((match) => unscored.has(match.name)).map((match) => ({ name: match.name, score: 0 }));
+				telemetry("jev", {
+					judged: items.length,
+					matched: scored.length,
+					confidence: confidenceBucket(scored[0]?.score),
+					...(unscored.size > 0 ? { unscored: unscored.size } : {}),
+				});
+				return [...scored, ...extras].slice(0, limit);
+			} catch {
+				// Discovery must work without Jev: an abort, a transport error, or a bad answer ranks locally.
+				telemetry("fallback", { confidence: confidenceBucket(undefined), reason: "transport" });
+				return local.slice(0, limit);
+			}
+		},
+	};
+}
+
+export default function jevToolRankerExtension(pi: ExtensionAPI): void {
+	const dispose = registerToolRanker(createJevToolRanker({ events: pi.events }));
+	pi.on("session_shutdown", () => {
+		dispose();
+	});
+}

package/dist/extensions/package.json

@@ -20,6 +20,7 @@
 			"./inline-skills.ts",
 			"./jev-advisory-routing.ts",
 			"./jev-ask-tool.ts",
+			"./jev-tool-ranker.ts",
 			"./rtk.ts",
 			"./tokenin-onboarding.ts",
 			"./pi-graft",

package/dist/extensions/pi-graft/index.ts

@@ -64,8 +64,6 @@ import {
 	recoveryFor,
 	reduceGraftState,
 	type RetrievalMode,
-	STATUS_KEY,
-	statusText,
 } from "./state.ts";
 import { GRAFT_TOOL_NAMES, registerGraftTools } from "./tools.ts";
 
@@ -280,14 +278,12 @@ export default function graftExtension(pi: ExtensionAPI): void {
 	let structuralBuildSession: GraftSession | undefined;
 	const guard = createInjectionGuard();
 
-	const applyEvent = (ctx: ExtensionContext | undefined, event: GraftEvent): void => {
+	const applyEvent = (_ctx: ExtensionContext | undefined, event: GraftEvent): void => {
 		session.state = reduceGraftState(session.state, event);
-		if (ctx?.hasUI) ctx.ui.setStatus(STATUS_KEY, statusText(session.state));
 	};
 
-	const setMode = (mode: RetrievalMode, ctx?: ExtensionContext): void => {
+	const setMode = (mode: RetrievalMode, _ctx?: ExtensionContext): void => {
 		session.mode = mode;
-		if (ctx?.hasUI) ctx.ui.setStatus(`${STATUS_KEY}-mode`, `graft mode: ${mode}`);
 	};
 
 	/** Share one global npm install between startup and a concurrent `/graft` command. */
@@ -506,10 +502,7 @@ export default function graftExtension(pi: ExtensionAPI): void {
 		session.disposed = false;
 		session.settings = readGraftSettings({ cwd: ctx.cwd, trusted: ctx.isProjectTrusted() });
 		session.enabled = session.settings.enabled !== false;
-		if (!session.enabled) {
-			if (ctx.hasUI) ctx.ui.setStatus(STATUS_KEY, undefined);
-			return;
-		}
+		if (!session.enabled) return;
 		if (session.settings.telemetry !== "inherit") session.telemetry = applyTelemetryDefault();
 		setMode(readBranchMode(ctx.sessionManager.getBranch()) ?? session.settings.mode ?? DEFAULT_RETRIEVAL_MODE, ctx);
 
@@ -518,13 +511,9 @@ export default function graftExtension(pi: ExtensionAPI): void {
 		else autoBuild(ctx, session);
 	});
 
-	pi.on("session_shutdown", (_event: SessionShutdownEvent, ctx: ExtensionContext) => {
+	pi.on("session_shutdown", (_event: SessionShutdownEvent) => {
 		session.disposed = true;
 		session.telemetry?.restore();
-		if (ctx.hasUI) {
-			ctx.ui.setStatus(STATUS_KEY, undefined);
-			ctx.ui.setStatus(`${STATUS_KEY}-mode`, undefined);
-		}
 		guard.beginTurn();
 		session = freshSession();
 	});
@@ -638,10 +627,6 @@ export default function graftExtension(pi: ExtensionAPI): void {
 		const debounceMs = (session.settings.refreshDebounceSeconds ?? DEFAULT_REFRESH_DEBOUNCE_SECONDS) * 1000;
 		if (Date.now() - session.lastRefreshAt < debounceMs) return;
 		session.lastRefreshAt = Date.now();
-		if (ctx.hasUI) {
-			ctx.ui.setStatus(STATUS_KEY, statusText(reduceGraftState(session.state, { type: "refresh-started" })));
-		}
-
 		void (async () => {
 			try {
 				const run = await buildGraph(ctx, session, "refresh");