@adeildo/pi-ask-permission 4.1.0 → 5.1.0

package/src/core/config/settings.ts

@@ -1,24 +1,27 @@
-// The permission config lives in the shared settings file, one key per leaf, so the settings screen
-// comes from these declarations instead of a screen written by hand. The nested config the rest of
-// the package reads is assembled here, and writing maps back to the same keys.
+// One setting per leaf of the config. `readConfig` builds the nested config back.
 import { existsSync, renameSync } from "node:fs";
 
 import {
 	boolean,
+	type Control,
 	type Decoder,
 	duration,
+	isObject,
 	literal,
 	nullable,
+	readSettingsFile,
 	type Setting,
 	setting,
 	type SettingsScope,
+	type SettingUi,
 	string,
 	stringList,
 	trimmedString,
 	unit,
+	writeSettingsFile,
 } from "@adeildo/pi-kit";
 
-import { type NoUIConfig, noUI } from "#core/config/decode.ts";
+import { mode, type NoUIConfig, noUI, mcpPolicies } from "#core/config/decode.ts";
 import {
 	DEFAULT_CONFIG,
 	DEFAULT_TYPING,
@@ -30,242 +33,276 @@ import {
 	type WorkspaceConfig,
 } from "#core/config/schema.ts";
 import { configPath, readLegacyConfig } from "#core/config/store.ts";
-import { DEFAULT_JUDGE, type JudgeBackendId, type JudgeFallback } from "#core/judge/config.ts";
-import { DEFAULT_MODE, PERMISSION_MODES, type PermissionMode } from "#core/mode.ts";
-
-const PERMISSION = "Permission";
-const JUDGE = "Permission judge";
-
-function leaf<T>(
-	id: string,
-	fallback: T,
-	decoder: Decoder<T>,
-	label: string,
-	description: string,
-	ui = PERMISSION,
-): Setting<T> {
-	return setting({
-		id: `permission.${id}`,
-		default: fallback,
-		decoder,
-		ui: { group: ui, label, description },
-	});
+import {
+	DEFAULT_JUDGE,
+	DEFAULT_RIGOR,
+	JEV_MODELS,
+	JUDGE_RIGORS,
+	type JudgeFallback,
+	type JudgeRigor,
+	RIGOR,
+} from "#core/judge/config.ts";
+import { POLICY_PRESETS } from "#core/judge/policy.ts";
+import { MCP_POLICIES, MCP_POLICY_TEXT, type McpPolicy, sameServer } from "#core/mcp.ts";
+import { DEFAULT_MODE, MODES, PERMISSION_MODES, type PermissionMode } from "#core/mode.ts";
+import { OUTSIDE_DESCRIPTION, OUTSIDE_SCOPES } from "#core/workspace.ts";
+
+export const SECTIONS = [
+	"This session",
+	"New sessions",
+	"Workspace",
+	"MCP servers",
+	"Reads",
+	"Dialog",
+	"Judge",
+	"Always yes",
+] as const;
+
+export type Section = (typeof SECTIONS)[number];
+
+interface Leaf<T> extends Omit<SettingUi, "section"> {
+	id: string;
+	fallback: T;
+	decoder: Decoder<T>;
+	section: Section;
+}
+
+function leaf<T>(entry: Leaf<T>): Setting<T> {
+	const { id, fallback, decoder, ...ui } = entry;
+	return setting({ id: `permission.${id}`, default: fallback, decoder, ui });
+}
+
+/** A setting with no row of its own: the screen builds its row, or only the file sets it. */
+function hiddenLeaf<T>(id: string, fallback: T, decoder: Decoder<T>): Setting<T> {
+	return setting({ id: `permission.${id}`, default: fallback, decoder });
 }
 
+export const MCP_POLICY_CONTROL: Control = {
+	type: "choice",
+	options: MCP_POLICIES.map((value) => ({
+		value,
+		label: MCP_POLICY_TEXT[value].label,
+		description: MCP_POLICY_TEXT[value].description,
+	})),
+};
+
+export const MODE_CONTROL: Control = {
+	type: "choice",
+	options: PERMISSION_MODES.map((value) => ({ value, description: MODES[value].description })),
+};
+
+export const OUTSIDE_CONTROL: Control = {
+	type: "choice",
+	options: OUTSIDE_SCOPES.map((value) => ({ value, description: OUTSIDE_DESCRIPTION[value] })),
+};
+
+const judgeFallback = literal("ask", "allow", "deny");
+
 const PERMISSION_LEAVES = {
-	allow: leaf(
-		"allow",
-		DEFAULT_CONFIG.allow,
-		stringList("tool names"),
-		"Allowed tools",
-		"Tools that run without asking.",
-	),
-	noUI: leaf<NoUIConfig>(
-		"noUI",
-		DEFAULT_CONFIG.noUI,
-		noUI,
-		"Without a dialog",
-		'What to do when there is no dialog to ask in: "allow", "deny", or a map per tool.',
-	),
-	notes: leaf<NoteDelivery>(
-		"notes",
-		DEFAULT_CONFIG.notes,
-		literal("result", "message"),
-		"Note delivery",
-		'"result" attaches your note to the tool result, "message" sends it as a message.',
-	),
-	mode: leaf<PermissionMode>(
-		"mode",
-		DEFAULT_MODE,
-		literal(...PERMISSION_MODES),
-		"Default mode",
-		"The mode a new session starts in.",
-	),
-	readOnlyBash: leaf(
-		"readOnlyBash",
-		DEFAULT_CONFIG.readOnlyBash,
-		boolean,
-		"Read-only bash",
-		"Let commands that only read run without asking.",
-	),
-	roots: leaf(
-		"workspace.roots",
-		DEFAULT_WORKSPACE.roots,
-		stringList("paths"),
-		"Workspace roots",
-		"Paths the project is made of.",
-	),
-	outside: leaf<OutsideScope>(
-		"workspace.outside",
-		DEFAULT_WORKSPACE.outside,
-		literal("ask", "deny", "allow"),
-		"Outside the workspace",
-		"What to do with a path outside the roots.",
-	),
-	pause: leaf(
-		"typing.pause",
-		DEFAULT_TYPING.pause,
-		duration,
-		"Typing pause",
-		"How long after you stop typing the dialog opens.",
-	),
-	maxWait: leaf<number | null>(
-		"typing.maxWait",
-		DEFAULT_TYPING.maxWait,
-		nullable(duration),
-		"Typing wait cap",
-		"Longest the dialog waits while you type. Empty means no cap.",
-	),
+	mode: leaf<PermissionMode>({
+		id: "mode",
+		fallback: DEFAULT_MODE,
+		decoder: mode,
+		section: "New sessions",
+		label: "Mode",
+		description: "The mode a new session starts in. Alt+M changes it for one session.",
+		control: MODE_CONTROL,
+	}),
+	outside: leaf<OutsideScope>({
+		id: "workspace.outside",
+		fallback: DEFAULT_WORKSPACE.outside,
+		decoder: literal("ask", "deny", "allow"),
+		section: "New sessions",
+		label: "Outside the workspace",
+		description:
+			"What a new session does with a call outside the roots. Alt+W changes it for one session.",
+		control: OUTSIDE_CONTROL,
+	}),
+	roots: leaf({
+		id: "workspace.roots",
+		fallback: DEFAULT_WORKSPACE.roots,
+		decoder: stringList("paths"),
+		section: "Workspace",
+		label: "Roots",
+		description: "The folders the project is made of. Relative, absolute and ~ work.",
+	}),
+	servers: hiddenLeaf<Record<string, McpPolicy>>("mcp.servers", {}, mcpPolicies),
+	allow: leaf({
+		id: "allow",
+		fallback: DEFAULT_CONFIG.allow,
+		decoder: stringList("tool names"),
+		section: "Reads",
+		label: "Allowed tools",
+		description: "Tools that run without asking. `mcp_*` matches a family.",
+	}),
+	readOnlyBash: leaf({
+		id: "readOnlyBash",
+		fallback: DEFAULT_CONFIG.readOnlyBash,
+		decoder: boolean,
+		section: "Reads",
+		label: "Read-only bash",
+		description: "Commands that only read run without asking. In full everything runs anyway.",
+	}),
+	notes: leaf<NoteDelivery>({
+		id: "notes",
+		fallback: DEFAULT_CONFIG.notes,
+		decoder: literal("result", "message"),
+		section: "Dialog",
+		label: "Notes",
+		description: "Where the note you write in the dialog goes.",
+		control: {
+			type: "choice",
+			options: [
+				{ value: "result", description: "added to the tool result" },
+				{ value: "message", description: "sent as a message of its own" },
+			],
+		},
+	}),
+	noUI: leaf<NoUIConfig>({
+		id: "noUI",
+		fallback: DEFAULT_CONFIG.noUI,
+		decoder: noUI,
+		section: "Dialog",
+		label: "With no dialog",
+		description:
+			"What happens when nobody can answer, as in print mode or a subagent. The file also takes a map per tool.",
+		control: { type: "choice", options: [{ value: "deny" }, { value: "allow" }] },
+	}),
+	pause: leaf({
+		id: "typing.pause",
+		fallback: DEFAULT_TYPING.pause,
+		decoder: duration,
+		section: "Dialog",
+		label: "Typing pause",
+		description: "How long after you stop typing in the editor the dialog opens.",
+	}),
+	maxWait: leaf<number | null>({
+		id: "typing.maxWait",
+		fallback: DEFAULT_TYPING.maxWait,
+		decoder: nullable(duration),
+		section: "Dialog",
+		label: "Typing wait cap",
+		description:
+			"The longest the dialog waits while you type. Empty waits for as long as you type.",
+	}),
 };
 
 const JUDGE_LEAVES = {
-	enabled: leaf(
-		"judge.enabled",
-		DEFAULT_JUDGE.enabled,
-		boolean,
-		"Judge enabled",
-		"Let a model decide the routine calls.",
-		JUDGE,
-	),
-	provider: leaf<JudgeBackendId>(
-		"judge.provider",
-		DEFAULT_JUDGE.provider,
-		literal("jev", "pi"),
-		"Judge backend",
-		'"jev" asks TypeSafe, "pi" asks the model you are already using.',
-		JUDGE,
-	),
-	model: leaf(
-		"judge.model",
-		DEFAULT_JUDGE.model,
-		trimmedString,
-		"Judge model",
-		"A Jev alias, or provider/modelId for the pi backend.",
-		JUDGE,
-	),
-	tools: leaf(
-		"judge.tools",
-		DEFAULT_JUDGE.tools,
-		stringList("patterns"),
-		"Judged tools",
-		"Tool patterns the judge may decide. Empty means it never runs.",
-		JUDGE,
-	),
-	alwaysAsk: leaf(
-		"judge.alwaysAsk",
-		DEFAULT_JUDGE.alwaysAsk,
-		stringList("patterns"),
-		"Always ask me",
-		"Tool patterns that skip the judge and come to you.",
-		JUDGE,
-	),
-	allowThreshold: leaf(
-		"judge.thresholds.allow",
-		DEFAULT_JUDGE.thresholds.allow,
-		unit,
-		"Judge confidence to allow",
-		"How sure the judge has to be before a call runs.",
-		JUDGE,
-	),
-	denyThreshold: leaf(
-		"judge.thresholds.deny",
-		DEFAULT_JUDGE.thresholds.deny,
-		unit,
-		"Judge confidence to deny",
-		"How sure the judge has to be before it blocks a call on its own.",
-		JUDGE,
-	),
-	riskCeiling: leaf(
-		"judge.riskCeiling",
-		DEFAULT_JUDGE.riskCeiling,
-		unit,
-		"Risk ceiling",
-		"Above this risk the call comes to you, however sure the judge is.",
-		JUDGE,
-	),
-	whenUnsure: leaf<JudgeFallback>(
+	model: leaf({
+		id: "judge.model",
+		fallback: DEFAULT_JUDGE.model,
+		decoder: trimmedString,
+		section: "Judge",
+		label: "Model",
+		description: "Who judges. Jev answers fast, after /login typesafe. Any pi model works too.",
+		control: (ctx) => ({
+			type: "choice",
+			custom: true,
+			options: [
+				...JEV_MODELS.map((value) => ({ value, description: "Jev, by TypeSafe" })),
+				...ctx.modelRegistry
+					.getAvailable()
+					.map((model) => `${model.provider}/${model.id}`)
+					.toSorted((left, right) => left.localeCompare(right))
+					.map((value) => ({ value, description: "pi model" })),
+			],
+		}),
+	}),
+	policy: leaf({
+		id: "judge.policy",
+		fallback: DEFAULT_JUDGE.policy,
+		decoder: string,
+		section: "Judge",
+		label: "Policy",
+		description: "The rules the judge follows, in plain English. Start from a preset and edit it.",
+		control: {
+			type: "text",
+			multiline: true,
+			presets: POLICY_PRESETS.filter((preset) => preset.policy !== "").map((preset) => ({
+				value: preset.policy,
+				label: preset.label,
+				description: preset.description,
+			})),
+		},
+	}),
+	alwaysAsk: leaf({
+		id: "judge.alwaysAsk",
+		fallback: DEFAULT_JUDGE.alwaysAsk,
+		decoder: stringList("patterns"),
+		section: "Judge",
+		label: "Always ask me",
+		description: 'Patterns the judge never approves, like "git push*".',
+	}),
+	// The screen builds these two rows itself. That keeps them after the policy, and lets picking a
+	// rigor drop the numbers set by hand.
+	rigor: hiddenLeaf<JudgeRigor>("judge.rigor", DEFAULT_RIGOR, literal(...JUDGE_RIGORS)),
+	dryRun: hiddenLeaf("judge.dryRun", DEFAULT_JUDGE.dryRun, boolean),
+	// File only. A threshold or a ceiling set here overrides the rigor.
+	allowThreshold: hiddenLeaf("judge.thresholds.allow", DEFAULT_JUDGE.thresholds.allow, unit),
+	denyThreshold: hiddenLeaf("judge.thresholds.deny", DEFAULT_JUDGE.thresholds.deny, unit),
+	riskCeiling: hiddenLeaf("judge.riskCeiling", DEFAULT_JUDGE.riskCeiling, unit),
+	canDeny: hiddenLeaf("judge.canDeny", DEFAULT_JUDGE.canDeny, boolean),
+	whenUnsure: hiddenLeaf<JudgeFallback>(
 		"judge.whenUnsure",
 		DEFAULT_JUDGE.whenUnsure,
-		literal("ask", "allow", "deny"),
-		"When the judge is unsure",
-		"What to do near the thresholds.",
-		JUDGE,
-	),
-	canDeny: leaf(
-		"judge.canDeny",
-		DEFAULT_JUDGE.canDeny,
-		boolean,
-		"Judge may deny",
-		"Let the judge block a call instead of asking you.",
-		JUDGE,
+		judgeFallback,
 	),
-	whenItFails: leaf<JudgeFallback>(
+	whenItFails: hiddenLeaf<JudgeFallback>(
 		"judge.whenItFails",
 		DEFAULT_JUDGE.whenItFails,
-		literal("ask", "allow", "deny"),
-		"When the judge fails",
-		"What to do when the judge errors or times out.",
-		JUDGE,
-	),
-	noUI: leaf(
-		"judge.noUI",
-		DEFAULT_JUDGE.noUI,
-		boolean,
-		"Judge without a dialog",
-		"Run the judge even where there is nobody to ask.",
-		JUDGE,
-	),
-	dryRun: leaf(
-		"judge.dryRun",
-		DEFAULT_JUDGE.dryRun,
-		boolean,
-		"Judge dry run",
-		"Ask the judge and log the verdict, deciding nothing.",
-		JUDGE,
+		judgeFallback,
 	),
-	rememberApprovals: leaf(
+	noUI: hiddenLeaf("judge.noUI", DEFAULT_JUDGE.noUI, boolean),
+	rememberApprovals: hiddenLeaf(
 		"judge.rememberApprovals",
 		DEFAULT_JUDGE.rememberApprovals,
 		boolean,
-		"Remember judge approvals",
-		"Treat an always-yes as a rule for the judge later.",
-		JUDGE,
-	),
-	timeoutMs: leaf(
-		"judge.timeoutMs",
-		DEFAULT_JUDGE.timeoutMs,
-		duration,
-		"Judge timeout",
-		"How long to wait before the call comes to you.",
-		JUDGE,
-	),
-	cache: leaf(
-		"judge.cache",
-		DEFAULT_JUDGE.cache,
-		boolean,
-		"Judge cache",
-		"Reuse a verdict for the same call in one session.",
-		JUDGE,
-	),
-	policy: leaf(
-		"judge.policy",
-		DEFAULT_JUDGE.policy,
-		string,
-		"Judge policy",
-		"The rulebook the judge reads. Plain English.",
-		JUDGE,
 	),
+	timeoutMs: hiddenLeaf("judge.timeoutMs", DEFAULT_JUDGE.timeoutMs, duration),
+	cache: hiddenLeaf("judge.cache", DEFAULT_JUDGE.cache, boolean),
 };
 
+/** The numbers a rigor stands for, when the settings file sets none of them itself. */
+const RIGOR_NUMBERS = [
+	JUDGE_LEAVES.allowThreshold,
+	JUDGE_LEAVES.denyThreshold,
+	JUDGE_LEAVES.riskCeiling,
+] as const;
+
+/** The rigor in force, or `custom` when the settings file sets the numbers by hand. */
+export function readRigor(scope: SettingsScope): JudgeRigor | "custom" {
+	if (RIGOR_NUMBERS.some((entry) => isSetByHand(scope, entry))) return "custom";
+	return JUDGE_LEAVES.rigor.get(scope);
+}
+
+/** Picks a rigor and drops the numbers set by hand, which would otherwise win over it. */
+export function writeRigor(scope: SettingsScope, rigor: JudgeRigor): string | undefined {
+	for (const entry of RIGOR_NUMBERS) {
+		if (!isSetByHand(scope, entry)) continue;
+		const failure = scope.settings.unset(entry, "global");
+		if (failure !== undefined) return failure;
+	}
+	return scope.settings.set(JUDGE_LEAVES.rigor, rigor);
+}
+
+export function readDryRun(scope: SettingsScope): boolean {
+	return JUDGE_LEAVES.dryRun.get(scope);
+}
+
+export function writeDryRun(scope: SettingsScope, dryRun: boolean): string | undefined {
+	return scope.settings.set(JUDGE_LEAVES.dryRun, dryRun);
+}
+
 export const PERMISSION_SETTINGS: readonly Setting<unknown>[] = [
 	...Object.values(PERMISSION_LEAVES),
 	...Object.values(JUDGE_LEAVES),
 ];
 
-/** A fresh object every read, so a caller that mutates one cannot change the defaults. */
+/** A fresh object every read, so a caller can mutate it. */
 export function readConfig(scope: SettingsScope): PermissionConfig {
 	const leaves = PERMISSION_LEAVES;
 	const judge = JUDGE_LEAVES;
+	const rigor = RIGOR[judge.rigor.get(scope)];
 
 	return {
 		allow: [...leaves.allow.get(scope)],
@@ -275,14 +312,15 @@ export function readConfig(scope: SettingsScope): PermissionConfig {
 		readOnlyBash: leaves.readOnlyBash.get(scope),
 		workspace: workspaceOf(scope),
 		typing: typingOf(scope),
+		mcp: { servers: { ...leaves.servers.get(scope) } },
 		judge: {
-			enabled: judge.enabled.get(scope),
-			provider: judge.provider.get(scope),
 			model: judge.model.get(scope),
-			tools: [...judge.tools.get(scope)],
 			alwaysAsk: [...judge.alwaysAsk.get(scope)],
-			thresholds: { allow: judge.allowThreshold.get(scope), deny: judge.denyThreshold.get(scope) },
-			riskCeiling: judge.riskCeiling.get(scope),
+			thresholds: {
+				allow: byHand(scope, judge.allowThreshold) ?? rigor.thresholds.allow,
+				deny: byHand(scope, judge.denyThreshold) ?? rigor.thresholds.deny,
+			},
+			riskCeiling: byHand(scope, judge.riskCeiling) ?? rigor.riskCeiling,
 			whenUnsure: judge.whenUnsure.get(scope),
 			canDeny: judge.canDeny.get(scope),
 			whenItFails: judge.whenItFails.get(scope),
@@ -300,10 +338,23 @@ export function writeConfig(scope: SettingsScope, config: PermissionConfig): str
 	return scope.settings.setAll(toEntries(config));
 }
 
-/**
- * Moves the pre-4.0 config.json into the shared settings and keeps it as a `.bak`. A value that
- * already reads the same is not written, so migrating a default config leaves no keys behind.
- */
+/** The policy one MCP server follows, keeping the others. */
+export function setMcpPolicy(
+	scope: SettingsScope,
+	server: string,
+	policy: McpPolicy,
+): string | undefined {
+	const entry = PERMISSION_LEAVES.servers;
+	const servers: Record<string, McpPolicy> = {};
+	// A name that pi sanitized one way and a hand edit wrote the other way are one server.
+	for (const [name, value] of Object.entries(entry.get(scope))) {
+		if (!sameServer(name, server)) servers[name] = value;
+	}
+	servers[server] = policy;
+	return scope.settings.set(entry, servers);
+}
+
+/** Moves the 3.x config.json into the shared settings and keeps it as a `.bak`. */
 export function migrateConfig(scope: SettingsScope): string[] {
 	const path = configPath();
 	if (!existsSync(path)) return [];
@@ -322,6 +373,49 @@ export function migrateConfig(scope: SettingsScope): string[] {
 	return [...loaded.warnings, `moved the config to the shared settings, keeping ${backup}`];
 }
 
+// Keys an older version read and this one ignores. Left in the file, they look like they work.
+const RETIRED_JUDGE_KEYS: Record<string, string> = {
+	enabled: "pick the judge mode with Alt+M, or under New sessions",
+	tools: "the judge mode judges every call that is not a read or an edit",
+	provider: "the model name picks the provider",
+};
+
+/** Removes the retired judge keys from the global file, and says what each one became. */
+export function dropRetiredKeys(scope: SettingsScope): string[] {
+	const path = scope.settings.globalPath;
+	const { data } = readSettingsFile(path);
+	const permission = isObject(data.permission) ? data.permission : undefined;
+	const judge = isObject(permission?.judge) ? permission.judge : undefined;
+	if (permission === undefined || judge === undefined) return [];
+
+	const retired = Object.keys(RETIRED_JUDGE_KEYS).filter((key) => key in judge);
+	if (retired.length === 0) return [];
+
+	// In 3.x a judge switched on with no mode meant the judge mode, so new sessions keep starting in it.
+	const switchedOn = judge.enabled === true && permission.mode === undefined;
+	if (switchedOn) permission.mode = "judge";
+	for (const key of retired) delete judge[key];
+
+	try {
+		writeSettingsFile(path, data);
+	} catch (error) {
+		return [`could not remove the retired judge keys from ${path}: ${describeError(error)}`];
+	}
+	scope.settings.load(scope.settings.projectPath);
+
+	const lines = retired.map((key) => `removed judge.${key}, ${RETIRED_JUDGE_KEYS[key]}`);
+	if (switchedOn) lines.push("new sessions start in the judge mode, as judge.enabled said");
+	return lines;
+}
+
+function isSetByHand(scope: SettingsScope, entry: Setting<unknown>): boolean {
+	return scope.settings.layer(entry) !== "default";
+}
+
+function byHand<T>(scope: SettingsScope, entry: Setting<T>): T | undefined {
+	return isSetByHand(scope, entry) ? entry.get(scope) : undefined;
+}
+
 function workspaceOf(scope: SettingsScope): WorkspaceConfig {
 	return {
 		roots: [...PERMISSION_LEAVES.roots.get(scope)],
@@ -347,12 +441,10 @@ function toEntries(config: PermissionConfig): (readonly [Setting<unknown>, unkno
 		[leaves.readOnlyBash, config.readOnlyBash],
 		[leaves.roots, config.workspace.roots],
 		[leaves.outside, config.workspace.outside],
+		[leaves.servers, config.mcp.servers],
 		[leaves.pause, config.typing.pause],
 		[leaves.maxWait, config.typing.maxWait],
-		[judge.enabled, config.judge.enabled],
-		[judge.provider, config.judge.provider],
 		[judge.model, config.judge.model],
-		[judge.tools, config.judge.tools],
 		[judge.alwaysAsk, config.judge.alwaysAsk],
 		[judge.allowThreshold, config.judge.thresholds.allow],
 		[judge.denyThreshold, config.judge.thresholds.deny],

package/src/core/config/store.ts

@@ -1,6 +1,5 @@
-// Where 3.x kept its files. The config is read once by the migration and then retired to a `.bak`.
-// Grants stay here, because they are state and not settings, and a project grant has to live in the
-// project it belongs to.
+// The 3.x config.json, which only the migration reads. Always yes files stay here: they are state,
+// and a project's has to live in that project.
 import { existsSync, readFileSync } from "node:fs";
 import { join } from "node:path";
 
@@ -9,6 +8,7 @@ import { CONFIG_DIR_NAME, getAgentDir } from "@earendil-works/pi-coding-agent";
 import { ALWAYS_YES_FILE } from "#core/always-yes.ts";
 import { decodeConfig } from "#core/config/decode.ts";
 import { defaultConfig, type PermissionConfig } from "#core/config/schema.ts";
+import { FOLDERS_FILE } from "#core/folders.ts";
 import { CONFIG_DIR } from "#identity";
 import { describe, isRecord } from "#util/primitives.ts";
 
@@ -30,7 +30,14 @@ export function projectAlwaysYesPath(cwd: string): string {
 	return join(cwd, CONFIG_DIR_NAME, "extensions", CONFIG_DIR, ALWAYS_YES_FILE);
 }
 
-/** Reads the config.json of 3.x. Only the migration reads it, and only while the file exists. */
+export function globalFoldersPath(): string {
+	return join(getAgentDir(), "extensions", CONFIG_DIR, FOLDERS_FILE);
+}
+
+export function projectFoldersPath(cwd: string): string {
+	return join(cwd, CONFIG_DIR_NAME, "extensions", CONFIG_DIR, FOLDERS_FILE);
+}
+
 export function readLegacyConfig(): LegacyConfig {
 	const path = configPath();
 	if (!existsSync(path)) return { config: defaultConfig(), path, warnings: [] };