@omercnet/paseo-omp 0.2.1 → 0.3.0-next.100.1

package/server/provider-diagnostics.ts

@@ -17,7 +17,7 @@ import type {
   OmpVersionStatus,
   PathState,
 } from "../shared/provider-diagnostics";
-import { ompAgentDir } from "./paths";
+import { currentOmpEnvironment, ompAgentDir, ompDataDir, ompSessionDir } from "./paths";
 
 const VERSION_TIMEOUT_MS = 3_000;
 const HELP_TIMEOUT_MS = 3_000;
@@ -190,7 +190,11 @@ export async function killWindowsProcessTree(
 
   let child: ProbeChildProcess;
   try {
-    child = spawnFn(taskkillPath, ["/pid", String(pid), "/t", "/f"], buildProbeEnv(process.env));
+    child = spawnFn(
+      taskkillPath,
+      ["/pid", String(pid), "/t", "/f"],
+      buildProbeEnv(currentOmpEnvironment()),
+    );
   } catch {
     return false;
   }
@@ -243,7 +247,7 @@ export function defaultSpawn(
         return killWindowsProcessTree(
           child.pid,
           defaultSpawn,
-          process.env.SystemRoot ?? WINDOWS_DEFAULT_SYSTEM_ROOT,
+          currentOmpEnvironment().SystemRoot ?? WINDOWS_DEFAULT_SYSTEM_ROOT,
           graceMs,
         );
       }
@@ -569,7 +573,7 @@ export async function probeOmpAvailability(options: OmpAvailabilityProbeOptions)
   status: "missing" | "unrunnable" | "incompatible" | "available";
   diagnostic?: string;
 }> {
-  const environment = options.environment ?? process.env;
+  const environment = options.environment ?? currentOmpEnvironment();
   const [command, ...prefixArgs] = options.command;
   const resolvedPath = await resolveExecutablePath(
     command,
@@ -810,31 +814,57 @@ async function computeMcpDiagnostics(agentDir: string): Promise<OmpMcpDiagnostic
 export interface ProcessDiagnosticsFs {
   readdir(path: string): Promise<string[]>;
   lstat(path: string): Promise<Stats>;
+  readMetadata(path: string, maxBytes: number): Promise<BoundedFileRead>;
 }
 
-const processDiagnosticsFs: ProcessDiagnosticsFs = { readdir, lstat };
+const processDiagnosticsFs: ProcessDiagnosticsFs = {
+  readdir,
+  lstat,
+  readMetadata: readBoundedNoSymlinkFile,
+};
+const MAX_PROCESS_METADATA_BYTES = 64 * 1024;
+const MAX_PROCESS_METADATA_ENTRIES = 4_096;
+const ProcessStateSchema = z.object({
+  daemon: z.object({
+    state: z.string().max(32),
+    exitedAt: z.number().finite().nonnegative().nullish(),
+  }),
+});
+const ACTIVE_PROCESS_STATES = new Set(["starting", "running", "ready", "restarting"]);
+const HISTORICAL_PROCESS_STATES = new Set(["exited", "failed", "stopped"]);
 
 /**
- * Counts only regular, non-symlink meta.json entries. Missing/wrong entries are expected and
- * ignored; any other read/stat failure makes the result partial rather than silently hiding it.
+ * Classifies bounded, regular, non-symlink Hub metadata. A recorded active state is not a
+ * liveness check. Historical files remain useful evidence and are never counted as running.
+ * Only aggregate counts leave this reader; metadata arguments, paths and values are discarded.
  */
 export async function computeProcessDiagnostics(
   hubRunRoot: string,
   fs: ProcessDiagnosticsFs = processDiagnosticsFs,
 ): Promise<OmpProcessDiagnostics> {
+  const unavailableCounts = {
+    trackedCount: null,
+    activeCount: null,
+    historicalCount: null,
+    unknownCount: null,
+  };
   let projectHashes: string[];
   try {
     const rootStats = await fs.lstat(hubRunRoot);
     if (rootStats.isSymbolicLink() || !rootStats.isDirectory()) {
-      return { status: "unavailable", trackedCount: null };
+      return { status: "unavailable", ...unavailableCounts };
     }
     projectHashes = await fs.readdir(hubRunRoot);
   } catch (error) {
-    return { status: isEnoent(error) ? "unavailable" : "unknown", trackedCount: null };
+    return { status: isEnoent(error) ? "unavailable" : "unknown", ...unavailableCounts };
   }
   let trackedCount = 0;
-  let partial = false;
-  for (const hash of projectHashes) {
+  let activeCount = 0;
+  let historicalCount = 0;
+  let unknownCount = 0;
+  let partial = projectHashes.length > MAX_PROCESS_METADATA_ENTRIES;
+  let visitedEntries = 0;
+  for (const hash of projectHashes.slice(0, MAX_PROCESS_METADATA_ENTRIES)) {
     const projectDir = join(hubRunRoot, hash);
     const daemonsDir = join(projectDir, "daemons");
     try {
@@ -855,15 +885,51 @@ export async function computeProcessDiagnostics(
       continue;
     }
     for (const name of daemonNames) {
+      if (++visitedEntries > MAX_PROCESS_METADATA_ENTRIES) {
+        partial = true;
+        break;
+      }
       try {
-        const metaStats = await fs.lstat(join(daemonsDir, name, "meta.json"));
-        if (!metaStats.isSymbolicLink() && metaStats.isFile()) trackedCount += 1;
+        const daemonDir = join(daemonsDir, name);
+        const directoryStats = await fs.lstat(daemonDir);
+        if (directoryStats.isSymbolicLink() || !directoryStats.isDirectory()) continue;
+        const metaPath = join(daemonDir, "meta.json");
+        const metaStats = await fs.lstat(metaPath);
+        if (metaStats.isSymbolicLink() || !metaStats.isFile()) continue;
+        trackedCount += 1;
+        let category: "active" | "historical" | "unknown" = "unknown";
+        try {
+          const file = await fs.readMetadata(metaPath, MAX_PROCESS_METADATA_BYTES);
+          if (file.state === "available") {
+            const parsed = ProcessStateSchema.safeParse(JSON.parse(file.text));
+            if (parsed.success) {
+              const { state, exitedAt } = parsed.data.daemon;
+              if (HISTORICAL_PROCESS_STATES.has(state) || exitedAt != null) category = "historical";
+              else if (ACTIVE_PROCESS_STATES.has(state)) category = "active";
+            }
+          }
+        } catch {
+          // Read/access/parse errors have an honest unknown bucket, never a guessed active state.
+        }
+        if (category === "historical") historicalCount += 1;
+        else if (category === "active") activeCount += 1;
+        else {
+          unknownCount += 1;
+          partial = true;
+        }
       } catch (error) {
         if (!isEnoent(error)) partial = true;
       }
     }
+    if (visitedEntries > MAX_PROCESS_METADATA_ENTRIES) break;
   }
-  return { status: partial ? "partial" : "ok", trackedCount };
+  return {
+    status: partial ? "partial" : "ok",
+    trackedCount,
+    activeCount,
+    historicalCount,
+    unknownCount,
+  };
 }
 
 function homeRelative(path: string, homeDir: string): string | null {
@@ -880,16 +946,23 @@ function sanitizeRootPath(path: string, homeDir: string): string {
   return homeRelative(path, homeDir) ?? "<custom path>";
 }
 
-function sanitizeDerivedPath(rawRoot: string, sanitizedRoot: string, fullPath: string): string {
+function sanitizeDerivedPath(
+  rawRoot: string,
+  sanitizedRoot: string,
+  fullPath: string,
+  fallbackHomeDir?: string,
+): string {
   const suffix = relative(rawRoot, fullPath);
   if (suffix === "" || suffix === ".." || suffix.startsWith(`..${sep}`) || isAbsolute(suffix)) {
-    return sanitizedRoot;
+    return fallbackHomeDir ? sanitizeRootPath(fullPath, fallbackHomeDir) : sanitizedRoot;
   }
   return `${sanitizedRoot}/${suffix.split(sep).join("/")}`;
 }
 
 export interface ProviderDiagnosticsDeps {
   agentDir: string;
+  dataDir?: string;
+  sessionDir?: string;
   command: string;
   pathDirs: readonly string[];
   cwd: string;
@@ -910,6 +983,8 @@ export async function computeOmpProviderHealth(
   deps: ProviderDiagnosticsDeps,
 ): Promise<OmpProviderHealth> {
   const agentDir = resolve(deps.agentDir);
+  const dataDir = resolve(deps.dataDir ?? agentDir);
+  const sessionRoot = resolve(deps.sessionDir ?? join(dataDir, SESSION_DIR_NAME));
   const homeDir = resolve(deps.homeDir);
   const versionTimeoutMs = deps.versionTimeoutMs ?? VERSION_TIMEOUT_MS;
   const helpTimeoutMs = deps.helpTimeoutMs ?? HELP_TIMEOUT_MS;
@@ -935,6 +1010,7 @@ export async function computeOmpProviderHealth(
           versionTimeoutMs,
           killGraceMs,
           maxVersionBytes,
+          deps.cwd,
         )
       : null,
     installed
@@ -946,6 +1022,7 @@ export async function computeOmpProviderHealth(
           helpTimeoutMs,
           killGraceMs,
           maxHelpBytes,
+          deps.cwd,
         )
       : null,
   ]);
@@ -957,9 +1034,8 @@ export async function computeOmpProviderHealth(
   const lsp = helpRun ? computeLspDiagnostics(helpRun) : { status: "unknown" as const };
   const processCleanupFailed = Boolean(versionRun?.cleanupFailed || helpRun?.cleanupFailed);
 
-  const agentDbPath = join(agentDir, AGENT_DB_FILENAME);
-  const historyDbPath = join(agentDir, HISTORY_DB_FILENAME);
-  const sessionRoot = join(agentDir, SESSION_DIR_NAME);
+  const agentDbPath = join(dataDir, AGENT_DB_FILENAME);
+  const historyDbPath = join(dataDir, HISTORY_DB_FILENAME);
   const [
     configResult,
     agentRootState,
@@ -1000,7 +1076,7 @@ export async function computeOmpProviderHealth(
       agentRootState,
       configPath: sanitizeDerivedPath(agentDir, sanitizedAgentRoot, configResult.path),
       configState,
-      sessionRoot: sanitizeDerivedPath(agentDir, sanitizedAgentRoot, sessionRoot),
+      sessionRoot: sanitizeDerivedPath(agentDir, sanitizedAgentRoot, sessionRoot, homeDir),
       sessionRootState,
     },
     databases: {
@@ -1013,11 +1089,11 @@ export async function computeOmpProviderHealth(
   };
 }
 
-let cachedHealth: { value: OmpProviderHealth; expiresAt: number } | null = null;
-let inFlightHealth: Promise<OmpProviderHealth> | null = null;
+const cachedHealth = new Map<string, { value: OmpProviderHealth; expiresAt: number }>();
+const inFlightHealth = new Map<string, Promise<OmpProviderHealth>>();
 
-function defaultHubRunRoot(): string {
-  return process.env.PASEO_OMP_RUN_DIR ?? join(homedir(), ".omp", "run", "daemons");
+function defaultHubRunRoot(environment: NodeJS.ProcessEnv = currentOmpEnvironment()): string {
+  return environment.PASEO_OMP_RUN_DIR ?? join(homedir(), ".omp", "run", "daemons");
 }
 
 /**
@@ -1029,29 +1105,39 @@ function defaultHubRunRoot(): string {
 export async function resolveGetOmpProviderHealth(
   input: RpcInput<typeof getOmpProviderHealth>,
 ): Promise<OmpProviderHealth> {
+  const cwd = input.cwd ?? process.cwd();
+  const environment = currentOmpEnvironment();
+  const agentDir = ompAgentDir(environment);
+  const dataDir = ompDataDir(environment);
+  const sessionDir = ompSessionDir(environment);
   const now = Date.now();
-  if (!input.force && cachedHealth && cachedHealth.expiresAt > now) return cachedHealth.value;
-  if (inFlightHealth) return inFlightHealth;
+  const key = JSON.stringify([cwd, agentDir, dataDir, sessionDir]);
+  const cached = cachedHealth.get(key);
+  if (!input.force && cached && cached.expiresAt > now) return cached.value;
+  const inFlight = inFlightHealth.get(key);
+  if (inFlight) return inFlight;
 
   const computation = computeOmpProviderHealth({
-    agentDir: ompAgentDir(),
-    command: process.env.OMP_COMMAND ?? "omp",
-    pathDirs: (process.env.PATH ?? "").split(delimiter),
-    cwd: process.cwd(),
+    agentDir,
+    dataDir,
+    sessionDir,
+    command: environment.OMP_COMMAND ?? "omp",
+    pathDirs: (environment.PATH ?? "").split(delimiter),
+    cwd,
     platform: process.platform,
-    pathExt: process.env.PATHEXT ?? WINDOWS_DEFAULT_PATHEXT,
-    env: process.env,
+    pathExt: environment.PATHEXT ?? WINDOWS_DEFAULT_PATHEXT,
+    env: environment,
     spawnFn: defaultSpawn,
-    hubRunRoot: defaultHubRunRoot(),
+    hubRunRoot: defaultHubRunRoot(environment),
     homeDir: homedir(),
   })
     .then((value) => {
-      cachedHealth = { value, expiresAt: Date.now() + HEALTH_CACHE_TTL_MS };
+      cachedHealth.set(key, { value, expiresAt: Date.now() + HEALTH_CACHE_TTL_MS });
       return value;
     })
     .finally(() => {
-      inFlightHealth = null;
+      inFlightHealth.delete(key);
     });
-  inFlightHealth = computation;
+  inFlightHealth.set(key, computation);
   return computation;
 }

package/server/quota.ts

@@ -1,8 +1,9 @@
+import { join } from "node:path";
 import { DatabaseSync } from "node:sqlite";
 import type { RpcInput } from "@getpaseo/plugin";
 import { z } from "zod";
 import type { listOmpQuotas, OmpQuota } from "../shared/quota";
-import { ompAgentDir } from "./paths";
+import { ompDataDir } from "./paths";
 
 const QuotaRowSchema = z.object({
   provider: z.string(),
@@ -50,5 +51,5 @@ export function listOmpQuotasFrom(path: string): OmpQuota[] {
 export function resolveListOmpQuotas(_input: RpcInput<typeof listOmpQuotas>): {
   quotas: OmpQuota[];
 } {
-  return { quotas: listOmpQuotasFrom(`${ompAgentDir()}/agent.db`) };
+  return { quotas: listOmpQuotasFrom(join(ompDataDir(), "agent.db")) };
 }

package/server/sessions.ts

@@ -3,7 +3,7 @@ import { DatabaseSync } from "node:sqlite";
 import type { RpcInput } from "@getpaseo/plugin";
 import { z } from "zod";
 import type { listOmpSessions, OmpSessionEntry } from "../shared/sessions";
-import { ompAgentDir } from "./paths";
+import { ompDataDir } from "./paths";
 
 const PROMPT_LIMIT = 400;
 const ROW_LIMIT = 100;
@@ -54,5 +54,5 @@ export function listOmpSessionsFrom(path: string, cwd: string): OmpSessionEntry[
 export function resolveListOmpSessions({ cwd }: RpcInput<typeof listOmpSessions>): {
   sessions: OmpSessionEntry[];
 } {
-  return { sessions: listOmpSessionsFrom(join(ompAgentDir(), "history.db"), cwd) };
+  return { sessions: listOmpSessionsFrom(join(ompDataDir(), "history.db"), cwd) };
 }

package/shared/composer-pill-settings.ts

@@ -0,0 +1,28 @@
+import { defineSettings } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const DEFAULT_COMPOSER_PILL_SETTINGS = {
+  mcp: true,
+  hub: true,
+  memory: true,
+  sessions: true,
+  quota: true,
+} as const;
+
+export const composerPillSettingsSchema = z.object({
+  mcp: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.mcp),
+  hub: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.hub),
+  memory: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.memory),
+  sessions: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.sessions),
+  quota: z.boolean().default(DEFAULT_COMPOSER_PILL_SETTINGS.quota),
+});
+
+export type ComposerPillSettings = z.infer<typeof composerPillSettingsSchema>;
+export type ComposerPillKey = keyof ComposerPillSettings;
+
+export const composerPillSettings = defineSettings({
+  id: "composer-pills",
+  scope: "host",
+  version: 1,
+  schema: composerPillSettingsSchema,
+});

package/shared/external-url.ts

@@ -0,0 +1,21 @@
+export type ExternalUrlOpener = (url: string) => Promise<void>;
+
+export function selectExternalUrlOpener(
+  paseoOpener: ExternalUrlOpener | undefined,
+  fallback: ExternalUrlOpener,
+): ExternalUrlOpener {
+  return paseoOpener ?? fallback;
+}
+
+export function validatedHttpUrl(value: string): string {
+  let url: URL;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error("Only absolute HTTP(S) URLs are supported.");
+  }
+  if (url.protocol !== "http:" && url.protocol !== "https:") {
+    throw new Error("Only absolute HTTP(S) URLs are supported.");
+  }
+  return url.href;
+}

package/shared/hub.ts

@@ -23,7 +23,7 @@ export const HubProcessSchema = z.object({
   exitCode: z.number().nullable(),
 });
 export type HubProcess = z.infer<typeof HubProcessSchema>;
-const CwdSchema = z.string().min(1).max(4_096);
+export const OmpWorkspaceCwdSchema = z.string().min(1).max(4_096);
 const ProcessNameSchema = z
   .string()
   .min(1)
@@ -32,12 +32,12 @@ const ProcessNameSchema = z
 
 export const listHubProcesses = defineRpc({
   name: "paseo-omp.list-processes",
-  input: z.object({ cwd: CwdSchema }),
+  input: z.object({ cwd: OmpWorkspaceCwdSchema }),
   output: z.object({ processes: z.array(HubProcessSchema) }),
 });
 
 export const tailHubLog = defineRpc({
   name: "paseo-omp.tail-log",
-  input: z.object({ cwd: CwdSchema, name: ProcessNameSchema }),
+  input: z.object({ cwd: OmpWorkspaceCwdSchema, name: ProcessNameSchema }),
   output: z.object({ content: z.string(), truncated: z.boolean() }),
 });

package/shared/mcp.ts

@@ -0,0 +1,47 @@
+import { defineRpc } from "@getpaseo/plugin";
+import { z } from "zod";
+
+export const OMP_MCP_AUTH_TIMELINE_KIND = "omp-mcp-authorization";
+const OmpMcpAuthorizationUrlSchema = z
+  .string()
+  .max(16_384)
+  .refine((value) => {
+    try {
+      const url = new URL(value);
+      return (
+        (url.protocol === "http:" || url.protocol === "https:") && !url.username && !url.password
+      );
+    } catch {
+      return false;
+    }
+  }, "Authorization URL must be an HTTP URL without embedded credentials");
+
+export const ompMcpAuthorizationTimelineSchema = z.object({
+  url: OmpMcpAuthorizationUrlSchema,
+  instructions: z
+    .string()
+    .max(64 * 1024)
+    .optional(),
+  loopbackCallback: z.boolean(),
+  browserAuthorizationToken: z.string().uuid().optional(),
+});
+
+export type OmpMcpAuthorizationTimeline = z.infer<typeof ompMcpAuthorizationTimelineSchema>;
+export const openOmpMcpAuthorizationInPaseoBrowser = defineRpc({
+  name: "paseo-omp.open-mcp-authorization-in-browser",
+  input: z.object({ authorizationToken: z.string().uuid() }),
+  output: z.object({ opened: z.literal(true) }),
+});
+
+const OMP_MCP_SERVER_NAME = /^[a-zA-Z0-9_.:-]{1,100}$/u;
+
+export type OmpMcpServerAction = "test" | "reauth" | "enable" | "disable";
+
+export function buildOmpMcpServerCommand(
+  action: OmpMcpServerAction,
+  serverName: string,
+): string | undefined {
+  const name = serverName.trim();
+  if (!OMP_MCP_SERVER_NAME.test(name)) return;
+  return `/mcp ${action} ${name}`;
+}

package/shared/memory.ts

@@ -1,5 +1,6 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
+import { OmpStoreSchema } from "./omp-store";
 
 const CwdSchema = z.string().min(1).max(4_096);
 
@@ -15,7 +16,7 @@ export type OmpMemoryFact = z.infer<typeof OmpMemoryFactSchema>;
 
 export const listOmpMemory = defineRpc({
   name: "paseo-omp.list-memory",
-  input: z.object({ cwd: CwdSchema }),
+  input: z.object({ store: OmpStoreSchema.optional(), cwd: CwdSchema }),
   output: z.object({
     bank: z.string().nullable(),
     facts: z.array(OmpMemoryFactSchema),

package/shared/omp-config.ts

@@ -1,5 +1,7 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
 
 // Mirrors the safe, non-secret subset of omp's on-disk ~/.omp/agent/config.yml. That file is an
 // internal, unversioned config format owned by the omp harness (source: omp's
@@ -72,7 +74,9 @@ export type OmpConfig = z.infer<typeof OmpConfigSchema>;
 
 export const listOmpConfig = defineRpc({
   name: "paseo-omp.list-config",
-  input: z.object({}),
+  input: z
+    .object({ store: OmpStoreSchema.optional(), cwd: OmpWorkspaceCwdSchema.optional() })
+    .strict(),
   output: z.object({
     path: z.string(),
     available: z.boolean(),

package/shared/omp-plugins.ts

@@ -1,5 +1,7 @@
 import { defineRpc } from "@getpaseo/plugin";
 import { z } from "zod";
+import { OmpWorkspaceCwdSchema } from "./hub";
+import { OmpStoreSchema } from "./omp-store";
 
 export const OMP_PLUGIN_LIMIT = 256;
 export const OMP_PLUGIN_ARGUMENT_LIMIT = 512;
@@ -72,6 +74,7 @@ export const OmpInstalledPluginSchema = z
     availableFeatures: z.array(z.string().min(1).max(128)).max(128),
     configurable: z.boolean(),
     ambiguous: z.boolean(),
+    configAmbiguous: z.boolean(),
     usesDefaultFeatures: z.boolean(),
   })
   .strict();
@@ -89,7 +92,9 @@ export type OmpPluginState = z.infer<typeof OmpPluginStateSchema>;
 
 export const listOmpPlugins = defineRpc({
   name: "paseo-omp.list-plugins",
-  input: z.object({}).strict(),
+  input: z
+    .object({ store: OmpStoreSchema.optional(), cwd: OmpWorkspaceCwdSchema.optional() })
+    .strict(),
   output: OmpPluginStateSchema,
 });
 
@@ -121,7 +126,13 @@ export type OmpPluginConfigState = z.infer<typeof OmpPluginConfigStateSchema>;
 
 export const inspectOmpPluginConfig = defineRpc({
   name: "paseo-omp.inspect-plugin-config",
-  input: z.object({ plugin: OmpPluginNameSchema }).strict(),
+  input: z
+    .object({
+      store: OmpStoreSchema.optional(),
+      plugin: OmpPluginNameSchema,
+      cwd: OmpWorkspaceCwdSchema.optional(),
+    })
+    .strict(),
   output: OmpPluginConfigStateSchema,
 });
 
@@ -151,6 +162,8 @@ export const OmpPluginConfigMutationSchema = z.discriminatedUnion("action", [
       plugin: OmpPluginNameSchema,
       key: OmpPluginConfigKeySchema,
       value: z.union([OmpPluginConfigStringValueSchema, z.number().finite(), z.boolean()]),
+      store: OmpStoreSchema.optional(),
+      cwd: OmpWorkspaceCwdSchema.optional(),
     })
     .strict(),
   z
@@ -158,6 +171,8 @@ export const OmpPluginConfigMutationSchema = z.discriminatedUnion("action", [
       action: z.literal("delete"),
       plugin: OmpPluginNameSchema,
       key: OmpPluginConfigKeySchema,
+      store: OmpStoreSchema.optional(),
+      cwd: OmpWorkspaceCwdSchema.optional(),
     })
     .strict(),
 ]);
@@ -176,38 +191,64 @@ export const mutateOmpPluginConfig = defineRpc({
 });
 
 const ScopedMutationShape = {
-  scope: z.literal("user").optional(),
+  scope: OmpPluginScopeSchema.optional(),
+  store: OmpStoreSchema.optional(),
+  cwd: OmpWorkspaceCwdSchema.optional(),
 };
-
-export const OmpPluginMutationSchema = z.discriminatedUnion("action", [
-  z
-    .object({
-      action: z.literal("install"),
-      source: OmpPluginInstallSourceSchema,
-      ...ScopedMutationShape,
-    })
-    .strict(),
-  z
-    .object({ action: z.literal("enable"), plugin: OmpPluginTargetSchema, ...ScopedMutationShape })
-    .strict(),
-  z
-    .object({ action: z.literal("disable"), plugin: OmpPluginTargetSchema, ...ScopedMutationShape })
-    .strict(),
-  z
-    .object({
-      action: z.literal("uninstall"),
-      plugin: OmpPluginTargetSchema,
-      ...ScopedMutationShape,
-    })
-    .strict(),
-  z
-    .object({
-      action: z.literal("upgrade"),
-      plugin: OmpMarketplacePluginIdSchema,
-      ...ScopedMutationShape,
-    })
-    .strict(),
-]);
+export const OmpPluginMutationSchema = z
+  .discriminatedUnion("action", [
+    z
+      .object({
+        action: z.literal("install"),
+        source: OmpPluginInstallSourceSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("enable"),
+        plugin: OmpPluginTargetSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("disable"),
+        plugin: OmpPluginTargetSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("uninstall"),
+        plugin: OmpPluginTargetSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+    z
+      .object({
+        action: z.literal("upgrade"),
+        plugin: OmpMarketplacePluginIdSchema,
+        ...ScopedMutationShape,
+      })
+      .strict(),
+  ])
+  .superRefine((input, context) => {
+    if (input.scope === "project" && input.cwd === undefined) {
+      context.addIssue({
+        code: "custom",
+        message: "Project-scoped plugin actions require a workspace",
+        path: ["cwd"],
+      });
+    }
+    if (input.action === "install" && input.scope === "project") {
+      context.addIssue({
+        code: "custom",
+        message: "Project-scoped installation is not supported through this API",
+        path: ["scope"],
+      });
+    }
+  });
 export type OmpPluginMutation = z.infer<typeof OmpPluginMutationSchema>;
 
 export const mutateOmpPlugin = defineRpc({