ultimate-pi 0.19.1 → 0.22.0

package/.pi/extensions/policy-gate.ts

@@ -59,7 +59,6 @@ const PHASE_ORDER: HarnessPhase[] = [
 	"merge",
 ];
 
-// @ts-expect-error pi extensions run as ESM
 const MODULE_URL = import.meta.url;
 
 const MUTATING_TOOLS = new Set(["write", "edit"]);
@@ -127,260 +126,302 @@ function getLatestPolicyStateFull(ctx: {
 	return defaultState();
 }
 
-export default function policyGate(pi: ExtensionAPI) {
-	if (!isHarnessProjectEnabled()) return;
-	let state = defaultState();
-
-	const appendPolicyState = (next: PolicyState): void => {
-		state = next;
-		pi.appendEntry("harness-policy-state", state);
-	};
-
-	pi.on("session_start", async (_event, ctx) => {
-		state = getLatestPolicyStateFull(ctx);
-		const booted = await bootstrapHarnessSubprocessFromEnv(pi, ctx);
-		if (booted) {
-			state = getLatestPolicyStateFull(ctx);
-		}
-	});
-
-	pi.on("before_agent_start", async (event, ctx) => {
-		const userPrompt = userVisiblePromptSlice(event.prompt);
-		await bootstrapHarnessSubprocessFromEnv(pi, ctx);
-		const entries = ctx.sessionManager.getEntries();
-		state = getLatestPolicyStateFull(ctx);
-		const bootstrapPrompt = isHarnessBootstrapPrompt(userPrompt);
-		const abortSignal = hasHarnessAbortSignal(userPrompt);
-
-		// /harness-setup instructions mention `harness-plan` (e.g. gh label text). That
-		// substring must not force inferPhase() to "plan" or bootstrap stays blocked.
-		if (bootstrapPrompt) {
-			state.phase = "execute";
-			state.approvedPlan = true;
-			state.planId = null;
-			state.budgetBypass = true;
-			state.aborted = false;
-			state.abortReason = null;
-			state.abortedAt = null;
-			state.updatedAt = nowIso();
-			pi.appendEntry("harness-policy-state", state);
-			return {
-				systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nPhase=${state.phase}; ApprovedPlan=${state.approvedPlan}; PlanId=${state.planId ?? "none"}; Aborted=${state.aborted}; Bootstrap=harness-setup.`,
-			};
-		}
-
-		if (abortSignal) {
-			state.phase = "plan";
-			state.approvedPlan = false;
-			state.planId = null;
-			state.budgetBypass = false;
-			state.aborted = true;
-			state.abortReason = "harness-abort command";
-			state.abortedAt = nowIso();
-			state.updatedAt = state.abortedAt;
-			pi.appendEntry("harness-policy-state", state);
-			return {
-				message: {
-					customType: "harness-policy-aborted",
-					display: true,
-					content: [
-						"Harness run aborted safely.",
-						"Mutating tools are now blocked until a new approved plan is attached.",
-						'Next step: /harness-plan "<task>"',
-					].join("\n"),
-				},
-				systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nAbort lock active. Mutating tools must remain blocked until a new approved plan is attached.`,
-			};
-		}
-
-		const nextPhase = inferHarnessPhase(entries, userPrompt);
-		const planSignal = hasApprovedPlanSignal(userPrompt, entries);
-
-		const transitionBlock = getPolicyTransitionBlock(userPrompt, entries);
-		if (transitionBlock.blocked) {
-			return {
-				message: {
-					customType: "harness-policy-violation",
-					display: true,
-					content:
-						transitionBlock.message ?? "Policy gate blocked this command.",
-				},
-			};
-		}
-
-		if (nextPhase === "plan") {
-			state.approvedPlan = false;
-			state.planId = null;
-		}
-
-		if (nextPhase === "execute" && !state.approvedPlan && !planSignal) {
-			const runCtx = getLatestRunContext(entries);
-			if (runCtx?.plan_ready) {
-				state.approvedPlan = true;
-				state.planId = runCtx.plan_id ?? state.planId;
-			}
-		}
+async function handlePolicySessionStart(
+	pi: ExtensionAPI,
+	stateRef: { current: PolicyState },
+	ctx: any,
+): Promise<void> {
+	stateRef.current = getLatestPolicyStateFull(ctx);
+	const booted = await bootstrapHarnessSubprocessFromEnv(pi, ctx);
+	if (booted) {
+		stateRef.current = getLatestPolicyStateFull(ctx);
+	}
+}
 
-		if (planSignal) {
-			state.approvedPlan = true;
-			const planMatch = userPrompt.match(
-				/plan[_-]?id["'\s:=]+([A-Za-z0-9._:-]+)/i,
-			);
-			state.planId = planMatch?.[1] ?? state.planId;
-			state.aborted = false;
-			state.abortReason = null;
-			state.abortedAt = null;
-		}
-		state.budgetBypass = bootstrapPrompt;
-		state.phase = nextPhase;
+async function handlePolicyBeforeAgentStart(args: {
+	pi: ExtensionAPI;
+	stateRef: { current: PolicyState };
+	event: any;
+	ctx: any;
+}) {
+	const { pi, stateRef, event, ctx } = args;
+	const userPrompt = userVisiblePromptSlice(event.prompt);
+	await bootstrapHarnessSubprocessFromEnv(pi, ctx);
+	const entries = ctx.sessionManager.getEntries();
+	const state = getLatestPolicyStateFull(ctx);
+	const bootstrapPrompt = isHarnessBootstrapPrompt(userPrompt);
+	const abortSignal = hasHarnessAbortSignal(userPrompt);
+
+	if (bootstrapPrompt) {
+		state.phase = "execute";
+		state.approvedPlan = true;
+		stateRef.current.planId = null;
+		state.budgetBypass = true;
+		state.aborted = false;
+		state.abortReason = null;
+		state.abortedAt = null;
 		state.updatedAt = nowIso();
-		pi.appendEntry("harness-policy-state", state);
-
-		const planPhaseHint =
-			state.phase === "plan"
-				? "\nPlan phase: scouts (parallel) → decompose → hypothesis (sequential) → implementation-researcher + stack-researcher (parallel) → execution-plan-author → validate-plan-dag → debate eligibility + Review Gate → approve_plan → create_plan (YAML plan-packet.yaml). Post-execute: /harness-review."
-				: "";
+		stateRef.current = state;
+		pi.appendEntry("harness-policy-state", stateRef.current);
+		return {
+			systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nPhase=${state.phase}; ApprovedPlan=${state.approvedPlan}; PlanId=${state.planId ?? "none"}; Aborted=${state.aborted}; Bootstrap=harness-setup.`,
+		};
+	}
 
+	if (abortSignal) {
+		stateRef.current.phase = "plan";
+		stateRef.current.approvedPlan = false;
+		stateRef.current.planId = null;
+		stateRef.current.budgetBypass = false;
+		stateRef.current.aborted = true;
+		state.abortReason = "harness-abort command";
+		stateRef.current.abortedAt = nowIso();
+		stateRef.current.updatedAt = stateRef.current.abortedAt;
+		stateRef.current = state;
+		pi.appendEntry("harness-policy-state", stateRef.current);
 		return {
-			systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nPhase=${state.phase}; ApprovedPlan=${state.approvedPlan}; PlanId=${state.planId ?? "none"}; Aborted=${state.aborted}.${planPhaseHint}`,
+			message: {
+				customType: "harness-policy-aborted",
+				display: true,
+				content: [
+					"Harness run aborted safely.",
+					"Mutating tools are now blocked until a new approved plan is attached.",
+					'Next step: /harness-plan "<task>"',
+				].join("\n"),
+			},
+			systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nAbort lock active. Mutating tools must remain blocked until a new approved plan is attached.`,
 		};
-	});
+	}
 
-	pi.on("tool_call", async (event, ctx) => {
-		state = getLatestPolicyStateFull(ctx);
-		const entries = ctx.sessionManager.getEntries();
-		const projectRoot = process.cwd();
-		const sessionId = ctx.sessionManager.getSessionId();
-
-		if (isHarnessAgtPolicyEnabled()) {
-			return evaluateAgtHarnessToolCall({
-				moduleUrl: MODULE_URL,
-				toolName: event.toolName,
-				toolInput: event.input as Record<string, unknown>,
-				policyState: state,
-				entries,
-				sessionId,
-				projectRoot,
-			});
-		}
+	const nextPhase = inferHarnessPhase(entries, userPrompt);
+	const planSignal = hasApprovedPlanSignal(userPrompt, entries);
+	const transitionBlock = getPolicyTransitionBlock(userPrompt, entries);
+	if (transitionBlock.blocked) {
+		return {
+			message: {
+				customType: "harness-policy-violation",
+				display: true,
+				content: transitionBlock.message ?? "Policy gate blocked this command.",
+			},
+		};
+	}
 
+	if (nextPhase === "plan") {
+		stateRef.current.approvedPlan = false;
+		stateRef.current.planId = null;
+	}
+	if (nextPhase === "execute" && !state.approvedPlan && !planSignal) {
 		const runCtx = getLatestRunContext(entries);
-
-		if (MUTATING_TOOLS.has(event.toolName)) {
-			const decision = await isPlanPhaseAllowedMutation(
-				event.toolName,
-				event.input as Record<string, unknown>,
-				state.phase,
-				runCtx,
-				projectRoot,
-				{
-					aborted: state.aborted,
-					entries,
-					ownerSessionId: runCtx?.owner_pi_session_id,
-					currentSessionId: sessionId,
-				},
-			);
-			if (!decision.allowed) {
-				return { block: true, reason: decision.reason };
-			}
-			return undefined;
+		if (runCtx?.plan_ready) {
+			state.approvedPlan = true;
+			state.planId = runCtx.plan_id ?? state.planId;
 		}
+	}
+	if (planSignal) {
+		state.approvedPlan = true;
+		const planMatch = userPrompt.match(
+			/plan[_-]?id["'\s:=]+([A-Za-z0-9._:-]+)/i,
+		);
+		state.planId = planMatch?.[1] ?? state.planId;
+		state.aborted = false;
+		state.abortReason = null;
+		state.abortedAt = null;
+	}
+	state.budgetBypass = bootstrapPrompt;
+	state.phase = nextPhase;
+	state.updatedAt = nowIso();
+	stateRef.current = state;
+	pi.appendEntry("harness-policy-state", stateRef.current);
+
+	const planPhaseHint =
+		state.phase === "plan"
+			? "\nPlan phase: scouts (parallel) → decompose → hypothesis (sequential) → implementation-researcher + stack-researcher (parallel) → execution-plan-author → validate-plan-dag → debate eligibility + Review Gate → approve_plan → create_plan (YAML plan-packet.yaml). Post-execute: /harness-review."
+			: "";
+	return {
+		systemPrompt: `${event.systemPrompt}\n\n[PolicyGate]\nPhase=${state.phase}; ApprovedPlan=${state.approvedPlan}; PlanId=${state.planId ?? "none"}; Aborted=${state.aborted}.${planPhaseHint}`,
+	};
+}
 
-		if (event.toolName === "bash") {
-			const command = String(event.input.command ?? "");
-			const { isMutatingBash } = await import(
-				"../lib/harness-context-mode-policy.js"
-			);
-			if (!isMutatingBash(command)) return undefined;
-			if (state.aborted) {
-				return {
-					block: true,
-					reason:
-						"policy-gate: mutating bash command blocked because harness-abort lock is active. Attach a new approved plan first.",
-				};
-			}
-			if (state.phase !== "execute" && state.phase !== "merge") {
-				return {
-					block: true,
-					reason: `policy-gate: mutating bash command blocked in phase '${state.phase}'.`,
-				};
-			}
-		}
+async function handlePolicyToolCall(args: {
+	stateRef: { current: PolicyState };
+	event: any;
+	ctx: any;
+}) {
+	const state = getLatestPolicyStateFull(args.ctx);
+	args.stateRef.current = state;
+	const entries = args.ctx.sessionManager.getEntries();
+	const projectRoot = process.cwd();
+	const sessionId = args.ctx.sessionManager.getSessionId();
+
+	if (isHarnessAgtPolicyEnabled()) {
+		return evaluateAgtHarnessToolCall({
+			moduleUrl: MODULE_URL,
+			toolName: args.event.toolName,
+			toolInput: args.event.input as Record<string, unknown>,
+			policyState: state,
+			entries,
+			sessionId,
+			projectRoot,
+		});
+	}
 
-		const { evaluateContextModeMutation } = await import(
-			"../lib/harness-context-mode-policy.js"
-		);
-		const ctxDecision = evaluateContextModeMutation(
-			event.toolName,
-			event.input as Record<string, unknown>,
+	const runCtx = getLatestRunContext(entries);
+	if (MUTATING_TOOLS.has(args.event.toolName)) {
+		const decision = await isPlanPhaseAllowedMutation(
+			args.event.toolName,
+			args.event.input as Record<string, unknown>,
 			state.phase,
+			runCtx,
+			projectRoot,
 			{
 				aborted: state.aborted,
-				budgetBypass: state.budgetBypass,
+				entries,
+				ownerSessionId: runCtx?.owner_pi_session_id,
+				currentSessionId: sessionId,
 			},
 		);
-		if (ctxDecision.blocked) {
-			return { block: true, reason: ctxDecision.reason };
+		if (!decision.allowed) return { block: true, reason: decision.reason };
+		return undefined;
+	}
+
+	if (args.event.toolName === "bash") {
+		const command = String(args.event.input.command ?? "");
+		const { isMutatingBash } = await import(
+			"../lib/harness-context-mode-policy.js"
+		);
+		if (!isMutatingBash(command)) return undefined;
+		if (state.aborted) {
+			return {
+				block: true,
+				reason:
+					"policy-gate: mutating bash command blocked because harness-abort lock is active. Attach a new approved plan first.",
+			};
+		}
+		if (state.phase !== "execute" && state.phase !== "merge") {
+			return {
+				block: true,
+				reason: `policy-gate: mutating bash command blocked in phase '${state.phase}'.`,
+			};
 		}
+	}
 
-		return undefined;
-	});
+	const { evaluateContextModeMutation } = await import(
+		"../lib/harness-context-mode-policy.js"
+	);
+	const ctxDecision = evaluateContextModeMutation(
+		args.event.toolName,
+		args.event.input as Record<string, unknown>,
+		state.phase,
+		{ aborted: state.aborted, budgetBypass: state.budgetBypass },
+	);
+	if (ctxDecision.blocked) return { block: true, reason: ctxDecision.reason };
+	return undefined;
+}
 
-	pi.on("tool_result", async (event, ctx) => {
-		if (event.isError) return;
-		if (event.toolName !== "write" && event.toolName !== "edit") return;
+async function handlePolicyToolResult(args: {
+	pi: ExtensionAPI;
+	stateRef: { current: PolicyState };
+	event: any;
+	ctx: any;
+	appendPolicyState: (next: PolicyState) => void;
+}): Promise<void> {
+	const { pi, stateRef, event, ctx, appendPolicyState } = args;
+	if (event.isError) return;
+	if (event.toolName !== "write" && event.toolName !== "edit") return;
+
+	const entries = ctx.sessionManager.getEntries();
+	const state = getLatestPolicyStateFull(ctx);
+	stateRef.current = state;
+	const projectRoot = process.cwd();
+	const runCtx = getLatestRunContext(entries);
+	if (!runCtx) return;
+
+	const target = extractWritePathFromToolInput(
+		event.input as Record<string, unknown>,
+	);
+	if (!target) return;
+	const scoped = await isPlanPhaseScopedWrite(target, runCtx, projectRoot);
+	if (!scoped) return;
+
+	const planPath = normalizeHarnessPath(target, projectRoot);
+	const packet = await readPlanPacketFromPath(planPath);
+	const validation = validatePlanPacket(packet);
+	if (!validation.valid || !packet?.plan_id) return;
+	if (!isHarnessAutoSession(entries)) return;
+
+	state.phase = "execute";
+	state.approvedPlan = true;
+	state.planId = packet.plan_id;
+	state.aborted = false;
+	state.abortReason = null;
+	state.abortedAt = null;
+	state.updatedAt = nowIso();
+	stateRef.current = state;
+	appendPolicyState(state);
+
+	runCtx.plan_ready = true;
+	runCtx.plan_id = packet.plan_id;
+	runCtx.phase = "execute";
+	runCtx.updated_at = nowIso();
+	pi.appendEntry("harness-run-context", runCtx);
+	void saveRunContextToDisk(runCtx);
+	void saveProjectActiveRun(runCtx);
+}
 
-		const entries = ctx.sessionManager.getEntries();
-		state = getLatestPolicyStateFull(ctx);
-		const projectRoot = process.cwd();
-		const runCtx = getLatestRunContext(entries);
-		if (!runCtx) return;
+export default function policyGate(pi: ExtensionAPI) {
+	if (!isHarnessProjectEnabled()) return;
+	const stateRef: { current: PolicyState } = { current: defaultState() };
 
-		const target = extractWritePathFromToolInput(
-			event.input as Record<string, unknown>,
-		);
-		if (!target) return;
-		const scoped = await isPlanPhaseScopedWrite(target, runCtx, projectRoot);
-		if (!scoped) return;
+	const appendPolicyState = (next: PolicyState): void => {
+		stateRef.current = next;
+		pi.appendEntry("harness-policy-state", stateRef.current);
+	};
 
-		const planPath = normalizeHarnessPath(target, projectRoot);
-		const packet = await readPlanPacketFromPath(planPath);
-		const validation = validatePlanPacket(packet);
-		if (!validation.valid || !packet?.plan_id) return;
+	pi.on("session_start", async (_event, ctx) => {
+		await handlePolicySessionStart(pi, stateRef, ctx);
+	});
 
-		if (isHarnessAutoSession(entries)) {
-			state.phase = "execute";
-			state.approvedPlan = true;
-			state.planId = packet.plan_id;
-			state.aborted = false;
-			state.abortReason = null;
-			state.abortedAt = null;
-			state.updatedAt = nowIso();
-			appendPolicyState(state);
-
-			runCtx.plan_ready = true;
-			runCtx.plan_id = packet.plan_id;
-			runCtx.phase = "execute";
-			runCtx.updated_at = nowIso();
-			pi.appendEntry("harness-run-context", runCtx);
-			void saveRunContextToDisk(runCtx);
-			void saveProjectActiveRun(runCtx);
-		}
+	pi.on("before_agent_start", async (event, ctx) =>
+		handlePolicyBeforeAgentStart({
+			pi,
+			stateRef,
+			event,
+			ctx,
+		}),
+	);
+
+	pi.on("tool_call", async (event, ctx) =>
+		handlePolicyToolCall({
+			stateRef,
+			event,
+			ctx,
+		}),
+	);
+
+	pi.on("tool_result", async (event, ctx) => {
+		await handlePolicyToolResult({
+			pi,
+			stateRef,
+			event,
+			ctx,
+			appendPolicyState,
+		});
 	});
 
 	pi.registerCommand("harness-abort", {
 		description: "Safely abort current harness run and reset to plan phase",
 		handler: async (args, ctx) => {
 			const reason = args.trim();
-			state.phase = "plan";
-			state.approvedPlan = false;
-			state.planId = null;
-			state.budgetBypass = false;
-			state.aborted = true;
-			state.abortReason = reason.length > 0 ? reason : "manual abort";
-			state.abortedAt = nowIso();
-			state.updatedAt = state.abortedAt;
-			pi.appendEntry("harness-policy-state", state);
+			stateRef.current.phase = "plan";
+			stateRef.current.approvedPlan = false;
+			stateRef.current.planId = null;
+			stateRef.current.budgetBypass = false;
+			stateRef.current.aborted = true;
+			stateRef.current.abortReason =
+				reason.length > 0 ? reason : "manual abort";
+			stateRef.current.abortedAt = nowIso();
+			stateRef.current.updatedAt = stateRef.current.abortedAt;
+			pi.appendEntry("harness-policy-state", stateRef.current);
 
 			const runCtx = getLatestRunContext(ctx.sessionManager.getEntries());
 			if (runCtx) {
@@ -391,7 +432,7 @@ export default function policyGate(pi: ExtensionAPI) {
 				runCtx.next_recommended_command = runCtx.task_summary
 					? `/harness-plan "${runCtx.task_summary}"`
 					: '/harness-plan "<task>"';
-				runCtx.updated_at = state.abortedAt ?? nowIso();
+				runCtx.updated_at = stateRef.current.abortedAt ?? nowIso();
 				pi.appendEntry("harness-run-context", runCtx);
 				void saveRunContextToDisk(runCtx);
 				void saveProjectActiveRun(runCtx);
@@ -401,8 +442,8 @@ export default function policyGate(pi: ExtensionAPI) {
 				"Harness run aborted safely.",
 				"  phase: plan",
 				"  approvedPlan: false",
-				`  abortReason: ${state.abortReason}`,
-				`  abortedAt: ${state.abortedAt}`,
+				`  abortReason: ${stateRef.current.abortReason}`,
+				`  abortedAt: ${stateRef.current.abortedAt}`,
 				"Mutating tools are now blocked until a new approved plan is attached.",
 				'Next command: /harness-plan "<task>"',
 			];

package/.pi/extensions/sentrux-rules-sync.ts

@@ -6,6 +6,7 @@ import { spawn } from "node:child_process";
 import type { ExtensionAPI } from "@earendil-works/pi-coding-agent";
 import { resolveHarnessScript } from "../lib/harness-paths.js";
 import { isHarnessProjectEnabled } from "../lib/harness-project-config.js";
+import { completeStrictFlag } from "../lib/harness-slash-completions.js";
 
 function resolveSyncScript(): string {
 	return resolveHarnessScript(
@@ -81,6 +82,7 @@ export default function sentruxRulesSync(pi: ExtensionAPI) {
 	pi.registerCommand("harness-sentrux-sync", {
 		description:
 			"Regenerate .sentrux/rules.toml from harness architecture manifest",
+		getArgumentCompletions: completeStrictFlag,
 		handler: async (_args, ctx) => {
 			const strict = _args.includes("--strict");
 			const { code, output } = await runSync(

package/.pi/extensions/soundboard.ts

@@ -387,6 +387,53 @@ function readAgentEndOutcome(event: unknown): {
 	return { status: "completed" };
 }
 
+function registerSoundsCommand(pi: ExtensionAPI): void {
+	pi.registerCommand("sounds", {
+		description: "Show pi-sounds status: loaded sounds, player",
+		handler: async (_args: string, ctx: ExtensionCommandContext) => {
+			const soundCtx = await getSoundContext();
+			if (!soundCtx) {
+				const msg = "pi-sounds: no .pi/sounds/project-sounds.json found";
+				if (ctx.hasUI) ctx.ui.notify(msg, "warning");
+				else
+					pi.sendMessage({
+						customType: "pi-sounds",
+						content: msg,
+						display: true,
+					});
+				return;
+			}
+
+			const player = await getPlayer();
+			const playerName = player ? player.cmd : "none";
+			const total = SOUND_CATEGORIES.reduce(
+				(sum, c) => sum + soundCtx.soundsByCategory[c].length,
+				0,
+			);
+			const lines = [
+				`pi-sounds status:`,
+				`  player: ${playerName}`,
+				`  sounds: ${total} files in ${soundCtx.soundsDirectory}`,
+				`  randomize: ${soundCtx.randomizeSounds ? "yes" : "no"}`,
+				`  categories:`,
+			];
+			for (const cat of SOUND_CATEGORIES) {
+				const files = soundCtx.soundsByCategory[cat];
+				lines.push(
+					`    ${cat}: ${files.length > 0 ? files.map((f) => basename(f)).join(", ") : "(none)"}`,
+				);
+			}
+			if (ctx.hasUI) ctx.ui.notify(lines.join("\n"), "info");
+			else
+				pi.sendMessage({
+					customType: "pi-sounds",
+					content: lines.join("\n"),
+					display: true,
+				});
+		},
+	});
+}
+
 // ── Extension ─────────────────────────────────────────────────────
 
 export default function piSoundsExtension(pi: ExtensionAPI): void {
@@ -482,52 +529,5 @@ export default function piSoundsExtension(pi: ExtensionAPI): void {
 		hadErrorInTurn = false;
 	});
 
-	// ── Command ────────────────────────────────────────────────────
-
-	pi.registerCommand("sounds", {
-		description: "Show pi-sounds status: loaded sounds, player",
-		handler: async (_args: string, ctx: ExtensionCommandContext) => {
-			const soundCtx = await getSoundContext();
-			if (!soundCtx) {
-				const msg = "pi-sounds: no .pi/sounds/project-sounds.json found";
-				if (ctx.hasUI) ctx.ui.notify(msg, "warning");
-				else
-					pi.sendMessage({
-						customType: "pi-sounds",
-						content: msg,
-						display: true,
-					});
-				return;
-			}
-
-			const player = await getPlayer();
-			const playerName = player ? player.cmd : "none";
-			const total = SOUND_CATEGORIES.reduce(
-				(sum, c) => sum + soundCtx.soundsByCategory[c].length,
-				0,
-			);
-
-			const lines = [
-				`pi-sounds status:`,
-				`  player: ${playerName}`,
-				`  sounds: ${total} files in ${soundCtx.soundsDirectory}`,
-				`  randomize: ${soundCtx.randomizeSounds ? "yes" : "no"}`,
-				`  categories:`,
-			];
-			for (const cat of SOUND_CATEGORIES) {
-				const files = soundCtx.soundsByCategory[cat];
-				lines.push(
-					`    ${cat}: ${files.length > 0 ? files.map((f) => basename(f)).join(", ") : "(none)"}`,
-				);
-			}
-
-			if (ctx.hasUI) ctx.ui.notify(lines.join("\n"), "info");
-			else
-				pi.sendMessage({
-					customType: "pi-sounds",
-					content: lines.join("\n"),
-					display: true,
-				});
-		},
-	});
+	registerSoundsCommand(pi);
 }