pi-profile-switch 0.3.1 → 0.4.2

package/src/skill-registry.ts

@@ -0,0 +1,94 @@
+/**
+ * SkillRegistry: mirrors Pi's native skill discovery result as a
+ * name → final SKILL.md mapping.
+ *
+ * Implemented on top of the Pi SDK's DefaultResourceLoader pointed at the
+ * real agent dir and cwd, so discovery rules and same-name priority stay
+ * Pi's own — this module never re-implements directory scanning.
+ *
+ * Extensions are NOT loaded during discovery (`noExtensions`): extension code
+ * must never execute as a side effect of resolving a profile. Skills that
+ * extensions contribute at runtime are therefore absent here — they load with
+ * their extension instead of being referenced by profiles.
+ *
+ * Discovery re-runs on every call, so newly added/removed skills are
+ * reflected immediately (glob references re-expand at every start).
+ */
+
+import { DefaultResourceLoader, SettingsManager } from "@earendil-works/pi-coding-agent";
+
+export interface SkillEntry {
+	/** Pi skill name (the profile-facing identity). */
+	name: string;
+	/** Absolute path of the winning SKILL.md (or lone .md) file. */
+	filePath: string;
+	/** Discovery source, e.g. "auto", "local", or a package source string. */
+	source: string;
+	/** "user" | "project" | "temporary" (Pi's SourceScope). */
+	scope: string;
+	/** "package" when contributed by an installed package, else "top-level". */
+	origin: string;
+	/** Package install root for package-origin skills (patterns are relative to it). */
+	baseDir?: string;
+}
+
+export interface DiscoverSkillsOptions {
+	cwd: string;
+	agentDir: string;
+	/**
+	 * Whether the project at `cwd` is trusted (the launcher's trust check).
+	 * Untrusted projects are never scanned: no project skills, no project
+	 * settings packages. Defaults to false.
+	 */
+	projectTrusted?: boolean;
+}
+
+export async function discoverSkills(options: DiscoverSkillsOptions): Promise<SkillEntry[]> {
+	// Project trust comes from the caller's trust check; generated settings
+	// carry defaultProjectTrust: "never", so discovery is the only place
+	// project resources can enter a plan.
+	const settingsManager = SettingsManager.create(options.cwd, options.agentDir, {
+		projectTrusted: options.projectTrusted ?? false,
+	});
+	const loader = new DefaultResourceLoader({
+		cwd: options.cwd,
+		agentDir: options.agentDir,
+		settingsManager,
+		noExtensions: true,
+		noPromptTemplates: true,
+		noThemes: true,
+		noContextFiles: true,
+	});
+	// Pi installs missing configured packages during resolve(); discovery must
+	// stay read-only (no network, no mutations), so offline mode is forced for
+	// the duration of the load. The spawned pi decides on installs itself at
+	// startup, with its own progress UI. Known limitation: skills of a
+	// not-yet-installed package cannot be referenced until after a reload.
+	const savedOffline = process.env.PI_OFFLINE;
+	process.env.PI_OFFLINE = "1";
+	try {
+		await loader.reload();
+	} finally {
+		if (savedOffline === undefined) delete process.env.PI_OFFLINE;
+		else process.env.PI_OFFLINE = savedOffline;
+	}
+	return loader.getSkills().skills.flatMap((skill) => {
+		// Project-scoped package skills are excluded: their packages install
+		// under the project's .pi/npm, which generated global-scope settings
+		// cannot reference. Project .pi/skills and ancestor .agents/skills are
+		// unaffected. (Limitation documented in ticket 03's comments.)
+		if (skill.sourceInfo.origin === "package" && skill.sourceInfo.scope === "project") {
+			return [];
+		}
+		return [
+			{
+				name: skill.name,
+				filePath: skill.filePath,
+				source: skill.sourceInfo.source,
+				scope: skill.sourceInfo.scope,
+				origin: skill.sourceInfo.origin,
+				baseDir: skill.sourceInfo.baseDir,
+			},
+		];
+	});
+}

package/src/switching/apply-plan.ts

@@ -0,0 +1,197 @@
+/**
+ * ApplyLaunchPlan: applies the launch plan inside a running Pi after every
+ * session start (startup, reload, new/resume/fork) — the post-reload half of
+ * switching (ticket 05).
+ *
+ * The freshly re-executed pi-profile extension calls this from its
+ * `session_start` handler. It is dependency-injected against a narrow pi
+ * surface so unit tests never need a real Pi.
+ *
+ * Steps:
+ *   1. tools: re-expand the profile's raw tool references against Pi's LIVE
+ *      tool registry (includes extension-provided tools the pre-spawn
+ *      expansion cannot know) and setActiveTools. Literals that no tool
+ *      provides are dropped with a warning — Pi silently ignores unknown
+ *      names, so the warning is the only signal.
+ *   2. model: setModel + setThinkingLevel when declared.
+ *   3. mcp: probe the adapter and publish the runtime allowlist (ticket 04).
+ *   4. persistence: when the plan is marked `persistSelection` and this is a
+ *      reload, save the selection and the rollback anchor
+ *      (activeProfile = lastVerifiedProfile = plan.profile) to the
+ *      profile's scope state file. Launch-transient selections never write.
+ *   5. change summary: a `switchedFrom` marker produces a one-shot summary
+ *      for the next agent turn and is cleared from the plan file.
+ *
+ * Pi's reload re-executes extension modules, so no stale handler or command
+ * context survives; this module is the only place post-reload state is
+ * established.
+ */
+
+import { writeFile } from "node:fs/promises";
+import path from "node:path";
+
+import { isRecord, readJsonFile } from "../json-file.ts";
+import {
+	MCP_ALLOWLIST_EVENT,
+	MCP_ALLOWLIST_VERSION,
+	MissingMcpAdapterError,
+	probeAdapterPresence,
+} from "../mcp-coordination.ts";
+import { RuntimeStateStore } from "../runtime-state-store.ts";
+import { getGlobalStateDir } from "../workspace.ts";
+import { expandToolReferences } from "./tool-references.ts";
+
+export interface LaunchPlanFile {
+	profile: string;
+	source: string;
+	agentDir?: string;
+	instructions?: string;
+	model?: { provider: string; id: string; thinkingLevel?: string };
+	tools?: string[];
+	toolReferences?: string[];
+	mcps?: string[];
+	switchedFrom?: string;
+	persistSelection?: boolean;
+	clearOverlay?: boolean;
+	resolved?: {
+		skills: Array<{ name: string; filePath: string }>;
+		extensions: Array<{ id: string; entry: string }>;
+	};
+	/** Glob references that matched nothing at resolution (ADR-0006). */
+	unmatched?: string[];
+	previousResolved?: {
+		skills: string[];
+		extensions: string[];
+		tools?: string[];
+		mcps?: string[];
+	};
+}
+
+/** The narrow slice of ExtensionAPI/Context the application needs. */
+export interface PlanApplicationSurface {
+	getAllTools(): Array<{ name: string }>;
+	setActiveTools(names: string[]): void;
+	modelRegistry: { find(provider: string, id: string): unknown | undefined };
+	setModel(model: unknown): Promise<boolean>;
+	setThinkingLevel(level: unknown): void;
+	events: { emit(channel: string, data: unknown): void };
+	notify?(message: string, level: "info" | "warning" | "error"): void;
+}
+
+export interface ApplyResult {
+	/** One-shot profile-change summary for the next agent turn, if any. */
+	summary?: string;
+	warnings: string[];
+}
+
+export async function readLaunchPlanFile(runtimeDir: string): Promise<LaunchPlanFile | undefined> {
+	const result = await readJsonFile(path.join(runtimeDir, "pi-profile.json"));
+	if (!result.ok || !isRecord(result.value) || typeof result.value.profile !== "string") {
+		return undefined;
+	}
+	return result.value as unknown as LaunchPlanFile;
+}
+
+/** Applies the plan carried by the runtime dir's pi-profile.json. */
+export async function applyLaunchPlan(input: {
+	runtimeDir: string;
+	cwd: string;
+	/** The session_start reason ("startup" | "reload" | "new" | ...). */
+	reason: string;
+	surface: PlanApplicationSurface;
+}): Promise<ApplyResult> {
+	const { surface } = input;
+	const plan = await readLaunchPlanFile(input.runtimeDir);
+	if (plan === undefined) {
+		return { warnings: [] };
+	}
+	const warnings: string[] = [];
+
+	// --- tools ---
+	if (plan.toolReferences !== undefined) {
+		const liveNames = surface.getAllTools().map((tool) => tool.name);
+		const { expanded, droppedLiterals } = expandToolReferences(plan.toolReferences, liveNames);
+		if (droppedLiterals.length > 0) {
+			warnings.push(
+				`profile "${plan.profile}": tools ${droppedLiterals.map((name) => JSON.stringify(name)).join(", ")} match nothing in Pi's live registry`,
+			);
+		}
+		surface.setActiveTools(expanded);
+	}
+
+	// --- model ---
+	if (plan.model !== undefined) {
+		const found = surface.modelRegistry.find(plan.model.provider, plan.model.id);
+		if (found === undefined) {
+			warnings.push(`profile "${plan.profile}": declared model ${plan.model.provider}/${plan.model.id} not found`);
+		} else {
+			const applied = await surface.setModel(found);
+			if (!applied) {
+				warnings.push(
+					`profile "${plan.profile}": model ${plan.model.provider}/${plan.model.id} has no configured auth`,
+				);
+			}
+		}
+		if (plan.model.thinkingLevel !== undefined) {
+			surface.setThinkingLevel(plan.model.thinkingLevel);
+		}
+	}
+
+	// --- mcp coordination (ticket 04 contract) ---
+	if (plan.mcps !== undefined && plan.mcps.length > 0) {
+		if (!probeAdapterPresence(surface.events)) {
+			const error = new MissingMcpAdapterError(plan.profile);
+			surface.notify?.(error.message, "error");
+			throw error;
+		}
+		surface.events.emit(MCP_ALLOWLIST_EVENT, {
+			version: MCP_ALLOWLIST_VERSION,
+			profile: plan.profile,
+			servers: plan.mcps,
+		});
+	}
+
+	// --- persistence + rollback anchor (post-reload only) ---
+	if (plan.persistSelection === true && input.reason === "reload" && plan.agentDir !== undefined) {
+		const stateDir = plan.source === "project" ? path.join(input.cwd, ".pi") : getGlobalStateDir(plan.agentDir);
+		// Merge: the overlay belongs to customize/reset, not to this write.
+		// A switch (clearOverlay) explicitly drops it.
+		await new RuntimeStateStore(stateDir).update({
+			activeProfile: plan.profile,
+			lastVerifiedProfile: plan.profile,
+			...(plan.clearOverlay === true ? { overlay: undefined } : {}),
+		});
+	}
+
+	// --- one-shot change summary ---
+	let summary: string | undefined;
+	if (typeof plan.switchedFrom === "string" && plan.switchedFrom.length > 0) {
+		summary = buildSwitchSummary(plan);
+		surface.notify?.(summary, "info");
+		await clearSwitchMarker(input.runtimeDir);
+	}
+
+	for (const warning of warnings) {
+		surface.notify?.(warning, "warning");
+	}
+	return { summary, warnings };
+}
+
+function buildSwitchSummary(plan: LaunchPlanFile): string {
+	const parts = [
+		`profile switched: ${plan.switchedFrom} → ${plan.profile}`,
+		plan.tools !== undefined ? `tools: [${plan.tools.join(", ")}]` : undefined,
+		plan.mcps !== undefined && plan.mcps.length > 0 ? `mcp: [${plan.mcps.join(", ")}]` : undefined,
+		plan.model !== undefined ? `model: ${plan.model.provider}/${plan.model.id}` : undefined,
+	].filter((part): part is string => part !== undefined);
+	return parts.join("; ");
+}
+
+/** Clears the one-shot marker so the summary fires exactly once, even
+ *  across later reloads. */
+async function clearSwitchMarker(runtimeDir: string): Promise<void> {
+	const plan = await readLaunchPlanFile(runtimeDir);
+	if (plan === undefined) return;
+	delete plan.switchedFrom;
+	await writeFile(path.join(runtimeDir, "pi-profile.json"), `${JSON.stringify(plan, null, 2)}\n`);
+}

package/src/switching/customize.ts

@@ -1,61 +1,90 @@
 /**
- * Overlay customize/reset orchestration.
+ * Overlay customize/reset orchestration (ticket 06).
  *
  * The overlay narrows the ACTIVE profile for this runtime only. It is
- * written to the scope state file (never a catalog) as persistence and the
- * status surface; the runtime effect flows through re-resolution with the
- * overlay, exactly like a switch. Startup activation ignores stored
- * overlays, so an overlay never outlives its runtime.
+ * written to the scope state file (never a catalog) purely as the
+ * persistence/status surface — the runtime effect flows through
+ * re-resolution with the overlay, exactly like a switch. The launcher
+ * ignores stored overlays, so an overlay never outlives its runtime.
  *
  * Ordering invariants:
- * - customize: activate with the candidate overlay FIRST (validation:
- *   unknown references fail here, before anything is written), then persist
- *   the overlay to state. A failed activation leaves the stored overlay
- *   untouched.
- * - reset: activate without the overlay first, then delete it from state.
+ * - customize: re-resolve with the candidate overlay FIRST (validation:
+ *   unknown references and alwaysOn protection fail here, before anything
+ *   is written), then switch+reload, then persist the overlay to state. A
+ *   failed switch leaves the stored overlay untouched, consistent with the
+ *   rolled-back runtime.
+ * - reset: switch+reload WITHOUT the overlay first, then delete it from
+ *   state. If the switch rolls back, the stored overlay still matches the
+ *   restored runtime.
  */
 
+import path from "node:path";
 
-import type { ProfileSource } from "../profile-catalog.ts";
-import { RuntimeStateStore, stateDirFor, type RuntimeOverlay } from "../runtime-state-store.ts";
-import { activateProfile, ActivationError, type ActivationDeps, type ActivationResult } from "./activate-profile.ts";
+import { RuntimeStateStore, type RuntimeOverlay, type RuntimeState } from "../runtime-state-store.ts";
+import { getGlobalStateDir } from "../workspace.ts";
+import { readLaunchPlanFile } from "./apply-plan.ts";
+import { SwitchError, switchProfile, type SwitchDeps, type SwitchResult } from "./switch-profile.ts";
 
-export interface OverlayTarget {
-	profile: { name: string; source: ProfileSource };
+/** The scope state file for the currently active profile. */
+async function currentStateTarget(
+	deps: SwitchDeps,
+): Promise<{ profile: string; store: RuntimeStateStore; state: RuntimeState }> {
+	const plan = await readLaunchPlanFile(deps.runtimeDir);
+	if (plan === undefined) {
+		throw new SwitchError("no active profile — nothing to customize");
+	}
+	const stateDir = plan.source === "project" ? path.join(deps.cwd, ".pi") : getGlobalStateDir(plan.agentDir);
+	if (stateDir === undefined) {
+		throw new SwitchError("the launch plan carries no real agent dir — cannot locate the state file");
+	}
+	const store = new RuntimeStateStore(stateDir);
+	return { profile: plan.profile, store, state: await store.read() };
 }
 
 /** Applies a mutation to the active profile's overlay and re-activates. */
 export async function customizeOverlay(
-	deps: ActivationDeps & OverlayTarget,
+	deps: SwitchDeps,
 	mutate: (overlay: RuntimeOverlay) => RuntimeOverlay,
-): Promise<ActivationResult> {
-	const stateDir = stateDirFor(deps.profile.source, deps);
-	const stored = (await new RuntimeStateStore(stateDir).read()).overlay ?? {};
-	const candidate = mutate(stored);
-	// activateProfile re-resolves with the candidate and persists it
-	// (overlay in the state update) — validation fails before any write.
-	return activateProfile(deps.profile.name, deps, { overlay: candidate, persist: true });
+): Promise<SwitchResult> {
+	const { profile, store, state } = await currentStateTarget(deps);
+	const candidate = mutate(state.overlay ?? {});
+
+	// switchProfile re-resolves with the candidate overlay; resolution-time
+	// validation (unknown references, alwaysOn protection) fails before any
+	// write. persistSelection is preserved by the reload-current path.
+	const result = await switchProfile(profile, deps, { reloadCurrent: true, overlay: candidate });
+
+	await store.update({ overlay: candidate });
+	return result;
 }
 
 /** Discards the overlay and reactivates the profile exactly as declared. */
-export async function resetOverlay(deps: ActivationDeps & OverlayTarget): Promise<ActivationResult> {
-	return activateProfile(deps.profile.name, deps, { overlay: null, persist: true });
+export async function resetOverlay(deps: SwitchDeps): Promise<SwitchResult> {
+	const { profile, store } = await currentStateTarget(deps);
+
+	// overlay: null — explicit "none"; without it the reload path would
+	// re-apply the stored overlay we're discarding.
+	const result = await switchProfile(profile, deps, { reloadCurrent: true, overlay: null });
+
+	await store.update({ overlay: undefined });
+	return result;
 }
 
 export const CUSTOMIZE_USAGE =
-	"/profile customize disable|enable skill|mcp <name> · /profile customize tools [ref...]" as const;
+	"/profile customize disable|enable skill|extension|mcp <name> · /profile customize tools [ref...]" as const;
 
 const DISABLED_FIELDS = {
 	skill: "disabledSkills",
-	mcp: "disabledMcp",
+	extension: "disabledExtensions",
+	mcp: "disabledMcps",
 } as const;
 
 /** Parses `/profile customize` arguments into an overlay mutation.
  *  Grammar:
- *    customize disable skill|mcp <name>
- *    customize enable  skill|mcp <name>   (un-disable)
- *    customize tools <ref>...             (replace tool refs)
- *    customize tools                      (clear the tools override)
+ *    customize disable skill|extension|mcp <name>
+ *    customize enable  skill|extension|mcp <name>   (un-disable)
+ *    customize tools <ref>...                        (replace tool refs)
+ *    customize tools                                  (clear the tools override)
  */
 export function parseCustomizeArgs(args: string): (overlay: RuntimeOverlay) => RuntimeOverlay {
 	const [action, kind, ...rest] = args.trim().split(/\s+/).filter(Boolean);
@@ -71,8 +100,8 @@ export function parseCustomizeArgs(args: string): (overlay: RuntimeOverlay) => R
 	}
 
 	const field = DISABLED_FIELDS[kind as keyof typeof DISABLED_FIELDS];
-	if (field === undefined || (action !== "disable" && action !== "enable") || rest.length !== 1) {
-		throw new ActivationError(`usage: ${CUSTOMIZE_USAGE}`);
+	if ((action !== "disable" && action !== "enable") || field === undefined || rest.length !== 1) {
+		throw new SwitchError(`usage: ${CUSTOMIZE_USAGE}`);
 	}
 	const [name] = rest;
 	return (overlay) => {

package/src/switching/list-profiles.ts

@@ -1,12 +1,14 @@
 /**
- * ProfileListing: the `/profile list` and `/profile` selector data surface.
+ * ProfileListing: the `/profile list` and `/profile` selector data surface
+ * (ticket 07).
  *
  * Trust-gated exactly like activation: an untrusted project's profiles are
  * invisible. The listing reports each visible profile with the source of
- * the WINNING definition (a same-name project definition fully replaces the
- * global one — the shadowed global entry is reported as such).
+ * the WINNING definition (a same-name project definition fully replaces
+ * the global one — the shadowed global entry is reported as such).
  */
 
+import { readTrustInputs } from "../launcher/initial-profile.ts";
 import { ProfileCatalog, type ProfileSource } from "../profile-catalog.ts";
 
 export interface ProfileListEntry {
@@ -23,17 +25,18 @@ export interface ProfileListEntry {
 export async function listProfiles(input: {
 	realAgentDir: string;
 	cwd: string;
-	projectTrusted: boolean;
 }): Promise<ProfileListEntry[]> {
+	const { projectTrusted } = await readTrustInputs({ agentDir: input.realAgentDir, cwd: input.cwd });
 	const catalog = await ProfileCatalog.load(input.realAgentDir, {
-		projectDir: input.projectTrusted ? input.cwd : undefined,
+		projectDir: projectTrusted ? input.cwd : undefined,
 	});
+	const globalOnly = projectTrusted ? await ProfileCatalog.load(input.realAgentDir) : catalog;
 	return catalog.list().map((profile) => ({
 		name: profile.name,
 		source: profile.source,
 		...(typeof profile.definition.label === "string" ? { label: profile.definition.label } : {}),
 		...(typeof profile.definition.description === "string" ? { description: profile.definition.description } : {}),
-		shadowsGlobal: profile.source === "project" && catalog.shadowsGlobal(profile.name),
+		shadowsGlobal: profile.source === "project" && globalOnly.resolve(profile.name) !== undefined,
 	}));
 }
 

package/src/switching/mcp-toggle.ts

@@ -4,9 +4,9 @@
  * The profile's `mcps` array in its OWNING catalog is the profile-scoped
  * state store (ticket 04 established that pi-mcp-adapter@2.33.0 has no
  * allowlist/profile-state API — ADR-0002's assumed store does not exist;
- * pi-profile-switch owns the contract). The runtime effect is the caller's
- * re-activation of the active profile, which republishes the allowlist over
- * the coordination channel.
+ * pi-profile owns the contract). Runtime effect flows through the standard
+ * rewrite-settings-and-reload path: the post-reload session_start
+ * republishes the allowlist over the coordination channel.
  *
  * Invariants:
  * - Enable accepts only adapter-discovered names (fail fast on typos);
@@ -20,40 +20,30 @@
  */
 
 import { discoverAdapterServerNames } from "../mcp-config.ts";
-import {
-	CatalogError,
-	DEFAULT_PROFILE_NAME,
-	LEGACY_FIELD_ALIASES,
-	type ProfileDefinition,
-	type ProfileSource,
-} from "../profile-catalog.ts";
+import { CatalogError, DEFAULT_PROFILE_NAME, type ProfileDefinition } from "../profile-catalog.ts";
+import { readTrustInputs as readTrust } from "../launcher/initial-profile.ts";
 import { catalogStore, readCatalogScope, type CatalogScope } from "./profile-crud.ts";
 
 export async function setMcpServerEnabled(
-	input: {
-		realAgentDir: string;
-		cwd: string;
-		projectTrusted: boolean;
-		profile: { name: string; source: ProfileSource };
-	},
+	input: { realAgentDir: string; cwd: string; profile: { name: string; source: string } },
 	server: string,
 	enabled: boolean,
 ): Promise<{ mcps: string[]; changed: boolean }> {
-	const { name, source } = input.profile;
-	if (name === DEFAULT_PROFILE_NAME || source === "builtin") {
+	if (input.profile.name === DEFAULT_PROFILE_NAME || input.profile.source === "builtin") {
 		throw new CatalogError(
 			`the built-in default profile has no catalog entry — create a named profile (/profile create) to toggle MCP servers`,
 		);
 	}
-	if (source !== "global" && source !== "project") {
-		throw new CatalogError(`profile "${name}" has no writable owning catalog (source: ${source})`);
+	const scope = input.profile.source as CatalogScope;
+	if (scope !== "global" && scope !== "project") {
+		throw new CatalogError(`profile "${input.profile.name}" has no writable owning catalog (source: ${input.profile.source})`);
 	}
-	const scope: CatalogScope = source;
 
-	if (scope === "project" && !input.projectTrusted) {
+	const { projectTrusted } = await readTrust({ agentDir: input.realAgentDir, cwd: input.cwd });
+	if (scope === "project" && !projectTrusted) {
 		throw new CatalogError(`project catalog is unavailable: ${input.cwd} is not trusted`);
 	}
-	const discovered = await discoverAdapterServerNames(input.realAgentDir, input.projectTrusted ? input.cwd : undefined);
+	const discovered = await discoverAdapterServerNames(input.realAgentDir, projectTrusted ? input.cwd : undefined);
 	if (enabled && !discovered.includes(server)) {
 		throw new CatalogError(
 			`unknown MCP server "${server}" — adapter discovered: [${discovered.join(", ") || "(none)"}]`,
@@ -72,12 +62,10 @@ export async function setMcpServerEnabled(
 	}
 	const next = enabled ? [...current, server] : current.filter((name) => name !== server);
 	// Drop the key entirely when empty (exactOptionalPropertyTypes; a
-	// written `mcps: undefined` would also misrepresent the definition) and
-	// drop the legacy alias, so one save migrates the file to `mcps`.
+	// written `mcps: undefined` would also misrepresent the definition).
 	const rest = { ...definition };
 	delete rest.mcps;
 	const updated: ProfileDefinition = next.length > 0 ? { ...rest, mcps: next } : rest;
-	delete (updated as Record<string, unknown>)[LEGACY_FIELD_ALIASES.mcps];
 	await catalogStore(input, scope).upsert(input.profile.name, updated);
 	return { mcps: next, changed: true };
 }

package/src/switching/profile-crud.ts

@@ -16,30 +16,34 @@
 
 import path from "node:path";
 
+import { getGlobalProfilesPath } from "../workspace.ts";
+import { readTrustInputs } from "../launcher/initial-profile.ts";
 import { CatalogError, DEFAULT_PROFILE_NAME, type ProfileDefinition } from "../profile-catalog.ts";
 import { ProfileCatalogStore } from "../profile-catalog-store.ts";
 
 export type CatalogScope = "global" | "project";
 
-/** The caller's trust decision (`ctx.isProjectTrusted()`) plus the two
- *  directories scope files live in. */
-export interface CatalogInput {
-	realAgentDir: string;
-	cwd: string;
-	projectTrusted: boolean;
-}
-
 /** The store for one scope's catalog file — the ONLY place scope-file
  *  paths are constructed. Callers must still trust-gate project access
  *  (`requireScope` / `readCatalogScope`). */
-export function catalogStore(input: CatalogInput, scope: CatalogScope): ProfileCatalogStore {
-	return new ProfileCatalogStore(
-		scope === "global" ? path.join(input.realAgentDir, "profiles.json") : path.join(input.cwd, ".pi", "profiles.json"),
-	);
+export function catalogStore(
+	input: { realAgentDir: string; cwd: string },
+	scope: CatalogScope,
+): ProfileCatalogStore {
+	if (scope === "global") {
+		return new ProfileCatalogStore(
+			getGlobalProfilesPath(),
+			path.join(input.realAgentDir, "profiles.json")
+		);
+	}
+	return new ProfileCatalogStore(path.join(input.cwd, ".pi", "profiles.json"));
 }
 
-function requireScope(input: CatalogInput, scope: CatalogScope): void {
-	if (scope === "project" && !input.projectTrusted) {
+async function requireScope(input: { realAgentDir: string; cwd: string }, scope: CatalogScope): Promise<void> {
+	if (
+		scope === "project" &&
+		!(await readTrustInputs({ agentDir: input.realAgentDir, cwd: input.cwd })).projectTrusted
+	) {
 		throw new CatalogError(`project catalog is unavailable: ${input.cwd} is not trusted`);
 	}
 }
@@ -47,10 +51,13 @@ function requireScope(input: CatalogInput, scope: CatalogScope): void {
 /** Reads one scope's catalog with the trust gate applied — project reads
  *  return empty when untrusted (never touching the file). */
 export async function readCatalogScope(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 ): Promise<Map<string, ProfileDefinition>> {
-	if (scope === "project" && !input.projectTrusted) {
+	if (
+		scope === "project" &&
+		!(await readTrustInputs({ agentDir: input.realAgentDir, cwd: input.cwd })).projectTrusted
+	) {
 		return new Map();
 	}
 	return catalogStore(input, scope).readDefinitions();
@@ -58,12 +65,12 @@ export async function readCatalogScope(
 
 /** Creates a complete definition in the chosen scope. */
 export async function createProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	name: string,
 	definition: ProfileDefinition,
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	const store = catalogStore(input, scope);
 	if ((await store.readDefinitions()).has(name)) {
 		throw new CatalogError(`profile "${name}" already exists in the ${scope} catalog`);
@@ -73,12 +80,12 @@ export async function createProfile(
 
 /** Replaces a complete definition; the caller reloads iff it is active. */
 export async function editProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	name: string,
 	definition: ProfileDefinition,
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	if (name === DEFAULT_PROFILE_NAME) {
 		throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and cannot be edited`);
 	}
@@ -96,12 +103,12 @@ export async function editProfile(
  * deleted.
  */
 export async function deleteProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	name: string,
 	options: { activeProfile?: string; replacement?: string },
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	if (name === DEFAULT_PROFILE_NAME) {
 		throw new CatalogError(`"${DEFAULT_PROFILE_NAME}" is built in and cannot be deleted`);
 	}
@@ -113,12 +120,12 @@ export async function deleteProfile(
 
 /** Copies a complete definition under a new, unused name. */
 export async function duplicateProfile(
-	input: CatalogInput,
+	input: { realAgentDir: string; cwd: string },
 	scope: CatalogScope,
 	sourceName: string,
 	newName: string,
 ): Promise<void> {
-	requireScope(input, scope);
+	await requireScope(input, scope);
 	const store = catalogStore(input, scope);
 	const definitions = await store.readDefinitions();
 	const source = definitions.get(sourceName);