pi-crew 0.9.53 → 0.9.55

package/src/extension/team-tool/dispatch/automate.ts

@@ -0,0 +1,80 @@
+/**
+ * API-5 facade dispatch — Automate domain router.
+ *
+ * Actions: schedule, scheduled, anchor, auto-summarize, auto_boomerang, api.
+ *
+ * Inline cases (anchor, auto-summarize/auto_boomerang) are moved verbatim from
+ * the former handleTeamTool switch.
+ */
+
+import type { TeamToolParamsValue } from "../../../schema/team-tool-schema.ts";
+import { formatActionSuggestion } from "../../action-suggestions.ts";
+import type { PiTeamsToolResult } from "../../tool-result.ts";
+import { handleAnchorAccumulate, handleAnchorClear, handleAnchorSet, handleAnchorStatus } from "../anchor.ts";
+import { handleApi } from "../api.ts";
+import {
+	createAutoSummarizeService,
+	handleAutoSummarizeConfig,
+	handleAutoSummarizeOff,
+	handleAutoSummarizeOn,
+	handleAutoSummarizeStatus,
+} from "../auto-summarize.ts";
+import { result, type TeamContext } from "../context.ts";
+import { handleListScheduled, handleSchedule } from "../handle-schedule.ts";
+
+export async function handleAutomateDomain(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	switch (params.action) {
+		case "api":
+			return handleApi(params, ctx);
+		case "schedule":
+			return handleSchedule(params, ctx);
+		case "scheduled":
+			return handleListScheduled(params, ctx);
+		case "anchor": {
+			const subAction = typeof params.config?.subAction === "string" ? params.config.subAction : "status";
+			switch (subAction) {
+				case "set":
+					return handleAnchorSet(params, ctx);
+				case "clear":
+					return handleAnchorClear(params, ctx);
+				case "accumulate":
+					return handleAnchorAccumulate(params, ctx);
+				default:
+					return handleAnchorStatus(params, ctx);
+			}
+		}
+		case "auto-summarize":
+		case "auto_boomerang": {
+			const subAction =
+				typeof params.config?.subAction === "string"
+					? params.config.subAction
+					: (params.action as string) === "auto_boomerang"
+						? "toggle"
+						: "status";
+			switch (subAction) {
+				case "on":
+					return handleAutoSummarizeOn(params, ctx);
+				case "off":
+					return handleAutoSummarizeOff(params, ctx);
+				case "config":
+					return handleAutoSummarizeConfig(params, ctx);
+				case "toggle": {
+					const service = createAutoSummarizeService();
+					service.toggle();
+					return result(`Auto-summarize ${service.isEnabled() ? "enabled" : "disabled"}.`, {
+						action: "auto-summarize",
+						status: "ok",
+					});
+				}
+				default:
+					return handleAutoSummarizeStatus(params, ctx);
+			}
+		}
+		default:
+			return result(
+				`Unhandled automate-domain action: ${params.action}${formatActionSuggestion(String(params.action ?? ""))}`,
+				{ action: "unknown", status: "error" },
+				true,
+			);
+	}
+}

package/src/extension/team-tool/dispatch/control.ts

@@ -0,0 +1,42 @@
+/**
+ * API-5 facade dispatch — Control domain router.
+ *
+ * Actions: cancel, invalidate, respond, cleanup, prune, forget, doctor.
+ */
+
+import type { TeamToolParamsValue } from "../../../schema/team-tool-schema.ts";
+import { cacheControlDepsFromContext, handleInvalidate } from "../../team-tool.ts";
+import type { PiTeamsToolResult } from "../../tool-result.ts";
+import { handleCancel } from "../cancel.ts";
+import { result, type TeamContext } from "../context.ts";
+import { handleDoctor } from "../doctor.ts";
+import { handleCleanup, handleForget, handlePrune } from "../lifecycle-actions.ts";
+import { handleRespond } from "../respond.ts";
+
+export async function handleControlDomain(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	switch (params.action) {
+		case "doctor":
+			return handleDoctor(ctx, params);
+		case "cleanup":
+			return handleCleanup(params, ctx);
+		case "prune":
+			return handlePrune(params, ctx);
+		case "forget":
+			return handleForget(params, ctx);
+		case "cancel":
+			return handleCancel(params, ctx, cacheControlDepsFromContext(ctx));
+		case "invalidate":
+			return handleInvalidate(params, ctx);
+		case "respond":
+			return handleRespond(params, ctx);
+		default:
+			return result(
+				`Unhandled control-domain action: ${params.action}`,
+				{
+					action: "unknown",
+					status: "error",
+				},
+				true,
+			);
+	}
+}

package/src/extension/team-tool/dispatch/index.ts

@@ -0,0 +1,95 @@
+/**
+ * API-5 facade dispatch — domain router registry.
+ *
+ * `domainForAction(action)` maps each of the 54 action strings to one of 5
+ * domains. `handleTeamTool` (in team-tool.ts) calls this to pick the right
+ * domain router, preserving the exact same public API and zero caller changes.
+ *
+ * 54→5 mapping:
+ *   run     (9):  run, parallel, plan, orchestrate, resume, retry, wait, steer, goal
+ *   status  (16): status, list, get, events, artifacts, summary, graph, search,
+ *                 health, worktrees, checkpoint, cache, explain, onboard, recommend, help
+ *   control (7):  cancel, invalidate, respond, cleanup, prune, forget, doctor
+ *   manage  (16): create, update, delete, init, config, validate, autonomy, settings,
+ *                 workflow-create/get/list/save/delete, import, imports, export
+ *   automate(6):  schedule, scheduled, anchor, auto-summarize, auto_boomerang, api
+ */
+import type { TeamDomain } from "../../../schema/team-tool-schema.ts";
+import { handleAutomateDomain } from "./automate.ts";
+import { handleControlDomain } from "./control.ts";
+import { handleManageDomain } from "./manage.ts";
+import { handleRunDomain } from "./run.ts";
+import { handleStatusDomain } from "./status.ts";
+
+export { handleAutomateDomain, handleControlDomain, handleManageDomain, handleRunDomain, handleStatusDomain };
+
+const ACTION_TO_DOMAIN: Record<string, TeamDomain> = {
+	// run domain (9)
+	run: "run",
+	parallel: "run",
+	plan: "run",
+	orchestrate: "run",
+	resume: "run",
+	retry: "run",
+	wait: "run",
+	steer: "run",
+	goal: "run",
+
+	// status domain (16)
+	status: "status",
+	list: "status",
+	get: "status",
+	events: "status",
+	artifacts: "status",
+	summary: "status",
+	graph: "status",
+	search: "status",
+	health: "status",
+	worktrees: "status",
+	checkpoint: "status",
+	cache: "status",
+	explain: "status",
+	onboard: "status",
+	recommend: "status",
+	help: "status",
+
+	// control domain (7)
+	cancel: "control",
+	invalidate: "control",
+	respond: "control",
+	cleanup: "control",
+	prune: "control",
+	forget: "control",
+	doctor: "control",
+
+	// manage domain (16)
+	create: "manage",
+	update: "manage",
+	delete: "manage",
+	init: "manage",
+	config: "manage",
+	validate: "manage",
+	autonomy: "manage",
+	settings: "manage",
+	"workflow-create": "manage",
+	"workflow-get": "manage",
+	"workflow-list": "manage",
+	"workflow-save": "manage",
+	"workflow-delete": "manage",
+	import: "manage",
+	imports: "manage",
+	export: "manage",
+
+	// automate domain (6)
+	schedule: "automate",
+	scheduled: "automate",
+	anchor: "automate",
+	"auto-summarize": "automate",
+	auto_boomerang: "automate",
+	api: "automate",
+};
+
+/** Map an action string to its domain. Returns undefined for unknown actions. */
+export function domainForAction(action: string): TeamDomain | undefined {
+	return ACTION_TO_DOMAIN[action];
+}

package/src/extension/team-tool/dispatch/manage.ts

@@ -0,0 +1,161 @@
+/**
+ * API-5 facade dispatch — Manage domain router.
+ *
+ * Actions: create, update, delete, init, config, validate, autonomy, settings,
+ * workflow-create, workflow-get, workflow-list, workflow-save, workflow-delete,
+ * import, imports, export.
+ *
+ * Inline cases (init, autonomy, config, validate) are moved verbatim from the
+ * former handleTeamTool switch.
+ */
+import { loadConfig, updateAutonomousConfig, updateConfig } from "../../../config/config.ts";
+import type { TeamToolParamsValue } from "../../../schema/team-tool-schema.ts";
+import { formatActionSuggestion } from "../../action-suggestions.ts";
+import { handleCreate, handleDelete, handleUpdate } from "../../management.ts";
+import { initializeProject } from "../../project-init.ts";
+import type { PiTeamsToolResult } from "../../tool-result.ts";
+import { formatValidationReport, validateResources } from "../../validate-resources.ts";
+import { autonomousPatchFromConfig, configPatchFromConfig, formatAutonomyStatus } from "../config-patch.ts";
+import { configRecord, result, type TeamContext } from "../context.ts";
+import { handleSettings } from "../handle-settings.ts";
+import { handleExport, handleImport, handleImports } from "../lifecycle-actions.ts";
+import {
+	handleWorkflowCreate,
+	handleWorkflowDelete,
+	handleWorkflowGet,
+	handleWorkflowList,
+	handleWorkflowSave,
+} from "../workflow-manage.ts";
+
+export async function handleManageDomain(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	switch (params.action) {
+		case "init": {
+			const cfg = configRecord(params.config);
+			const ignoreMethod =
+				typeof cfg.ignoreMethod === "string" && (cfg.ignoreMethod === "gitignore" || cfg.ignoreMethod === "exclude")
+					? cfg.ignoreMethod
+					: undefined;
+			const initialized = initializeProject(ctx.cwd, {
+				copyBuiltins: cfg.copyBuiltins === true,
+				overwrite: cfg.overwrite === true,
+				configScope:
+					cfg.configScope === "project" || cfg.scope === "project"
+						? "project"
+						: cfg.configScope === "none" || cfg.scope === "none"
+							? "none"
+							: "global",
+				ignoreMethod,
+			});
+			return result(
+				[
+					"Initialized pi-crew project layout.",
+					"Directories:",
+					...(initialized.createdDirs.length ? initialized.createdDirs.map((dir) => `- created ${dir}`) : ["- already existed"]),
+					"Copied builtin files:",
+					...(initialized.copiedFiles.length ? initialized.copiedFiles.map((file) => `- ${file}`) : ["- (none)"]),
+					...(initialized.skippedFiles.length
+						? ["Skipped existing files:", ...initialized.skippedFiles.map((file) => `- ${file}`)]
+						: []),
+					`Config: ${initialized.configPath || "(none)"} (${initialized.configScope}${initialized.configCreated ? "; created" : initialized.configSkipped ? "; already existed" : "; unchanged"})`,
+					`Ignore: ${initialized.gitignorePath} (${initialized.gitignoreUpdated ? "updated" : "already configured"})`,
+				].join("\n"),
+				{ action: "init", status: "ok" },
+			);
+		}
+		case "autonomy": {
+			const patch = autonomousPatchFromConfig(params.config);
+			const shouldUpdate = Object.values(patch).some((value) => value !== undefined);
+			if (!shouldUpdate) {
+				const loaded = loadConfig(ctx.cwd);
+				return result(
+					formatAutonomyStatus(loaded.config.autonomous, loaded.path, false),
+					{
+						action: "autonomy",
+						status: loaded.error ? "error" : "ok",
+					},
+					Boolean(loaded.error),
+				);
+			}
+			try {
+				const saved = updateAutonomousConfig(patch);
+				return result(formatAutonomyStatus(saved.config.autonomous, saved.path, true), { action: "autonomy", status: "ok" });
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				return result(message, { action: "autonomy", status: "error" }, true);
+			}
+		}
+		case "config": {
+			const patch = configPatchFromConfig(params.config);
+			const cfg = configRecord(params.config);
+			const unsetPaths = Array.isArray(cfg.unset)
+				? cfg.unset.filter((entry): entry is string => typeof entry === "string")
+				: typeof cfg.unset === "string"
+					? [cfg.unset]
+					: [];
+			const shouldUpdate = Object.values(patch).some((value) => value !== undefined) || unsetPaths.length > 0;
+			if (shouldUpdate) {
+				try {
+					const saved = updateConfig(patch, {
+						cwd: ctx.cwd,
+						scope: cfg.scope === "project" ? "project" : "user",
+						unsetPaths,
+					});
+					return result(
+						["Updated pi-crew config.", `Path: ${saved.path}`, "Effective config:", JSON.stringify(saved.config, null, 2)].join(
+							"\n",
+						),
+						{ action: "config", status: "ok" },
+					);
+				} catch (error) {
+					const message = error instanceof Error ? error.message : String(error);
+					return result(message, { action: "config", status: "error" }, true);
+				}
+			}
+			const loaded = loadConfig(ctx.cwd);
+			const lines = [
+				"pi-crew config:",
+				`Path: ${loaded.path}`,
+				`Status: ${loaded.error ? `error: ${loaded.error}` : "ok"}`,
+				"Effective config:",
+				JSON.stringify(loaded.config, null, 2),
+				"Schema: package export ./schema.json",
+			];
+			return result(lines.join("\n"), { action: "config", status: loaded.error ? "error" : "ok" }, Boolean(loaded.error));
+		}
+		case "validate": {
+			const report = validateResources(ctx.cwd);
+			const hasErrors = report.issues.some((issue) => issue.level === "error");
+			return result(formatValidationReport(report), { action: "validate", status: hasErrors ? "error" : "ok" }, hasErrors);
+		}
+		case "export":
+			return handleExport(params, ctx);
+		case "import":
+			return handleImport(params, ctx);
+		case "imports":
+			return handleImports(params, ctx);
+		case "settings":
+			return handleSettings(params, ctx);
+		case "create":
+			return handleCreate(params, ctx);
+		case "update":
+			return handleUpdate(params, ctx);
+		case "delete":
+			return handleDelete(params, ctx);
+		case "workflow-create":
+			return handleWorkflowCreate(params, ctx);
+		case "workflow-get":
+			return handleWorkflowGet(params, ctx);
+		case "workflow-list":
+			return handleWorkflowList(params, ctx);
+		case "workflow-save":
+			return handleWorkflowSave(params, ctx);
+		case "workflow-delete":
+			return handleWorkflowDelete(params, ctx);
+		default:
+			return result(
+				`Unhandled manage-domain action: ${params.action}${formatActionSuggestion(String(params.action ?? ""))}`,
+				{ action: "unknown", status: "error" },
+				true,
+			);
+	}
+}

package/src/extension/team-tool/dispatch/run.ts

@@ -0,0 +1,53 @@
+/**
+ * API-5 facade dispatch — Run domain router.
+ *
+ * Actions: run, parallel, plan, orchestrate, resume, retry, wait, steer, goal.
+ *
+ * Handlers are already extracted into src/extension/team-tool/*.ts; this file
+ * just routes the action labels. Local handlers (handleResume, handleSteer,
+ * handleWait, cacheControlDepsFromContext) are imported from the parent
+ * team-tool.ts module via ESM live bindings (circular import is safe — all
+ * references are resolved at call time, not at module-init).
+ */
+
+import type { TeamToolParamsValue } from "../../../schema/team-tool-schema.ts";
+import { cacheControlDepsFromContext, handleResume, handleRun, handleSteer, handleWait } from "../../team-tool.ts";
+import type { PiTeamsToolResult } from "../../tool-result.ts";
+import { handleRetry } from "../cancel.ts";
+import { result, type TeamContext } from "../context.ts";
+import { handleGoal } from "../goal.ts";
+import { handleOrchestrate } from "../orchestrate.ts";
+import { handleParallel } from "../parallel-dispatch.ts";
+import { handlePlan } from "../plan.ts";
+
+export async function handleRunDomain(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	switch (params.action) {
+		case "run":
+			return handleRun(params, ctx);
+		case "parallel":
+			return handleParallel(params, ctx);
+		case "plan":
+			return handlePlan(params, ctx);
+		case "orchestrate":
+			return handleOrchestrate(params, ctx);
+		case "resume":
+			return handleResume(params, ctx);
+		case "retry":
+			return handleRetry(params, ctx, cacheControlDepsFromContext(ctx));
+		case "wait":
+			return handleWait(params, ctx);
+		case "steer":
+			return handleSteer(params, ctx);
+		case "goal":
+			return handleGoal(params, ctx);
+		default:
+			return result(
+				`Unhandled run-domain action: ${params.action}`,
+				{
+					action: "unknown",
+					status: "error",
+				},
+				true,
+			);
+	}
+}

package/src/extension/team-tool/dispatch/status.ts

@@ -0,0 +1,187 @@
+/**
+ * API-5 facade dispatch — Status domain router.
+ *
+ * Actions: status, list, get, events, artifacts, summary, graph, search,
+ * health, worktrees, checkpoint, cache, explain, onboard, recommend, help.
+ *
+ * Inline cases (graph, search, onboard, explain, cache, checkpoint, recommend,
+ * help) are moved verbatim from the former handleTeamTool switch.
+ */
+import * as path from "node:path";
+import { allAgents, discoverAgents } from "../../../agents/discover-agents.ts";
+import { loadConfig } from "../../../config/config.ts";
+import { FileCheckpointStore } from "../../../runtime/checkpoint.ts";
+import { getSkillCacheStats } from "../../../runtime/skill-instructions.ts";
+import type { TeamToolParamsValue } from "../../../schema/team-tool-schema.ts";
+import { computeRunCacheKey, getCachedRun, getCacheStats } from "../../../state/run-cache.ts";
+import { listRunGraphs, loadRunGraph } from "../../../state/run-graph.ts";
+import { allTeams, discoverTeams } from "../../../teams/discover-teams.ts";
+import { searchAgents, searchTeams } from "../../../utils/bm25-search.ts";
+import { projectCrewRoot } from "../../../utils/paths.ts";
+import { assertSafePathId } from "../../../utils/safe-paths.ts";
+import { formatActionSuggestion } from "../../action-suggestions.ts";
+import { piTeamsHelp } from "../../help.ts";
+import { buildTeamOnboarding } from "../../team-onboard.ts";
+import { formatRecommendation, recommendTeam } from "../../team-recommendation.ts";
+import { handleGet, handleList } from "../../team-tool.ts";
+import type { PiTeamsToolResult } from "../../tool-result.ts";
+import { result, type TeamContext } from "../context.ts";
+import { handleExplain } from "../explain.ts";
+import { handleHealthMonitor } from "../health-monitor.ts";
+import { handleArtifacts, handleEvents, handleSummary } from "../inspect.ts";
+import { handleWorktrees } from "../lifecycle-actions.ts";
+import { handleStatus } from "../status.ts";
+
+export async function handleStatusDomain(params: TeamToolParamsValue, ctx: TeamContext): Promise<PiTeamsToolResult> {
+	switch (params.action) {
+		case "list":
+			return handleList(params, ctx);
+		case "get":
+			return handleGet(params, ctx);
+		case "status":
+			return handleStatus(params, ctx);
+		case "events":
+			return handleEvents(params, ctx);
+		case "artifacts":
+			return handleArtifacts(params, ctx);
+		case "worktrees":
+			return handleWorktrees(params, ctx);
+		case "summary":
+			return handleSummary(params, ctx);
+		case "health":
+			return handleHealthMonitor(ctx, params);
+		case "help":
+			return result(piTeamsHelp(), { action: "help", status: "ok" });
+		case "recommend": {
+			const goal = params.goal ?? params.task;
+			if (!goal) return result("Recommend requires goal or task.", { action: "recommend", status: "error" }, true);
+			const loaded = loadConfig(ctx.cwd);
+			const recommendation = recommendTeam(goal, loaded.config.autonomous, {
+				teams: allTeams(discoverTeams(ctx.cwd)),
+				agents: allAgents(discoverAgents(ctx.cwd)),
+			});
+			return result(formatRecommendation(goal, recommendation), {
+				action: "recommend",
+				status: "ok",
+			});
+		}
+		case "graph": {
+			if (params.runId) {
+				assertSafePathId("runId", params.runId);
+				const graph = loadRunGraph(ctx.cwd, params.runId);
+				return result(
+					graph ? JSON.stringify(graph, null, 2) : "No graph found for this run.",
+					{ action: "graph", status: graph ? "ok" : "error" },
+					!graph,
+				);
+			}
+			const graphs = listRunGraphs(ctx.cwd);
+			return result(graphs.length ? `Available graphs:\n${graphs.join("\n")}` : "No graphs available.", {
+				action: "graph",
+				status: "ok",
+			});
+		}
+		case "search": {
+			const query = params.goal ?? params.task ?? "";
+			if (!query) {
+				return result("Search requires goal or task query.", { action: "search", status: "error" }, true);
+			}
+			try {
+				const [agentResults, teamResults] = await Promise.all([
+					searchAgents(query, { limit: 5 }),
+					searchTeams(query, { limit: 3 }),
+				]);
+				const lines: string[] = [];
+				if (teamResults.length) {
+					lines.push("## Teams");
+					for (const r of teamResults) {
+						lines.push(`- [${r.team.name}] score=${r.score.toFixed(2)}: ${r.team.description ?? "(no description)"}`);
+					}
+				}
+				if (agentResults.length) {
+					lines.push("## Agents");
+					for (const r of agentResults) {
+						lines.push(`- [${r.agent.name}] score=${r.score.toFixed(2)}: ${r.agent.description ?? "(no description)"}`);
+					}
+				}
+				return result(lines.length ? lines.join("\n") : "No results found.", { action: "search", status: "ok" });
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				return result(`Search failed: ${msg}`, { action: "search", status: "error" }, true);
+			}
+		}
+		case "onboard": {
+			const team = params.team ?? "default";
+			const onboarding = buildTeamOnboarding(team, ctx.cwd);
+			return result(onboarding, { action: "onboard", status: "ok" });
+		}
+		case "explain": {
+			const explainResult = handleExplain(params, ctx.cwd);
+			return result(
+				explainResult.text,
+				{
+					action: "explain",
+					status: explainResult.isError ? "error" : "ok",
+				},
+				explainResult.isError,
+			);
+		}
+		case "cache": {
+			if (params.goal) {
+				const key = computeRunCacheKey(params.goal, params.team ?? "default", params.workflow ?? "default", ctx.cwd);
+				const cached = getCachedRun(ctx.cwd, key);
+				if (cached) {
+					return result(
+						`Cached run found (${new Date(cached.cachedAt).toISOString()}): runId=${cached.runId}, status=${cached.status}, ${cached.tasks.length} tasks`,
+						{
+							action: "cache",
+							status: "ok",
+							data: {
+								cacheKey: key,
+								cacheHit: true,
+								runId: cached.runId,
+								status: cached.status,
+								taskCount: cached.tasks.length,
+							},
+						},
+					);
+				}
+				return result(`No cached result for key: ${key}`, {
+					action: "cache",
+					status: "ok",
+					data: { cacheKey: key, cacheHit: false },
+				});
+			}
+			const stats = getCacheStats(ctx.cwd);
+			const skillStats = getSkillCacheStats();
+			return result(
+				`Run cache: ${stats.entries} entries, ${stats.sizeBytes} bytes\n` +
+					`Skill cache: ${skillStats.hits} hits, ${skillStats.misses} misses (${(skillStats.hitRate * 100).toFixed(1)}% hit rate), ${skillStats.currentSize}/${skillStats.maxEntries} entries, ${skillStats.evictions} evictions`,
+				{ action: "cache", status: "ok" },
+			);
+		}
+		case "checkpoint": {
+			if (!params.runId || !params.taskId) {
+				return result("Checkpoint requires runId and taskId.", { action: "checkpoint", status: "error" }, true);
+			}
+			assertSafePathId("runId", params.runId);
+			assertSafePathId("taskId", params.taskId);
+			const stateRoot = path.join(projectCrewRoot(ctx.cwd), "state", "runs", params.runId);
+			const store = new FileCheckpointStore(stateRoot);
+			const checkpoint = store.load(params.runId, params.taskId);
+			if (!checkpoint) {
+				return result("No checkpoint found.", { action: "checkpoint", status: "error" }, true);
+			}
+			return result(
+				`Checkpoint: step=${checkpoint.step}, progress=${checkpoint.progress}, savedAt=${new Date(checkpoint.savedAt).toISOString()}`,
+				{ action: "checkpoint", status: "ok", data: { checkpoint } },
+			);
+		}
+		default:
+			return result(
+				`Unhandled status-domain action: ${params.action}${formatActionSuggestion(String(params.action ?? ""))}`,
+				{ action: "unknown", status: "error" },
+				true,
+			);
+	}
+}