@unbrained/pm-cli 2026.6.23 → 2026.6.30

package/packages/pm-guide-shell/extensions/guide-shell/index.js

@@ -1,98 +0,0 @@
-import {
-  renderGuideShellPackageOutput,
-  runCompletionPackage,
-  runCompletionStatusesPackage,
-  runCompletionTagsPackage,
-  runCompletionTypesPackage,
-  runGuidePackage,
-} from "./runtime.js";
-
-export const manifest = {
-  name: "builtin-guide-shell",
-  version: "0.1.0",
-  entry: "./index.js",
-  priority: 0,
-  capabilities: ["commands", "schema", "services"],
-};
-
-const guideFlags = [
-  { long: "--list", value_type: "boolean", description: "List available guide topics." },
-  { long: "--format", value_name: "value", value_type: "string", description: "Output format override: markdown|toon|json." },
-  { long: "--depth", value_name: "value", value_type: "string", description: "Guide detail depth." },
-  { long: "--topic", value_name: "value", value_type: "string", description: "Explicit guide topic override." },
-];
-
-const completionFlags = [
-  { long: "--shell", value_name: "value", value_type: "string", description: "Completion target shell: bash|zsh|fish." },
-  { long: "--item-types", value_name: "csv", value_type: "string", description: "Filter completion item types." },
-  { long: "--item_types", value_name: "csv", value_type: "string", description: "Alias for --item-types." },
-  { long: "--tags", value_name: "csv", value_type: "string", description: "Filter completion tags." },
-  { long: "--eager-tags", value_type: "boolean", description: "Expand all tag suggestions eagerly." },
-  { long: "--eager_tags", value_type: "boolean", description: "Alias for --eager-tags." },
-];
-
-function guideCommand() {
-  return {
-    name: "guide",
-    action: "guide",
-    description: "Show migration and usage guidance for pm command families.",
-    arguments: [{ name: "topic", required: false, description: "Optional guide topic." }],
-    flags: [...guideFlags],
-    run: async (context) => runGuidePackage(context.args, context.options, context.global),
-  };
-}
-
-function completionCommand() {
-  return {
-    name: "completion",
-    action: "completion",
-    description: "Generate shell completion scripts for bash, zsh, and fish.",
-    arguments: [{ name: "shell", required: false, description: "Target shell (bash|zsh|fish)." }],
-    flags: [...completionFlags],
-    run: async (context) => runCompletionPackage(context.args, context.options, context.global),
-  };
-}
-
-function completionTagsCommand() {
-  return {
-    name: "completion-tags",
-    action: "completion-tags",
-    description: "Print known tags for completion filters.",
-    run: async (context) => runCompletionTagsPackage(context.global),
-  };
-}
-
-function completionStatusesCommand() {
-  return {
-    name: "completion-statuses",
-    action: "completion-statuses",
-    description: "Print runtime status IDs for completion filters.",
-    run: async (context) => runCompletionStatusesPackage(context.global),
-  };
-}
-
-function completionTypesCommand() {
-  return {
-    name: "completion-types",
-    action: "completion-types",
-    description: "Print runtime item type IDs for completion filters.",
-    run: async (context) => runCompletionTypesPackage(context.global),
-  };
-}
-
-export function activate(api) {
-  api.registerCommand(guideCommand());
-  api.registerCommand(completionCommand());
-  api.registerCommand(completionTagsCommand());
-  api.registerCommand(completionStatusesCommand());
-  api.registerCommand(completionTypesCommand());
-  api.registerService("output_format", (context) => {
-    const rendered = renderGuideShellPackageOutput(context);
-    return rendered ?? null;
-  });
-}
-
-export default {
-  manifest,
-  activate,
-};

package/packages/pm-guide-shell/extensions/guide-shell/runtime.js

@@ -1,294 +0,0 @@
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-const PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
-let runtimeBundle = null;
-let runtimeBundlePromise = null;
-
-async function ensureRuntimeBundle() {
-  if (runtimeBundle) {
-    return runtimeBundle;
-  }
-  if (!runtimeBundlePromise) {
-    runtimeBundlePromise = loadRuntimeBundle();
-  }
-  runtimeBundle = await runtimeBundlePromise;
-  return runtimeBundle;
-}
-
-async function loadRuntimeBundle() {
-  const envRoot = process.env[PM_PACKAGE_ROOT_ENV];
-  if (typeof envRoot !== "string" || envRoot.trim().length === 0) {
-    throw new Error(
-      `builtin-guide-shell requires ${PM_PACKAGE_ROOT_ENV} to locate core SDK runtime exports.`,
-    );
-  }
-  const modulePath = path.join(path.resolve(envRoot.trim()), "dist", "sdk", "runtime.js");
-  try {
-    const sdkLoaded = await import(pathToFileURL(modulePath).href);
-    if (
-      typeof sdkLoaded.runGuide === "function" &&
-      typeof sdkLoaded.resolveGuideOutputFormat === "function" &&
-      typeof sdkLoaded.renderGuideMarkdown === "function" &&
-      typeof sdkLoaded.runCompletion === "function" &&
-      typeof sdkLoaded.pathExists === "function" &&
-      typeof sdkLoaded.getSettingsPath === "function" &&
-      typeof sdkLoaded.resolvePmRoot === "function" &&
-      typeof sdkLoaded.readSettings === "function" &&
-      typeof sdkLoaded.resolveItemTypeRegistry === "function" &&
-      typeof sdkLoaded.resolveRuntimeStatusRegistry === "function" &&
-      typeof sdkLoaded.resolveRuntimeFieldRegistry === "function" &&
-      typeof sdkLoaded.listAllFrontMatter === "function" &&
-      typeof sdkLoaded.getActiveExtensionRegistrations === "function" &&
-      typeof sdkLoaded.readStringOption === "function" &&
-      typeof sdkLoaded.readBooleanOption === "function" &&
-      typeof sdkLoaded.readCsvListOption === "function"
-    ) {
-      return {
-        sdk: sdkLoaded,
-      };
-    }
-  } catch {
-    // Fall through to deterministic failure message below.
-  }
-  throw new Error(
-    `builtin-guide-shell failed to load guide/completion SDK runtime exports from ${modulePath}.`,
-  );
-}
-
-function normalizeGuideOptions(bundle, args, options) {
-  const { readStringOption, readBooleanOption } = bundle.sdk;
-  const topicFromArgs = args[0];
-  return {
-    topic: readStringOption(options, "topic") ?? (typeof topicFromArgs === "string" && topicFromArgs.trim().length > 0 ? topicFromArgs : undefined),
-    list: readBooleanOption(options, "list") === true ? true : undefined,
-    format: readStringOption(options, "format"),
-    depth: readStringOption(options, "depth"),
-  };
-}
-
-function normalizeCompletionOptions(bundle, args, options) {
-  const { readStringOption, readBooleanOption, readCsvListOption } = bundle.sdk;
-  const shellFromOptions = readStringOption(options, "shell");
-  const shellFromArgs = typeof args[0] === "string" && args[0].trim().length > 0 ? args[0].trim() : undefined;
-  return {
-    shell: shellFromOptions ?? shellFromArgs ?? "bash",
-    itemTypes: readCsvListOption(options, "itemTypes", ["item_types"]),
-    tags: readCsvListOption(options, "tags"),
-    eagerTags: readBooleanOption(options, "eagerTags", ["eager_tags"]) === true,
-  };
-}
-
-function collectTypeNames(typeRegistry) {
-  const candidates = Array.isArray(typeRegistry.types)
-    ? typeRegistry.types
-    : Array.isArray(typeRegistry.definitions)
-      ? typeRegistry.definitions
-          .filter((definition) => Boolean(definition))
-          .map((definition) => definition.name)
-      : [];
-  return [...new Set(candidates.filter((value) => typeof value === "string" && value.trim().length > 0))]
-    .sort((left, right) => left.localeCompare(right));
-}
-
-function collectTypeToFolder(typeRegistry) {
-  if (typeof typeRegistry.type_to_folder === "object" && typeRegistry.type_to_folder !== null) {
-    return typeRegistry.type_to_folder;
-  }
-  return Object.fromEntries(
-    (typeRegistry.definitions ?? [])
-      .filter((definition) => Boolean(definition?.name && definition?.folder))
-      .map((definition) => [definition.name, definition.folder]),
-  );
-}
-
-async function buildCompletionRuntimeConfig(bundle, global) {
-  const pmRoot = bundle.sdk.resolvePmRoot(process.cwd(), global.path);
-  if (!(await bundle.sdk.pathExists(bundle.sdk.getSettingsPath(pmRoot)))) {
-    return {};
-  }
-  const settings = await bundle.sdk.readSettings(pmRoot);
-  const registrations = bundle.sdk.getActiveExtensionRegistrations();
-  const typeRegistry = bundle.sdk.resolveItemTypeRegistry(settings, registrations);
-  const itemTypes = collectTypeNames(typeRegistry);
-  const schema = settings.schema;
-  const statuses = bundle.sdk.resolveRuntimeStatusRegistry(schema).definitions
-    .map((definition) => definition.id)
-    .filter((status) => typeof status === "string" && status.trim().length > 0)
-    .sort((left, right) => left.localeCompare(right));
-  const fieldRegistry = bundle.sdk.resolveRuntimeFieldRegistry(schema);
-  const runtimeCommands = ["list", "create", "update", "update-many", "search", "calendar", "context"];
-  const commandFlags = {};
-  for (const command of runtimeCommands) {
-    const definitions = fieldRegistry.command_to_fields.get(command) ?? [];
-    const flags = [
-      ...new Set(
-        definitions
-          .map((definition) => definition.cli_flag)
-          .filter((value) => typeof value === "string" && value.trim().length > 0)
-          .map((value) => `--${value.trim().replaceAll("_", "-")}`),
-      ),
-    ].sort((left, right) => left.localeCompare(right));
-    if (flags.length > 0) {
-      commandFlags[command] = flags;
-    }
-  }
-  return {
-    item_types: itemTypes.length > 0 ? itemTypes : undefined,
-    statuses: statuses.length > 0 ? statuses : undefined,
-    command_flags: Object.keys(commandFlags).length > 0 ? commandFlags : undefined,
-  };
-}
-
-function readPayloadFormat(payload) {
-  if (typeof payload === "object" && payload !== null) {
-    const format = payload.format;
-    if (format === "json") {
-      return "json";
-    }
-  }
-  return "toon";
-}
-
-function readPayloadResult(payload) {
-  if (typeof payload === "object" && payload !== null && "result" in payload) {
-    return payload.result;
-  }
-  return payload;
-}
-
-function collectTagsFromItems(items) {
-  const tagSet = new Set();
-  for (const item of items) {
-    const tags = Array.isArray(item.metadata.tags) ? item.metadata.tags : [];
-    for (const tag of tags) {
-      if (typeof tag === "string" && tag.trim().length > 0) {
-        tagSet.add(tag.trim());
-      }
-    }
-  }
-  return [...tagSet].sort((left, right) => left.localeCompare(right));
-}
-
-export async function runGuidePackage(args, options, global) {
-  const bundle = await ensureRuntimeBundle();
-  return bundle.sdk.runGuide(normalizeGuideOptions(bundle, args, options), global);
-}
-
-export async function runCompletionPackage(args, options, global) {
-  const bundle = await ensureRuntimeBundle();
-  const normalized = normalizeCompletionOptions(bundle, args, options);
-  const runtimeConfig = await buildCompletionRuntimeConfig(bundle, global);
-  return bundle.sdk.runCompletion(
-    normalized.shell,
-    normalized.itemTypes,
-    normalized.tags,
-    normalized.eagerTags,
-    runtimeConfig,
-  );
-}
-
-export async function runCompletionTagsPackage(global) {
-  const bundle = await ensureRuntimeBundle();
-  const pmRoot = bundle.sdk.resolvePmRoot(process.cwd(), global.path);
-  if (!(await bundle.sdk.pathExists(bundle.sdk.getSettingsPath(pmRoot)))) {
-    return { tags: [], count: 0 };
-  }
-  const settings = await bundle.sdk.readSettings(pmRoot);
-  const registrations = bundle.sdk.getActiveExtensionRegistrations();
-  const typeRegistry = bundle.sdk.resolveItemTypeRegistry(settings, registrations);
-  const typeToFolder = collectTypeToFolder(typeRegistry);
-  const schema = settings.schema;
-  const itemFormat = settings.item_format === "json_markdown" ? "json_markdown" : "toon";
-  const items = await bundle.sdk.listAllFrontMatter(pmRoot, itemFormat, typeToFolder, undefined, schema);
-  const tags = collectTagsFromItems(items);
-  return {
-    tags,
-    count: tags.length,
-  };
-}
-
-export async function runCompletionStatusesPackage(global) {
-  const bundle = await ensureRuntimeBundle();
-  const pmRoot = bundle.sdk.resolvePmRoot(process.cwd(), global.path);
-  const settings = await bundle.sdk.readSettings(pmRoot);
-  const schema = settings.schema;
-  const statuses = bundle.sdk.resolveRuntimeStatusRegistry(schema).definitions
-    .map((definition) => definition.id)
-    .filter((status) => typeof status === "string" && status.trim().length > 0)
-    .sort((left, right) => left.localeCompare(right));
-  return {
-    statuses,
-    count: statuses.length,
-  };
-}
-
-export async function runCompletionTypesPackage(global) {
-  const bundle = await ensureRuntimeBundle();
-  const pmRoot = bundle.sdk.resolvePmRoot(process.cwd(), global.path);
-  const settings = await bundle.sdk.readSettings(pmRoot);
-  const registrations = bundle.sdk.getActiveExtensionRegistrations();
-  const typeRegistry = bundle.sdk.resolveItemTypeRegistry(settings, registrations);
-  const types = collectTypeNames(typeRegistry);
-  return {
-    types,
-    count: types.length,
-  };
-}
-
-export function renderGuideShellPackageOutput(context) {
-  if (!runtimeBundle) {
-    return null;
-  }
-  const result = readPayloadResult(context.payload);
-  if (context.command === "guide") {
-    const options = context.options ?? {};
-    const global = context.global ?? {};
-    const outputFormat = runtimeBundle.sdk.resolveGuideOutputFormat(options, global);
-    if (outputFormat === "markdown") {
-      return `${runtimeBundle.sdk.renderGuideMarkdown(result)}\n`;
-    }
-    if (outputFormat === "json" || readPayloadFormat(context.payload) === "json") {
-      return `${JSON.stringify(result, null, 2)}\n`;
-    }
-    return null;
-  }
-  if (context.command === "completion") {
-    if (readPayloadFormat(context.payload) === "json") {
-      return `${JSON.stringify(result, null, 2)}\n`;
-    }
-    if (typeof result === "object" && result !== null && typeof result.script === "string") {
-      const script = result.script;
-      return script.endsWith("\n") ? script : `${script}\n`;
-    }
-    return null;
-  }
-  if (context.command === "completion-tags") {
-    if (readPayloadFormat(context.payload) === "json") {
-      return `${JSON.stringify(result, null, 2)}\n`;
-    }
-    const tags = typeof result === "object" && result !== null && Array.isArray(result.tags)
-      ? result.tags.filter((entry) => typeof entry === "string")
-      : [];
-    return `${tags.join(" ")}\n`;
-  }
-  if (context.command === "completion-statuses") {
-    if (readPayloadFormat(context.payload) === "json") {
-      return `${JSON.stringify(result, null, 2)}\n`;
-    }
-    const statuses = typeof result === "object" && result !== null && Array.isArray(result.statuses)
-      ? result.statuses.filter((entry) => typeof entry === "string")
-      : [];
-    return `${statuses.join(" ")}\n`;
-  }
-  if (context.command === "completion-types") {
-    if (readPayloadFormat(context.payload) === "json") {
-      return `${JSON.stringify(result, null, 2)}\n`;
-    }
-    const types = typeof result === "object" && result !== null && Array.isArray(result.types)
-      ? result.types.filter((entry) => typeof entry === "string")
-      : [];
-    return `${types.join(" ")}\n`;
-  }
-  return null;
-}

package/packages/pm-lifecycle-hooks/extensions/lifecycle-hooks/index.js

@@ -1,18 +0,0 @@
-export const manifest = {
-  name: "builtin-lifecycle-hooks",
-  version: "0.1.0",
-  entry: "./index.js",
-  priority: 0,
-  capabilities: ["hooks"],
-};
-
-export function activate(api) {
-  // First-party hooks exemplar: default-inert lifecycle observation with no
-  // output, writes, or command-specific behavior.
-  api.hooks.afterCommand(() => undefined);
-}
-
-export default {
-  manifest,
-  activate,
-};

package/packages/pm-linked-test-adapters/extensions/linked-test-adapters/index.js

@@ -1,124 +0,0 @@
-import {
-  runTestRunsListPackage,
-  runTestRunsLogsPackage,
-  runTestRunsResumePackage,
-  runTestRunsStatusPackage,
-  runTestRunsStopPackage,
-} from "./runtime.js";
-
-export const manifest = {
-  name: "builtin-linked-test-adapters",
-  version: "0.1.0",
-  entry: "./index.js",
-  priority: 0,
-  capabilities: ["commands", "schema"],
-};
-
-function assertNoArgs(args, commandName) {
-  if (args.some((arg) => arg.trim().length > 0)) {
-    throw new Error(`${commandName} does not accept positional arguments.`);
-  }
-}
-
-function assertSingleRunId(args, commandName) {
-  const runId = args[0];
-  if (typeof runId !== "string" || runId.trim().length === 0) {
-    throw new Error(`${commandName} requires a runId argument.`);
-  }
-  if (args.length > 1) {
-    throw new Error(`${commandName} accepts exactly one runId argument.`);
-  }
-  return args;
-}
-
-function testRunsCommand() {
-  return {
-    name: "test-runs",
-    action: "test-runs-list",
-    description: "List background linked-test runs.",
-    flags: [
-      { long: "--status", value_name: "value", value_type: "string", description: "Filter by background run status." },
-      { long: "--limit", value_name: "n", value_type: "string", description: "Limit number of runs returned." },
-    ],
-    run: async (context) => {
-      assertNoArgs(context.args, "test-runs");
-      return runTestRunsListPackage(context.options, context.global);
-    },
-  };
-}
-
-function testRunsListCommand() {
-  return {
-    name: "test-runs list",
-    action: "test-runs-list",
-    description: "List background linked-test runs.",
-    flags: [
-      { long: "--status", value_name: "value", value_type: "string", description: "Filter by background run status." },
-      { long: "--limit", value_name: "n", value_type: "string", description: "Limit number of runs returned." },
-    ],
-    run: async (context) => {
-      assertNoArgs(context.args, "test-runs list");
-      return runTestRunsListPackage(context.options, context.global);
-    },
-  };
-}
-
-function testRunsStatusCommand() {
-  return {
-    name: "test-runs status",
-    action: "test-runs-status",
-    description: "Show status and health snapshot for a background linked-test run.",
-    arguments: [{ name: "runId", required: true, description: "Background run id." }],
-    run: async (context) => runTestRunsStatusPackage(assertSingleRunId(context.args, "test-runs status"), context.global),
-  };
-}
-
-function testRunsLogsCommand() {
-  return {
-    name: "test-runs logs",
-    action: "test-runs-logs",
-    description: "Show tailed logs for a background linked-test run.",
-    arguments: [{ name: "runId", required: true, description: "Background run id." }],
-    flags: [
-      { long: "--stream", value_name: "value", value_type: "string", description: "Log stream selector: stdout|stderr|both." },
-      { long: "--tail", value_name: "n", value_type: "string", description: "Tail number of lines per selected stream." },
-    ],
-    run: async (context) => runTestRunsLogsPackage(assertSingleRunId(context.args, "test-runs logs"), context.options, context.global),
-  };
-}
-
-function testRunsStopCommand() {
-  return {
-    name: "test-runs stop",
-    action: "test-runs-stop",
-    description: "Stop a running background linked-test run.",
-    arguments: [{ name: "runId", required: true, description: "Background run id." }],
-    flags: [{ long: "--force", value_type: "boolean", description: "Force-stop via SIGKILL." }],
-    run: async (context) => runTestRunsStopPackage(assertSingleRunId(context.args, "test-runs stop"), context.options, context.global),
-  };
-}
-
-function testRunsResumeCommand() {
-  return {
-    name: "test-runs resume",
-    action: "test-runs-resume",
-    description: "Resume a terminal background linked-test run by starting a new attempt.",
-    arguments: [{ name: "runId", required: true, description: "Background run id." }],
-    flags: [{ long: "--author", value_name: "value", value_type: "string", description: "Resume author override." }],
-    run: async (context) => runTestRunsResumePackage(assertSingleRunId(context.args, "test-runs resume"), context.options, context.global),
-  };
-}
-
-export function activate(api) {
-  api.registerCommand(testRunsCommand());
-  api.registerCommand(testRunsListCommand());
-  api.registerCommand(testRunsStatusCommand());
-  api.registerCommand(testRunsLogsCommand());
-  api.registerCommand(testRunsStopCommand());
-  api.registerCommand(testRunsResumeCommand());
-}
-
-export default {
-  manifest,
-  activate,
-};

package/packages/pm-linked-test-adapters/extensions/linked-test-adapters/runtime.js

@@ -1,110 +0,0 @@
-import path from "node:path";
-import { pathToFileURL } from "node:url";
-
-const PM_PACKAGE_ROOT_ENV = "PM_CLI_PACKAGE_ROOT";
-let runtimeBundle = null;
-let runtimeBundlePromise = null;
-
-async function ensureRuntimeBundle() {
-  if (runtimeBundle) {
-    return runtimeBundle;
-  }
-  if (!runtimeBundlePromise) {
-    runtimeBundlePromise = loadRuntimeBundle();
-  }
-  runtimeBundle = await runtimeBundlePromise;
-  return runtimeBundle;
-}
-
-async function loadRuntimeBundle() {
-  const envRoot = process.env[PM_PACKAGE_ROOT_ENV];
-  if (typeof envRoot !== "string" || envRoot.trim().length === 0) {
-    throw new Error(
-      `builtin-linked-test-adapters requires ${PM_PACKAGE_ROOT_ENV} to locate core SDK runtime exports.`,
-    );
-  }
-  const modulePath = path.join(path.resolve(envRoot.trim()), "dist", "sdk", "runtime.js");
-  try {
-    const sdkLoaded = await import(pathToFileURL(modulePath).href);
-    if (
-      typeof sdkLoaded.runTestRunsList === "function" &&
-      typeof sdkLoaded.runTestRunsStatus === "function" &&
-      typeof sdkLoaded.runTestRunsLogs === "function" &&
-      typeof sdkLoaded.runTestRunsStop === "function" &&
-      typeof sdkLoaded.runTestRunsResume === "function" &&
-      typeof sdkLoaded.PmCliError === "function" &&
-      typeof sdkLoaded.readStringOption === "function" &&
-      typeof sdkLoaded.readBooleanOption === "function" &&
-      typeof sdkLoaded.EXIT_CODE === "object" &&
-      sdkLoaded.EXIT_CODE !== null
-    ) {
-      return {
-        sdk: sdkLoaded,
-      };
-    }
-  } catch {
-    // Fall through to deterministic failure message below.
-  }
-  throw new Error(
-    `builtin-linked-test-adapters failed to load test-runs SDK runtime exports from ${modulePath}.`,
-  );
-}
-
-function requireRunId(bundle, commandName, args) {
-  const runId = args[0];
-  if (typeof runId === "string" && runId.trim().length > 0) {
-    return runId.trim();
-  }
-  throw new bundle.sdk.PmCliError(`${commandName} requires a runId argument.`, bundle.sdk.EXIT_CODE.USAGE);
-}
-
-export async function runTestRunsListPackage(options, global) {
-  const bundle = await ensureRuntimeBundle();
-  return bundle.sdk.runTestRunsList(
-    {
-      status: bundle.sdk.readStringOption(options, "status"),
-      limit: bundle.sdk.readStringOption(options, "limit"),
-    },
-    global,
-  );
-}
-
-export async function runTestRunsStatusPackage(args, global) {
-  const bundle = await ensureRuntimeBundle();
-  return bundle.sdk.runTestRunsStatus(requireRunId(bundle, "test-runs status", args), global);
-}
-
-export async function runTestRunsLogsPackage(args, options, global) {
-  const bundle = await ensureRuntimeBundle();
-  return bundle.sdk.runTestRunsLogs(
-    requireRunId(bundle, "test-runs logs", args),
-    {
-      stream: bundle.sdk.readStringOption(options, "stream"),
-      tail: bundle.sdk.readStringOption(options, "tail"),
-    },
-    global,
-  );
-}
-
-export async function runTestRunsStopPackage(args, options, global) {
-  const bundle = await ensureRuntimeBundle();
-  return bundle.sdk.runTestRunsStop(
-    requireRunId(bundle, "test-runs stop", args),
-    {
-      force: bundle.sdk.readBooleanOption(options, "force") === true,
-    },
-    global,
-  );
-}
-
-export async function runTestRunsResumePackage(args, options, global) {
-  const bundle = await ensureRuntimeBundle();
-  return bundle.sdk.runTestRunsResume(
-    requireRunId(bundle, "test-runs resume", args),
-    {
-      author: bundle.sdk.readStringOption(options, "author"),
-      noExtensions: global.noExtensions === true,
-    },
-    global,
-  );
-}