@adeildo/pi-ask-permission 4.1.0 → 5.1.0

package/src/index.ts

@@ -1,17 +1,22 @@
+import { questions } from "@adeildo/pi-ask-questions";
 import { createApp, defineFeature } from "@adeildo/pi-kit";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 
+import { PERMISSION_SETTINGS, readConfig, SECTIONS } from "#core/config/settings.ts";
 import { listenForTools } from "#pi/api.ts";
 import { registerBashTimer } from "#pi/bash-timer.ts";
-import { registerCommands } from "#pi/commands.ts";
+import { registerShortcuts } from "#pi/commands.ts";
 import { registerEvents } from "#pi/events.ts";
 import { registerTypesafeProvider } from "#pi/provider.ts";
+import { registerScreen } from "#pi/screen.ts";
 import { createSession } from "#pi/session.ts";
 import { registerJudgeEntry } from "#ui/judge-entry.ts";
 
 export const permission = defineFeature({
 	id: "permission",
 	description: "Ask before a tool call runs, with a judge model for the routine ones",
+	sections: SECTIONS,
+	settings: PERMISSION_SETTINGS,
 	setup(scope) {
 		registerBashTimer(scope);
 		registerTypesafeProvider(scope);
@@ -20,10 +25,21 @@ export const permission = defineFeature({
 		const session = createSession();
 		registerEvents(scope, session);
 		listenForTools(scope, session.customTools);
-		registerCommands(scope, session);
+		registerShortcuts(scope, session);
+		registerScreen(scope, session);
+
+		// A change on the screen, or in another pi, applies to the next call.
+		for (const entry of PERMISSION_SETTINGS) {
+			entry.listen(scope, () => {
+				session.config = readConfig(scope);
+				session.judgeCache.clear();
+			});
+		}
 	},
 });
 
 export default function piAskPermission(pi: ExtensionAPI): void {
-	createApp(pi, { name: "pi-ask-permission" }).use(permission).build();
+	// The dialog is the questions feature's. It comes with the package, and the kit keeps it from
+	// running twice when the questions package or the harness is installed as well.
+	createApp(pi, { name: "pi-ask-permission" }).use(questions).use(permission).build();
 }

package/src/pi/commands.ts

@@ -1,193 +1,21 @@
+// Two keys for what a session changes the most. Everything else is on the settings screen.
 import type { FeatureScope } from "@adeildo/pi-kit";
-import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
-import { type AutocompleteItem, Key } from "@earendil-works/pi-tui";
+import { Key } from "@earendil-works/pi-tui";
 
-import { type Scope, SCOPE_LABEL } from "#core/always-yes.ts";
-import { TYPESAFE_PROVIDER } from "#core/judge/backends/jev.ts";
-import { probeJudge } from "#core/judge/probe.ts";
-import { judgeLogText } from "#core/judge/report.ts";
-import { MODE_DESCRIPTION, nextMode, parseMode, PERMISSION_MODES } from "#core/mode.ts";
+import { nextMode, PERMISSION_MODES } from "#core/mode.ts";
+import { toggleOutside } from "#core/workspace.ts";
 import { NAME } from "#identity";
-import { setSessionMode } from "#pi/mode.ts";
-import { forgetAlwaysYes, resetJudgeHealth, saveConfig, type SessionState } from "#pi/session.ts";
-import { alwaysYesCount, openSettings } from "#ui/settings/screen.ts";
-import { notifyJudgePolicyWarning, statusText } from "#ui/settings/status.ts";
-
-const JUDGE_STATUS = `${NAME}:judge`;
-
-export function registerCommands(scope: FeatureScope, state: SessionState): void {
-	const openSettingsFor = (ctx: ExtensionContext): Promise<void> =>
-		openSettings(ctx, {
-			config: state.config,
-			alwaysYes: state.alwaysYes,
-			mode: () => state.mode,
-			setMode: (mode) => setSessionMode(scope, state, mode, ctx, false),
-			save: () => saveConfig(scope, state, ctx),
-			onJudgeChange: () => state.judgeCache.clear(),
-		});
-
-	function notifyStatus(ctx: ExtensionContext): void {
-		ctx.ui.notify(statusText(state.config, state.alwaysYes, ctx.cwd, state.mode), "info");
-	}
-
-	function cycleMode(ctx: ExtensionContext): void {
-		setSessionMode(scope, state, nextMode(state.mode), ctx);
-	}
-
-	async function runJudgeProbe(ctx: ExtensionContext): Promise<void> {
-		ctx.ui.setStatus(JUDGE_STATUS, "judge: testing\u2026");
-		const auth = ctx.modelRegistry.getProviderAuthStatus(TYPESAFE_PROVIDER);
-		const probe = await probeJudge(
-			state.config.judge,
-			{
-				resolveApiKey: () => ctx.modelRegistry.getApiKeyForProvider(TYPESAFE_PROVIDER),
-				modelRegistry: ctx.modelRegistry,
-			},
-			ctx.signal,
-		).finally(() => ctx.ui.setStatus(JUDGE_STATUS, undefined));
-
-		if (!probe.ok) {
-			const source = auth.configured
-				? `key from ${auth.label ?? auth.source}`
-				: "no key configured";
-			const suffix = state.config.judge.provider === "jev" ? ` (${source})` : "";
-			ctx.ui.notify(`${NAME}: judge test failed: ${probe.detail}${suffix}`, "error");
-			return;
-		}
-
-		resetJudgeHealth(state);
-
-		const summary = `judge test ok \u00b7 ${probe.model ?? state.config.judge.model} \u00b7 ${probe.elapsedMs}ms`;
-		if (probe.elapsedMs > state.config.judge.timeoutMs) {
-			ctx.ui.notify(
-				`${NAME}: ${summary}. Slower than the ${state.config.judge.timeoutMs}ms timeout, raise judge.timeoutMs`,
-				"warning",
-			);
-			return;
-		}
-
-		ctx.ui.notify(`${NAME}: ${summary}`, "info");
-	}
-
-	async function judgeCommand(ctx: ExtensionContext, argument: string | undefined): Promise<void> {
-		if (argument === "log") {
-			ctx.ui.notify(judgeLogText(state.judgeLog), "info");
-			return;
-		}
-
-		if (argument === "test") {
-			await runJudgeProbe(ctx);
-			return;
-		}
-
-		if (argument === "on" || argument === "off") {
-			state.config.judge.enabled = argument === "on";
-			saveConfig(scope, state, ctx);
-			state.judgeCache.clear();
-			if (argument === "on") {
-				resetJudgeHealth(state);
-				notifyJudgePolicyWarning(state.config, ctx);
-			}
-			ctx.ui.notify(`${NAME}: judge ${argument}`, "info");
-			return;
-		}
-
-		await settingsOrStatus(ctx);
-	}
-
-	function modeCommand(ctx: ExtensionContext, argument: string | undefined): void {
-		if (argument === undefined) {
-			cycleMode(ctx);
-			return;
-		}
-
-		const mode = parseMode(argument);
-		if (!mode) {
-			ctx.ui.notify(`${NAME}: mode takes ${PERMISSION_MODES.join(", ")}`, "warning");
-			return;
-		}
-
-		setSessionMode(scope, state, mode, ctx);
-	}
-
-	function forgetCommand(ctx: ExtensionContext, argument = "session"): void {
-		const level = FORGET_SCOPES[argument];
-		if (!level) {
-			ctx.ui.notify(`${NAME}: forget takes ${Object.keys(FORGET_SCOPES).join(", ")}`, "warning");
-			return;
-		}
-
-		const where = level === "all" ? "every scope" : SCOPE_LABEL[level];
-		const removed = alwaysYesCount(forgetAlwaysYes(scope, state, ctx, level));
-		ctx.ui.notify(`${NAME}: forgot ${removed} from ${where}`, "info");
-	}
-
-	async function settingsOrStatus(ctx: ExtensionContext): Promise<void> {
-		if (ctx.mode === "tui") await openSettingsFor(ctx);
-		else notifyStatus(ctx);
-	}
-
-	scope.registerCommand("perm", {
-		description: `${NAME}: settings, mode, status, forget, judge`,
-		getArgumentCompletions: (prefix) => {
-			const typed = prefix.trimStart().toLowerCase();
-			const matches = SUBCOMMANDS.filter((command) => command.value.startsWith(typed));
-			return matches.length > 0 ? matches : null;
-		},
-		handler: async (args, ctx) => {
-			const [verb, argument] = args.trim().toLowerCase().split(/\s+/);
-
-			switch (verb) {
-				case "":
-					await settingsOrStatus(ctx);
-					return;
-				case "mode":
-					modeCommand(ctx, argument);
-					return;
-				case "status":
-					notifyStatus(ctx);
-					return;
-				case "forget":
-					forgetCommand(ctx, argument);
-					return;
-				case "judge":
-					await judgeCommand(ctx, argument);
-					return;
-				default:
-					ctx.ui.notify(`${NAME}: /perm takes ${VERBS.join(", ")}`, "warning");
-			}
-		},
-	});
+import { setSessionMode, setSessionOutside } from "#pi/mode.ts";
+import type { SessionState } from "#pi/session.ts";
 
+export function registerShortcuts(scope: FeatureScope, state: SessionState): void {
 	scope.registerShortcut(Key.alt("m"), {
-		description: `${NAME}: cycle mode (manual, accept edits, auto)`,
-		handler: cycleMode,
+		description: `${NAME}: cycle mode (${PERMISSION_MODES.join(", ")})`,
+		handler: (ctx) => setSessionMode(scope, state, nextMode(state.mode), ctx),
 	});
-}
-
-const FORGET_SCOPES: Record<string, Scope | "all"> = {
-	session: "session",
-	project: "project",
-	everywhere: "global",
-	all: "all",
-};
 
-const SUBCOMMANDS: AutocompleteItem[] = [
-	suggestion("mode", "Switch to the next mode (also Alt+M)"),
-	...PERMISSION_MODES.map((mode) => suggestion(`mode ${mode}`, MODE_DESCRIPTION[mode])),
-	suggestion("status", "Show the config, always yes, and file paths"),
-	suggestion("forget", "Forget this session's always yes"),
-	suggestion("forget project", "Forget this project's always yes"),
-	suggestion("forget everywhere", "Forget the always yes that applies everywhere"),
-	suggestion("forget all", "Forget every always yes"),
-	suggestion("judge on", "Turn the judge on"),
-	suggestion("judge off", "Turn the judge off"),
-	suggestion("judge log", "Show this session's judge decisions"),
-	suggestion("judge test", "Send one real request and report the result"),
-];
-
-function suggestion(value: string, description: string): AutocompleteItem {
-	return { value, label: value, description };
+	scope.registerShortcut(Key.alt("w"), {
+		description: `${NAME}: ask or allow calls outside the workspace, this session`,
+		handler: (ctx) => setSessionOutside(scope, state, toggleOutside(state.outside), ctx),
+	});
 }
-
-const VERBS = ["mode", "status", "forget", "judge"];

package/src/pi/events.ts

@@ -1,4 +1,4 @@
-import type { FeatureScope } from "@adeildo/pi-kit";
+import { canAsk, type FeatureScope } from "@adeildo/pi-kit";
 import {
 	type ExtensionAPI,
 	type ExtensionContext,
@@ -7,36 +7,40 @@ import {
 } from "@earendil-works/pi-coding-agent";
 
 import { SCOPE_LABEL } from "#core/always-yes.ts";
-import type { DialogAnswer } from "#core/answer.ts";
+import type { DialogAnswer, FolderOffer } from "#core/answer.ts";
 import { noUIMode } from "#core/config/patterns.ts";
 import {
+	accessOf,
 	type Call,
 	decide,
 	describeCall,
 	gateLayers,
-	type Layer,
 	type Verdict,
 } from "#core/decide.ts";
 import { judgeGate } from "#core/judge/gate.ts";
 import { judgeVerdictText, remember, warnOnce } from "#core/judge/report.ts";
-import type { CallDescriptor } from "#core/tools.ts";
+import { describeHints, type ToolFacts } from "#core/mcp.ts";
+import { MODES } from "#core/mode.ts";
+import { shortenHome } from "#core/tools.ts";
+import { folderChoices } from "#core/workspace.ts";
 import { NAME } from "#identity";
 import { announce, type Decided } from "#pi/api.ts";
-import { clearModeStatus, renderModeStatus } from "#pi/mode.ts";
+import { currentIntent } from "#pi/intent.ts";
+import { clearStatus, notifyJudgePolicyWarning, renderStatus } from "#pi/mode.ts";
 import { type FileChange, type PendingWrites, previewEdit, previewWrite } from "#pi/preview.ts";
 import { restoreSession } from "#pi/session-entries.ts";
 import {
 	loadSessionConfig,
 	openAlwaysYes,
+	openFolder,
 	noteJudgeFailure,
 	rememberAlwaysYes,
 	resetJudgeHealth,
 	type SessionState,
 } from "#pi/session.ts";
-import { AskDialog } from "#ui/dialog.ts";
 import { appendJudgeEntry } from "#ui/judge-entry.ts";
+import { askThroughQuestions, type AskExtras } from "#ui/questions.ts";
 import { askViaSelector } from "#ui/selector.ts";
-import { notifyJudgePolicyWarning } from "#ui/settings/status.ts";
 
 const JUDGE_STATUS = `${NAME}:judge`;
 const TYPING_STATUS = "waiting for you to finish typing";
@@ -46,29 +50,27 @@ export function registerEvents(scope: FeatureScope, state: SessionState): void {
 		loadSessionConfig(scope, state, ctx);
 		openAlwaysYes(state, ctx);
 		restoreSession(state, ctx);
-		notifyJudgePolicyWarning(state.config, ctx);
-		renderModeStatus(ctx, state.mode, state.config.workspace.outside);
+		notifyJudgePolicyWarning(state, ctx);
+		renderStatus(ctx, state);
 		state.typing.start(ctx);
 	});
 
 	scope.on("session_tree", (_event, ctx) => {
 		restoreSession(state, ctx);
-		renderModeStatus(ctx, state.mode, state.config.workspace.outside);
+		renderStatus(ctx, state);
 	});
 
 	scope.on("session_shutdown", (_event, ctx) => {
-		clearModeStatus(ctx);
+		clearStatus(ctx);
 		state.typing.stop();
 	});
 
 	scope.on("tool_call", async (event, ctx) => {
-		const call = describeCall(
-			event.toolName,
-			event.input,
-			ctx.cwd,
-			state.config,
-			state.customTools,
-		);
+		const call = describeCall(event.toolName, event.input, ctx.cwd, state.config, {
+			custom: state.customTools,
+			facts: toolFacts(scope),
+			nested: event.parentToolCallId !== undefined,
+		});
 		const outcome = await gate(scope, state, ctx, call, event);
 
 		announce(scope, {
@@ -101,6 +103,12 @@ export function registerEvents(scope: FeatureScope, state: SessionState): void {
 
 type Outcome = Pick<Decided, "action" | "by" | "reason" | "note">;
 
+/** What pi reports about a tool beside its name: the server it belongs to, and its own hints. */
+function toolFacts(pi: ExtensionAPI): ToolFacts {
+	const tools = pi.getAllTools();
+	return (toolName) => tools.find((tool) => tool.name === toolName);
+}
+
 async function gate(
 	pi: ExtensionAPI,
 	state: SessionState,
@@ -108,8 +116,11 @@ async function gate(
 	call: Call,
 	event: ToolCallEvent,
 ): Promise<Outcome> {
-	const judge: Layer = { name: "judge", decide: (next) => runJudge(state, pi, ctx, next) };
-	const decision = await decide(call, [...gateLayers(state), judge]);
+	const layers = gateLayers(state);
+	if (MODES[state.mode].judge) {
+		layers.push({ name: "judge", decide: (next) => runJudge(state, pi, ctx, next) });
+	}
+	const decision = await decide(call, layers);
 
 	if (decision.action === "allow") return { action: "allow", by: decision.by };
 	if (decision.action === "block")
@@ -129,9 +140,13 @@ async function gate(
 	});
 
 	state.typing.pause();
-	const answer = await ask(ctx, call.toolName, call.target, change?.diff).finally(() =>
-		state.typing.resume(),
-	);
+	const reason = "reason" in decision ? decision.reason : undefined;
+	const leaving = "by" in decision && decision.by === "workspace";
+	const answer = await ask(pi, ctx, call, {
+		diff: change?.diff,
+		reason,
+		offer: leaving ? offerFor(call) : undefined,
+	}).finally(() => state.typing.resume());
 
 	if (answer.decision === "deny") {
 		return { action: "block", by: "you", reason: denyReason(answer.note), note: answer.note };
@@ -141,11 +156,22 @@ async function gate(
 		const scope = answer.scope ?? "session";
 		rememberAlwaysYes(pi, state, ctx, scope, call.toolName, answer.remember);
 		ctx.ui.notify(
-			`${NAME}: always yes for ${call.toolName} \u00b7 ${answer.remember} (${SCOPE_LABEL[scope]})`,
+			`${NAME}: always yes for ${call.toolName}: ${answer.remember} (${SCOPE_LABEL[scope]})`,
 			"info",
 		);
 	}
 
+	if (answer.open) {
+		const { path, access, scope } = answer.open;
+		openFolder(pi, state, ctx, scope, path, access);
+		renderStatus(ctx, state);
+		const what =
+			access === "read"
+				? `reads open in ${shortenHome(path)}`
+				: `${shortenHome(path)} joins the workspace`;
+		ctx.ui.notify(`${NAME}: ${what}, ${SCOPE_LABEL[scope]}`, "info");
+	}
+
 	if (change)
 		state.pendingWrites.set(change.path, { toolCallId: event.toolCallId, after: change.after });
 	return { action: "allow", by: "you", note: answer.note };
@@ -175,6 +201,9 @@ async function runJudge(
 		toolName: call.toolName,
 		target: call.target,
 		rawInput: call.input,
+		source: judgeSource(call),
+		toolDescription: call.description,
+		intent: currentIntent(ctx),
 		cache: state.judgeCache,
 		onStatus: (status) => ctx.ui.setStatus(JUDGE_STATUS, status),
 	});
@@ -210,33 +239,41 @@ async function runJudge(
 	return undefined;
 }
 
+// What the tool name does not say: the server behind an MCP tool and what it declares, and a call
+// that a script issued rather than the model. The judge reads both as data.
+function judgeSource(call: Call): string | undefined {
+	const parts: string[] = [];
+	if (call.mcp) {
+		parts.push(
+			`MCP server "${call.mcp.server}", which declares the tool ${describeHints(call.hints)}`,
+		);
+	}
+	if (call.nested) parts.push("issued by a codemode script, not by the model");
+	return parts.length === 0 ? undefined : parts.join("; ");
+}
+
+// No offer when folderChoices finds nothing to open, like a path in the home itself.
+function offerFor(call: Call): FolderOffer | undefined {
+	if (call.reach.kind !== "outside") return undefined;
+	const choices = folderChoices(call.reach.paths);
+	return choices && { ...choices, access: accessOf(call) };
+}
+
 async function ask(
+	pi: ExtensionAPI,
 	ctx: ExtensionContext,
-	toolName: string,
-	target: CallDescriptor,
-	diff: string | undefined,
+	call: Call,
+	extras: AskExtras,
 ): Promise<DialogAnswer> {
-	if (ctx.mode === "tui") {
-		try {
-			const answer = await ctx.ui.custom<DialogAnswer>(
-				(tui, theme, keybindings, done) =>
-					new AskDialog({
-						theme,
-						toolName,
-						target,
-						diff,
-						keybindings,
-						requestRender: () => tui.requestRender(),
-						complete: done,
-					}),
-			);
-			if (answer) return answer;
-		} catch {
-			// The plain selector, not an open gate.
-		}
+	const { toolName, target } = call;
+	// The questions feature draws the dialog. Without it, and in RPC hosts that cannot draw a
+	// terminal component, the host's own selector asks.
+	if (ctx.mode === "tui" && canAsk(pi.events)) {
+		const answer = await askThroughQuestions(pi.events, call, extras);
+		if (answer !== undefined) return answer;
 	}
 
-	return askViaSelector(ctx, toolName, target);
+	return askViaSelector(ctx, toolName, target, extras.offer);
 }
 
 function sendNote(pi: ExtensionAPI, note: string, toolName: string): void {

package/src/pi/intent.ts

@@ -0,0 +1,34 @@
+// What the user is after, for the judge. Today the last thing they typed; a service that knows the
+// current intent better takes this place later, and the judge does not change.
+import type { ExtensionContext } from "@earendil-works/pi-coding-agent";
+
+import { isRecord } from "#util/primitives.ts";
+
+export function currentIntent(ctx: Pick<ExtensionContext, "sessionManager">): string | undefined {
+	const branch: readonly unknown[] = ctx.sessionManager.getBranch();
+	for (let index = branch.length - 1; index >= 0; index--) {
+		const text = userText(branch[index]);
+		if (text !== undefined) return text;
+	}
+	return undefined;
+}
+
+function userText(entry: unknown): string | undefined {
+	if (!isRecord(entry) || entry.type !== "message" || !isRecord(entry.message)) return undefined;
+	if (entry.message.role !== "user") return undefined;
+
+	return contentText(entry.message.content).trim() || undefined;
+}
+
+/** A message holds a string, or parts where only the text ones say anything. */
+function contentText(content: unknown): string {
+	if (typeof content === "string") return content;
+	if (!Array.isArray(content)) return "";
+
+	const texts: string[] = [];
+	for (const part of content) {
+		if (isRecord(part) && part.type === "text" && typeof part.text === "string")
+			texts.push(part.text);
+	}
+	return texts.join("\n");
+}

package/src/pi/mode.ts

@@ -1,13 +1,28 @@
 import type { ExtensionAPI, ExtensionContext } from "@earendil-works/pi-coding-agent";
 
 import type { OutsideScope } from "#core/config/schema.ts";
-import { MODE_DESCRIPTION, MODE_LABEL, type PermissionMode } from "#core/mode.ts";
+import { policyWarning } from "#core/judge/policy.ts";
+import { MODES, type PermissionMode } from "#core/mode.ts";
+import { OUTSIDE_DESCRIPTION } from "#core/workspace.ts";
 import { NAME } from "#identity";
 import { record } from "#pi/session-entries.ts";
 import type { SessionState } from "#pi/session.ts";
 
 export const MODE_STATUS = `${NAME}:mode`;
 
+const ARROW: Record<PermissionMode, string> = {
+	manual: "",
+	edits: "\u23f5 ",
+	judge: "\u23f5 ",
+	full: "\u23f5\u23f5 ",
+};
+
+const OUTSIDE_TAG: Record<OutsideScope, string | undefined> = {
+	ask: undefined,
+	allow: "anywhere",
+	deny: "workspace only",
+};
+
 export function setSessionMode(
 	pi: ExtensionAPI,
 	state: SessionState,
@@ -17,32 +32,64 @@ export function setSessionMode(
 ): void {
 	if (mode !== state.mode) record(pi, { kind: "mode", mode });
 	state.mode = mode;
-	renderModeStatus(ctx, mode, state.config.workspace.outside);
+	renderStatus(ctx, state);
 
-	if (announce) {
-		ctx.ui.notify(`${NAME}: ${MODE_LABEL[mode]} \u00b7 ${MODE_DESCRIPTION[mode]}`, "info");
-	}
+	if (!announce) return;
+	ctx.ui.notify(`${NAME}: ${mode}, ${MODES[mode].description}`, "info");
+	notifyJudgePolicyWarning(state, ctx);
 }
 
-export function clearModeStatus(ctx: ExtensionContext): void {
+export function setSessionOutside(
+	pi: ExtensionAPI,
+	state: SessionState,
+	outside: OutsideScope,
+	ctx: ExtensionContext,
+	announce = true,
+): void {
+	if (outside !== state.outside) record(pi, { kind: "outside", outside });
+	state.outside = outside;
+	renderStatus(ctx, state);
+
+	if (!announce) return;
+	ctx.ui.notify(`${NAME}: outside ${outside}, ${OUTSIDE_DESCRIPTION[outside]}`, "info");
+}
+
+export function notifyJudgePolicyWarning(
+	state: Pick<SessionState, "config" | "mode">,
+	ctx: ExtensionContext,
+): void {
+	if (state.mode !== "judge") return;
+	const warning = policyWarning(state.config.judge.policy);
+	if (warning) ctx.ui.notify(`${NAME}: ${warning}`, "warning");
+}
+
+export function clearStatus(ctx: ExtensionContext): void {
 	if (!ctx.hasUI) return;
 	ctx.ui.setStatus(MODE_STATUS, undefined);
 }
 
-export function renderModeStatus(
+export function renderStatus(
 	ctx: ExtensionContext,
-	mode: PermissionMode,
-	outside: OutsideScope,
+	state: Pick<SessionState, "mode" | "outside" | "folders">,
 ): void {
-	if (mode === "manual") {
-		clearModeStatus(ctx);
+	const tag = OUTSIDE_TAG[state.outside];
+	const folders = state.folders.total();
+	const quiet = state.mode === "manual" && tag === undefined;
+	if (quiet && folders === 0) {
+		clearStatus(ctx);
 		return;
 	}
 	if (!ctx.hasUI) return;
 
-	const anywhere = outside === "allow";
-	const arrow = mode === "auto" ? "\u23f5\u23f5" : "\u23f5";
-	const color = anywhere ? "error" : "warning";
-	const label = anywhere ? `${MODE_LABEL[mode]} \u00b7 anywhere` : MODE_LABEL[mode];
-	ctx.ui.setStatus(MODE_STATUS, ctx.ui.theme.fg(color, `${arrow} ${label}`));
+	const theme = ctx.ui.theme;
+	const parts: string[] = [];
+	if (!quiet) {
+		const label = tag === undefined ? state.mode : `${state.mode} (${tag})`;
+		const color = state.outside === "allow" ? "error" : "warning";
+		parts.push(theme.fg(color, `${ARROW[state.mode]}${label}`));
+	}
+	// Open folders widen the workspace, so the status bar counts them.
+	if (folders > 0)
+		parts.push(theme.fg("dim", `+${folders} ${folders === 1 ? "folder" : "folders"}`));
+	ctx.ui.setStatus(MODE_STATUS, parts.join("  "));
 }