@h-rig/omp-extension-plugin 0.0.6-alpha.186

package/dist/src/product-entrypoint/contributions.d.ts

@@ -0,0 +1,3 @@
+import type { CliCommand, FeatureCapability } from "@rig/core/config";
+export declare const productCliCommands: readonly CliCommand[];
+export declare const productEntrypointCapability: FeatureCapability;

package/dist/src/product-entrypoint/contributions.js

@@ -0,0 +1,215 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/omp-extension-plugin/src/product-entrypoint/product-entrypoint.ts
+var exports_product_entrypoint = {};
+__export(exports_product_entrypoint, {
+  runRigOmpProductCommand: () => runRigOmpProductCommand,
+  joinRigOmpProductSession: () => joinRigOmpProductSession
+});
+import { resolve } from "path";
+import { runCli } from "@oh-my-pi/pi-coding-agent/cli";
+import { parseArgs } from "@oh-my-pi/pi-coding-agent/cli/args";
+import { resolveCliArgv } from "@oh-my-pi/pi-coding-agent/cli-commands";
+import { prepareAcpTerminalAuthArgs } from "@oh-my-pi/pi-coding-agent/modes/acp/terminal-auth";
+import { runRootCommand } from "@oh-my-pi/pi-coding-agent/main";
+import { createAgentSession } from "@oh-my-pi/pi-coding-agent/sdk";
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+import { RUN_IDENTITY_ENV, RUN_READ_MODEL, TRANSPORT_CONFIG } from "@rig/contracts";
+async function withRigDefaultConfig(projectRoot, argv) {
+  const transportConfig = await loadCapabilityForRoot(projectRoot, TransportConfigCap);
+  if (!transportConfig)
+    throw new Error("TRANSPORT_CONFIG capability unavailable: load @rig/transport-plugin before launching OMP.");
+  return ["--config", transportConfig.resolveRigOmpConfigOverlayPath({ projectRoot }), ...argv];
+}
+async function createRigAgentSession(projectRoot, options = {}) {
+  const { host } = await resolvePluginHost(projectRoot);
+  const sessionExtensions = host.listSessionExtensions();
+  return createAgentSession({
+    ...options,
+    extensions: [...sessionExtensions.map((entry) => (api) => entry.install(api, { panels: host.listPanels() })), ...options.extensions ?? []]
+  });
+}
+function productArgv(input) {
+  if (input.command === "launch" && input.args.length === 0)
+    return [];
+  if (input.command === "launch" && input.args[0]?.startsWith("-"))
+    return [...input.args];
+  return [input.command, ...input.args];
+}
+async function joinRigOmpProductSession(input) {
+  const projectRoot = resolve(input.projectRoot);
+  const link = input.link.trim();
+  const previousProjectRoot = process.env.RIG_PROJECT_ROOT;
+  const previousCwd = process.cwd();
+  const identityEnv = await loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const restorePublicIdentityEnv = identityEnv?.applyIdentityEnv(projectRoot) ?? (() => {});
+  process.env.RIG_PROJECT_ROOT = projectRoot;
+  process.chdir(projectRoot);
+  try {
+    const args = await withRigDefaultConfig(projectRoot, []);
+    const parsed = parseArgs(args);
+    parsed.join = link;
+    await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    return { ok: true, group: "product", command: "join" };
+  } finally {
+    restorePublicIdentityEnv();
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) {
+      delete process.env.RIG_PROJECT_ROOT;
+    } else {
+      process.env.RIG_PROJECT_ROOT = previousProjectRoot;
+    }
+  }
+}
+async function runRigOmpProductCommand(input) {
+  const projectRoot = resolve(input.projectRoot);
+  const previousProjectRoot = process.env.RIG_PROJECT_ROOT;
+  const previousCwd = process.cwd();
+  const identityEnv = await loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const restorePublicIdentityEnv = identityEnv?.applyIdentityEnv(projectRoot) ?? (() => {});
+  process.env.RIG_PROJECT_ROOT = projectRoot;
+  process.chdir(projectRoot);
+  try {
+    const argv = productArgv(input);
+    if (argv[0]?.startsWith("__omp_worker_") || argv[0] === "--smoke-test") {
+      await runCli(argv);
+      return { ok: true, group: "product", command: input.command };
+    }
+    if (process.stdin.isTTY) {
+      const readModel = await loadCapabilityForRoot(projectRoot, RunReadModelCap);
+      if (readModel) {
+        await readModel.reconcileActiveRuns({
+          workspaceRoot: projectRoot,
+          identityFilter: identityEnv?.identityFilterFromEnv() ?? {}
+        }).catch(() => ({ flipped: [], resumable: [] }));
+      }
+    }
+    const resolved = resolveCliArgv(argv);
+    if ("error" in resolved) {
+      process.stderr.write(`error: ${resolved.error}
+`);
+      process.exitCode = 1;
+      return { ok: true, group: "product", command: input.command };
+    }
+    const [ompCommand, ...ompCommandArgs] = resolved.argv;
+    if (ompCommand === "launch") {
+      const args = await withRigDefaultConfig(projectRoot, ompCommandArgs);
+      await runRootCommand(parseArgs(args), args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    } else if (ompCommand === "acp") {
+      const { args: preparedArgs, terminalAuth } = prepareAcpTerminalAuthArgs(ompCommandArgs);
+      const args = await withRigDefaultConfig(projectRoot, preparedArgs);
+      const parsed = parseArgs(args);
+      if (!terminalAuth)
+        parsed.mode = "acp";
+      await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    } else if (ompCommand === "join") {
+      const link = ompCommandArgs[0]?.trim();
+      if (!link) {
+        process.stderr.write(`Usage: rig join <link>
+`);
+        process.exitCode = 1;
+        return { ok: true, group: "product", command: input.command };
+      }
+      if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write(`rig join requires an interactive terminal
+`);
+        process.exitCode = 1;
+        return { ok: true, group: "product", command: input.command };
+      }
+      await joinRigOmpProductSession({ projectRoot, link });
+    } else {
+      await runCli(resolved.argv);
+    }
+    return { ok: true, group: "product", command: input.command };
+  } finally {
+    restorePublicIdentityEnv();
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) {
+      delete process.env.RIG_PROJECT_ROOT;
+    } else {
+      process.env.RIG_PROJECT_ROOT = previousProjectRoot;
+    }
+  }
+}
+var RunIdentityEnvCap, TransportConfigCap, RunReadModelCap;
+var init_product_entrypoint = __esm(() => {
+  RunIdentityEnvCap = defineCapability(RUN_IDENTITY_ENV);
+  TransportConfigCap = defineCapability(TRANSPORT_CONFIG);
+  RunReadModelCap = defineCapability(RUN_READ_MODEL);
+});
+
+// packages/omp-extension-plugin/src/product-entrypoint/contributions.ts
+import { defineCapability as defineCapability2 } from "@rig/core/capability";
+import { PRODUCT_ENTRYPOINT } from "@rig/contracts";
+
+// packages/omp-extension-plugin/src/product-entrypoint/metadata.ts
+var STANDARD_PRODUCT_COMMANDS = [
+  { command: "launch", description: "Open the Rig Cockpit through the OMP collaboration substrate.", usage: "rig [launch] [args...]" },
+  { command: "join", description: "Join an encrypted Rig/OMP collaborative session.", usage: "rig join <link>" },
+  { command: "acp", description: "Start the Rig product in OMP ACP mode.", usage: "rig acp [args...]" },
+  { command: "models", description: "Delegate model management to the Rig product substrate.", usage: "rig models [args...]" },
+  { command: "mcp", description: "Delegate MCP management to the Rig product substrate.", usage: "rig mcp [args...]" },
+  { command: "update", description: "Delegate product update handling to the Rig product substrate.", usage: "rig update [args...]" }
+];
+function standardProductCliCommandId(command) {
+  return `@rig/omp-extension-plugin:${command}`;
+}
+function standardProductCliCommandMetadata(descriptor) {
+  return {
+    id: standardProductCliCommandId(descriptor.command),
+    family: descriptor.command,
+    description: descriptor.description,
+    usage: descriptor.usage,
+    projectRequired: false,
+    ...descriptor.command === "launch" ? { rootDefault: true } : {},
+    productRoot: true
+  };
+}
+
+// packages/omp-extension-plugin/src/product-entrypoint/contributions.ts
+var ProductEntrypointCap = defineCapability2(PRODUCT_ENTRYPOINT);
+async function importProductEntrypoint() {
+  return await Promise.resolve().then(() => (init_product_entrypoint(), exports_product_entrypoint));
+}
+function createStandardProductCliCommand(descriptor) {
+  return {
+    ...standardProductCliCommandMetadata(descriptor),
+    run: async (context, args) => {
+      const { runRigOmpProductCommand: runRigOmpProductCommand2 } = await importProductEntrypoint();
+      return runRigOmpProductCommand2({
+        projectRoot: context.projectRoot,
+        command: descriptor.command,
+        args
+      });
+    }
+  };
+}
+var productCliCommands = STANDARD_PRODUCT_COMMANDS.map(createStandardProductCliCommand);
+var productEntrypointCapability = ProductEntrypointCap.provide(async () => {
+  const { joinRigOmpProductSession: joinRigOmpProductSession2 } = await importProductEntrypoint();
+  return { joinSession: joinRigOmpProductSession2 };
+}, {
+  title: "Product entrypoint service",
+  description: "Join live product sessions via the cockpit-owned runtime entrypoint."
+});
+export {
+  productEntrypointCapability,
+  productCliCommands
+};

package/dist/src/product-entrypoint/metadata.d.ts

@@ -0,0 +1,17 @@
+export type RigProductCommandName = "launch" | "join" | "acp" | "models" | "mcp" | "update";
+export type StandardProductCommandDescriptor = {
+    readonly command: RigProductCommandName;
+    readonly description: string;
+    readonly usage: string;
+};
+export declare const STANDARD_PRODUCT_COMMANDS: readonly StandardProductCommandDescriptor[];
+export declare function standardProductCliCommandId(command: RigProductCommandName): string;
+export declare function standardProductCliCommandMetadata(descriptor: StandardProductCommandDescriptor): {
+    productRoot: boolean;
+    rootDefault?: boolean | undefined;
+    id: string;
+    family: RigProductCommandName;
+    description: string;
+    usage: string;
+    projectRequired: boolean;
+};

package/dist/src/product-entrypoint/metadata.js

@@ -0,0 +1,29 @@
+// @bun
+// packages/omp-extension-plugin/src/product-entrypoint/metadata.ts
+var STANDARD_PRODUCT_COMMANDS = [
+  { command: "launch", description: "Open the Rig Cockpit through the OMP collaboration substrate.", usage: "rig [launch] [args...]" },
+  { command: "join", description: "Join an encrypted Rig/OMP collaborative session.", usage: "rig join <link>" },
+  { command: "acp", description: "Start the Rig product in OMP ACP mode.", usage: "rig acp [args...]" },
+  { command: "models", description: "Delegate model management to the Rig product substrate.", usage: "rig models [args...]" },
+  { command: "mcp", description: "Delegate MCP management to the Rig product substrate.", usage: "rig mcp [args...]" },
+  { command: "update", description: "Delegate product update handling to the Rig product substrate.", usage: "rig update [args...]" }
+];
+function standardProductCliCommandId(command) {
+  return `@rig/omp-extension-plugin:${command}`;
+}
+function standardProductCliCommandMetadata(descriptor) {
+  return {
+    id: standardProductCliCommandId(descriptor.command),
+    family: descriptor.command,
+    description: descriptor.description,
+    usage: descriptor.usage,
+    projectRequired: false,
+    ...descriptor.command === "launch" ? { rootDefault: true } : {},
+    productRoot: true
+  };
+}
+export {
+  standardProductCliCommandMetadata,
+  standardProductCliCommandId,
+  STANDARD_PRODUCT_COMMANDS
+};

package/dist/src/product-entrypoint/plugin.d.ts

@@ -0,0 +1,4 @@
+export declare const PRODUCT_ENTRYPOINT_PLUGIN_NAME = "@rig/omp-extension-plugin";
+export declare const productEntrypointPlugin: import("@rig/core").RigPlugin;
+export declare function createProductEntrypointPlugin(): import("@rig/core").RigPlugin;
+export default productEntrypointPlugin;

package/dist/src/product-entrypoint/plugin.js

@@ -0,0 +1,300 @@
+// @bun
+var __defProp = Object.defineProperty;
+var __returnValue = (v) => v;
+function __exportSetter(name, newValue) {
+  this[name] = __returnValue.bind(null, newValue);
+}
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: __exportSetter.bind(all, name)
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// packages/omp-extension-plugin/src/product-entrypoint/product-entrypoint.ts
+var exports_product_entrypoint = {};
+__export(exports_product_entrypoint, {
+  runRigOmpProductCommand: () => runRigOmpProductCommand,
+  joinRigOmpProductSession: () => joinRigOmpProductSession
+});
+import { resolve } from "path";
+import { runCli } from "@oh-my-pi/pi-coding-agent/cli";
+import { parseArgs } from "@oh-my-pi/pi-coding-agent/cli/args";
+import { resolveCliArgv } from "@oh-my-pi/pi-coding-agent/cli-commands";
+import { prepareAcpTerminalAuthArgs } from "@oh-my-pi/pi-coding-agent/modes/acp/terminal-auth";
+import { runRootCommand } from "@oh-my-pi/pi-coding-agent/main";
+import { createAgentSession } from "@oh-my-pi/pi-coding-agent/sdk";
+import { defineCapability } from "@rig/core/capability";
+import { loadCapabilityForRoot } from "@rig/core/capability-loaders";
+import { resolvePluginHost } from "@rig/core/project-plugins";
+import { RUN_IDENTITY_ENV, RUN_READ_MODEL, TRANSPORT_CONFIG } from "@rig/contracts";
+async function withRigDefaultConfig(projectRoot, argv) {
+  const transportConfig = await loadCapabilityForRoot(projectRoot, TransportConfigCap);
+  if (!transportConfig)
+    throw new Error("TRANSPORT_CONFIG capability unavailable: load @rig/transport-plugin before launching OMP.");
+  return ["--config", transportConfig.resolveRigOmpConfigOverlayPath({ projectRoot }), ...argv];
+}
+async function createRigAgentSession(projectRoot, options = {}) {
+  const { host } = await resolvePluginHost(projectRoot);
+  const sessionExtensions = host.listSessionExtensions();
+  return createAgentSession({
+    ...options,
+    extensions: [...sessionExtensions.map((entry) => (api) => entry.install(api, { panels: host.listPanels() })), ...options.extensions ?? []]
+  });
+}
+function productArgv(input) {
+  if (input.command === "launch" && input.args.length === 0)
+    return [];
+  if (input.command === "launch" && input.args[0]?.startsWith("-"))
+    return [...input.args];
+  return [input.command, ...input.args];
+}
+async function joinRigOmpProductSession(input) {
+  const projectRoot = resolve(input.projectRoot);
+  const link = input.link.trim();
+  const previousProjectRoot = process.env.RIG_PROJECT_ROOT;
+  const previousCwd = process.cwd();
+  const identityEnv = await loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const restorePublicIdentityEnv = identityEnv?.applyIdentityEnv(projectRoot) ?? (() => {});
+  process.env.RIG_PROJECT_ROOT = projectRoot;
+  process.chdir(projectRoot);
+  try {
+    const args = await withRigDefaultConfig(projectRoot, []);
+    const parsed = parseArgs(args);
+    parsed.join = link;
+    await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    return { ok: true, group: "product", command: "join" };
+  } finally {
+    restorePublicIdentityEnv();
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) {
+      delete process.env.RIG_PROJECT_ROOT;
+    } else {
+      process.env.RIG_PROJECT_ROOT = previousProjectRoot;
+    }
+  }
+}
+async function runRigOmpProductCommand(input) {
+  const projectRoot = resolve(input.projectRoot);
+  const previousProjectRoot = process.env.RIG_PROJECT_ROOT;
+  const previousCwd = process.cwd();
+  const identityEnv = await loadCapabilityForRoot(projectRoot, RunIdentityEnvCap);
+  const restorePublicIdentityEnv = identityEnv?.applyIdentityEnv(projectRoot) ?? (() => {});
+  process.env.RIG_PROJECT_ROOT = projectRoot;
+  process.chdir(projectRoot);
+  try {
+    const argv = productArgv(input);
+    if (argv[0]?.startsWith("__omp_worker_") || argv[0] === "--smoke-test") {
+      await runCli(argv);
+      return { ok: true, group: "product", command: input.command };
+    }
+    if (process.stdin.isTTY) {
+      const readModel = await loadCapabilityForRoot(projectRoot, RunReadModelCap);
+      if (readModel) {
+        await readModel.reconcileActiveRuns({
+          workspaceRoot: projectRoot,
+          identityFilter: identityEnv?.identityFilterFromEnv() ?? {}
+        }).catch(() => ({ flipped: [], resumable: [] }));
+      }
+    }
+    const resolved = resolveCliArgv(argv);
+    if ("error" in resolved) {
+      process.stderr.write(`error: ${resolved.error}
+`);
+      process.exitCode = 1;
+      return { ok: true, group: "product", command: input.command };
+    }
+    const [ompCommand, ...ompCommandArgs] = resolved.argv;
+    if (ompCommand === "launch") {
+      const args = await withRigDefaultConfig(projectRoot, ompCommandArgs);
+      await runRootCommand(parseArgs(args), args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    } else if (ompCommand === "acp") {
+      const { args: preparedArgs, terminalAuth } = prepareAcpTerminalAuthArgs(ompCommandArgs);
+      const args = await withRigDefaultConfig(projectRoot, preparedArgs);
+      const parsed = parseArgs(args);
+      if (!terminalAuth)
+        parsed.mode = "acp";
+      await runRootCommand(parsed, args, { createAgentSession: (options) => createRigAgentSession(projectRoot, options) });
+    } else if (ompCommand === "join") {
+      const link = ompCommandArgs[0]?.trim();
+      if (!link) {
+        process.stderr.write(`Usage: rig join <link>
+`);
+        process.exitCode = 1;
+        return { ok: true, group: "product", command: input.command };
+      }
+      if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        process.stderr.write(`rig join requires an interactive terminal
+`);
+        process.exitCode = 1;
+        return { ok: true, group: "product", command: input.command };
+      }
+      await joinRigOmpProductSession({ projectRoot, link });
+    } else {
+      await runCli(resolved.argv);
+    }
+    return { ok: true, group: "product", command: input.command };
+  } finally {
+    restorePublicIdentityEnv();
+    process.chdir(previousCwd);
+    if (previousProjectRoot === undefined) {
+      delete process.env.RIG_PROJECT_ROOT;
+    } else {
+      process.env.RIG_PROJECT_ROOT = previousProjectRoot;
+    }
+  }
+}
+var RunIdentityEnvCap, TransportConfigCap, RunReadModelCap;
+var init_product_entrypoint = __esm(() => {
+  RunIdentityEnvCap = defineCapability(RUN_IDENTITY_ENV);
+  TransportConfigCap = defineCapability(TRANSPORT_CONFIG);
+  RunReadModelCap = defineCapability(RUN_READ_MODEL);
+});
+
+// packages/omp-extension-plugin/src/product-entrypoint/plugin.ts
+import { definePlugin } from "@rig/core/config";
+import { defineCapability as defineCapability3 } from "@rig/core/capability";
+import { HELP_CATALOG } from "@rig/contracts";
+
+// packages/omp-extension-plugin/src/product-entrypoint/contributions.ts
+import { defineCapability as defineCapability2 } from "@rig/core/capability";
+import { PRODUCT_ENTRYPOINT } from "@rig/contracts";
+
+// packages/omp-extension-plugin/src/product-entrypoint/metadata.ts
+var STANDARD_PRODUCT_COMMANDS = [
+  { command: "launch", description: "Open the Rig Cockpit through the OMP collaboration substrate.", usage: "rig [launch] [args...]" },
+  { command: "join", description: "Join an encrypted Rig/OMP collaborative session.", usage: "rig join <link>" },
+  { command: "acp", description: "Start the Rig product in OMP ACP mode.", usage: "rig acp [args...]" },
+  { command: "models", description: "Delegate model management to the Rig product substrate.", usage: "rig models [args...]" },
+  { command: "mcp", description: "Delegate MCP management to the Rig product substrate.", usage: "rig mcp [args...]" },
+  { command: "update", description: "Delegate product update handling to the Rig product substrate.", usage: "rig update [args...]" }
+];
+function standardProductCliCommandId(command) {
+  return `@rig/omp-extension-plugin:${command}`;
+}
+function standardProductCliCommandMetadata(descriptor) {
+  return {
+    id: standardProductCliCommandId(descriptor.command),
+    family: descriptor.command,
+    description: descriptor.description,
+    usage: descriptor.usage,
+    projectRequired: false,
+    ...descriptor.command === "launch" ? { rootDefault: true } : {},
+    productRoot: true
+  };
+}
+
+// packages/omp-extension-plugin/src/product-entrypoint/contributions.ts
+var ProductEntrypointCap = defineCapability2(PRODUCT_ENTRYPOINT);
+async function importProductEntrypoint() {
+  return await Promise.resolve().then(() => (init_product_entrypoint(), exports_product_entrypoint));
+}
+function createStandardProductCliCommand(descriptor) {
+  return {
+    ...standardProductCliCommandMetadata(descriptor),
+    run: async (context, args) => {
+      const { runRigOmpProductCommand: runRigOmpProductCommand2 } = await importProductEntrypoint();
+      return runRigOmpProductCommand2({
+        projectRoot: context.projectRoot,
+        command: descriptor.command,
+        args
+      });
+    }
+  };
+}
+var productCliCommands = STANDARD_PRODUCT_COMMANDS.map(createStandardProductCliCommand);
+var productEntrypointCapability = ProductEntrypointCap.provide(async () => {
+  const { joinRigOmpProductSession: joinRigOmpProductSession2 } = await importProductEntrypoint();
+  return { joinSession: joinRigOmpProductSession2 };
+}, {
+  title: "Product entrypoint service",
+  description: "Join live product sessions via the cockpit-owned runtime entrypoint."
+});
+
+// packages/omp-extension-plugin/src/product-entrypoint/product-help.ts
+var TOP_LEVEL_SECTIONS = [
+  {
+    title: "Open Rig",
+    subtitle: "the cockpit \u2014 bare rig opens the Rig Cockpit inside an OMP collab session",
+    commands: [
+      {
+        command: "rig",
+        description: "Open the Rig Cockpit (OMP collaboration substrate) for the current workspace.",
+        usecase: "Day-to-day entry point: drive everything (tasks, runs, inbox) from the board.",
+        examples: ["cd my-project && rig", "rig            # in a repo with rig.config.ts"]
+      },
+      {
+        command: "rig --workspace <path>",
+        description: "Open the cockpit for another workspace instead of the current dir.",
+        usecase: "Operate a project without cd-ing into it.",
+        examples: ["rig --workspace ~/work/humanwork", "rig --workspace ../other-repo"]
+      },
+      {
+        command: "rig join <link>",
+        description: "Join an encrypted OMP collaborative session from another operator.",
+        usecase: "Pair on a teammate's live run from the join link they shared.",
+        examples: ["rig join where.rig-does.work/r/AbC123\u2026"]
+      },
+      { command: "/rig", description: "From inside an OMP session, (re)open the Rig Cockpit screen.", usecase: "Jump back to the board after dropping into the raw agent session." },
+      { command: "rig --version", description: "Print the installed Rig CLI version.", examples: ["rig --version"] }
+    ]
+  }
+];
+var ADVANCED_COMMANDS = [
+  { command: "rig server task-run ...", description: "Internal legacy server-owned task execution entry point." },
+  { command: "rig server notify-test [--event <type>]", description: "Internal diagnostic event notification smoke command." },
+  { command: "rig run start|start-serial|start-parallel", description: "Legacy/internal queue starters; not the Rig Cockpit task-detail dispatch path." },
+  { command: "rig remote orchestrate-*", description: "Legacy automation-only remote orchestration commands." }
+];
+function assembleHelpCatalog(commands) {
+  const seen = new Set;
+  const groups = [];
+  for (const command of commands) {
+    const helpDoc = command.helpDoc;
+    if (!helpDoc || seen.has(helpDoc.name))
+      continue;
+    seen.add(helpDoc.name);
+    groups.push(helpDoc);
+  }
+  const advancedGroupNames = groups.filter((group) => group.advancedOnly).map((group) => group.name);
+  return {
+    sections: TOP_LEVEL_SECTIONS,
+    groups,
+    advancedCommands: ADVANCED_COMMANDS,
+    advancedGroupNames
+  };
+}
+
+// packages/omp-extension-plugin/src/product-entrypoint/plugin.ts
+var PRODUCT_ENTRYPOINT_PLUGIN_NAME = "@rig/omp-extension-plugin";
+var HelpCatalogCap = defineCapability3(HELP_CATALOG);
+var helpCatalogService = { helpCatalog: assembleHelpCatalog };
+var productEntrypointPlugin = definePlugin({
+  name: PRODUCT_ENTRYPOINT_PLUGIN_NAME,
+  version: "0.0.0-alpha.1",
+  effects: { spawnsProcesses: true, readsFiles: true, contributesCliCommands: true },
+  contributes: {
+    cliCommands: [...productCliCommands],
+    capabilities: [
+      productEntrypointCapability,
+      HelpCatalogCap.provide(() => helpCatalogService, {
+        title: "Rig help catalog",
+        description: "Product-help intro framing + per-command help groups assembled from contributed commands' helpDoc."
+      })
+    ]
+  }
+});
+function createProductEntrypointPlugin() {
+  return productEntrypointPlugin;
+}
+var plugin_default = productEntrypointPlugin;
+export {
+  productEntrypointPlugin,
+  plugin_default as default,
+  createProductEntrypointPlugin,
+  PRODUCT_ENTRYPOINT_PLUGIN_NAME
+};

package/dist/src/product-entrypoint/product-entrypoint.d.ts

@@ -0,0 +1,14 @@
+import { type ProductEntrypointJoinSessionInput, type ProductEntrypointJoinSessionResult } from "@rig/contracts";
+import type { RigProductCommandName } from "./metadata";
+export type RunRigOmpProductCommandInput = {
+    readonly projectRoot: string;
+    readonly command: RigProductCommandName;
+    readonly args: readonly string[];
+};
+export type JoinRigOmpProductSessionInput = ProductEntrypointJoinSessionInput;
+export declare function joinRigOmpProductSession(input: JoinRigOmpProductSessionInput): Promise<ProductEntrypointJoinSessionResult>;
+export declare function runRigOmpProductCommand(input: RunRigOmpProductCommandInput): Promise<{
+    ok: true;
+    group: string;
+    command: string;
+}>;