@unbrained/pm-cli 2026.7.6 → 2026.7.7

package/dist/cli-bundle/chunks/{chunk-TULGS6X6.js → chunk-QFBSP3NI.js}

@@ -1,18 +1,8 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="3b2e2c0b-d9a3-51c6-ba51-0bad9aa69284")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="59bf43ec-201a-5ebc-b1f7-9e467826b815")}catch(e){}}();
 import {
-  looksLikeStructuredLinkedTestEntry,
-  normalizeStructuredLinkedTestEntry,
-  parseLinkedTestAssertionEqualsMap,
-  parseLinkedTestAssertionGteMap,
-  parseLinkedTestBoolean,
-  parseLinkedTestContextMode,
-  parseLinkedTestEnvClear,
-  parseLinkedTestEnvSet,
-  parseLinkedTestMinLines,
-  parseLinkedTestRegexList,
-  parseLinkedTestStringList
-} from "./chunk-RFNYTESG.js";
+  getFocusedItem
+} from "./chunk-EDO7VXSO.js";
 import {
   assertNoUnknownCsvKeys,
   createStdinTokenResolver,
@@ -21,54 +11,48 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-IWVU4C2F.js";
-import {
-  getFocusedItem
-} from "./chunk-XG625QP4.js";
-import {
-  printError
-} from "./chunk-MLIYFOE7.js";
-import {
-  acquireLock,
-  appendHistoryEntry,
-  applyRegisteredItemFieldDefaultsAndValidation,
-  collectRegisteredItemFieldNames,
-  createHistoryEntry,
-  locateItem,
-  parseRegisteredItemFieldAssignments
-} from "./chunk-ENGQOEUY.js";
+} from "./chunk-DR2V5OIV.js";
 import {
   assertParentReferenceIsNotSelf,
   isPlaceholderReferenceToken,
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-7WBAJSS6.js";
+} from "./chunk-6UQCNWFV.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-VLEA2UTQ.js";
 import {
+  splitCommaList
+} from "./chunk-P4SESZGT.js";
+import {
+  printError
+} from "./chunk-EOUVR7JN.js";
+import {
+  PmCliError,
+  acquireLock,
+  appendHistoryEntry,
+  applyRegisteredItemFieldDefaultsAndValidation,
   canonicalDocument,
+  collectRegisteredItemFieldNames,
   collectRuntimeCreateFieldValues,
+  createHistoryEntry,
   generateItemId,
+  getActiveExtensionRegistrations,
+  locateItem,
   normalizeFrontMatter,
   normalizeItemId,
   normalizeStatusInput,
-  serializeItemDocument
-} from "./chunk-G24G7ZAV.js";
-import {
   nowIso,
-  resolveIsoOrRelative
-} from "./chunk-3GCS5SKL.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
+  parseRegisteredItemFieldAssignments,
   projectAfterCommandItemSnapshot,
   readSettings,
   recordAfterCommandAffectedItem,
+  resolveIsoOrRelative,
   runActiveCommandHandler,
-  runActiveOnWriteHooks
-} from "./chunk-E3SZTQ4K.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-KUOOJR35.js";
+  runActiveOnWriteHooks,
+  serializeItemDocument
+} from "./chunk-GH73UOSJ.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   CREATE_DIRECT_CLOSE_REASON_DEFAULT,
@@ -99,7 +83,7 @@ import {
   validateTypeOptions,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-57NWPFF2.js";
+} from "./chunk-UO7XAZK6.js";
 
 // dist/core/item/priority.js
 var PRIORITY_NAME_TO_VALUE = {
@@ -270,6 +254,491 @@ function suggestNextLifecycleTransition(id, type, status, statusRegistry) {
   return { command: `pm start-task ${id}`, to_status: inProgress };
 }
 
+// dist/cli/commands/linked-test-entry.js
+var STRUCTURED_LINKED_TEST_KEYS = [
+  "command",
+  "cmd",
+  "path",
+  "scope",
+  "timeout",
+  "timeout_seconds",
+  "pm_context_mode",
+  "env_set",
+  "env_clear",
+  "shared_host_safe",
+  "assert_stdout_contains",
+  "assert_stdout_regex",
+  "assert_stderr_contains",
+  "assert_stderr_regex",
+  "assert_stdout_min_lines",
+  "assert_json_field_equals",
+  "assert_json_field_gte",
+  "note"
+];
+var STRUCTURED_LINKED_TEST_KEY_SET = new Set(STRUCTURED_LINKED_TEST_KEYS);
+var STRUCTURED_LINKED_TEST_KEY_PATTERN = STRUCTURED_LINKED_TEST_KEYS.map((key) => key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")).join("|");
+var STRUCTURED_LINKED_TEST_ENTRY_PATTERN = new RegExp(`^(?:[-*+]\\s+)?(?:${STRUCTURED_LINKED_TEST_KEY_PATTERN})\\s*[:=]`, "i");
+function looksLikeStructuredLinkedTestEntry(raw) {
+  if (raw.startsWith("```") || raw.includes("\n")) {
+    return true;
+  }
+  return STRUCTURED_LINKED_TEST_ENTRY_PATTERN.test(raw);
+}
+function normalizeStructuredLinkedTestEntry(kv, optionName) {
+  const normalizedKv = {};
+  const unknownKeys = [];
+  for (const [key, value] of Object.entries(kv)) {
+    const normalizedKey = key.toLowerCase();
+    if (!STRUCTURED_LINKED_TEST_KEY_SET.has(normalizedKey)) {
+      unknownKeys.push(key);
+      continue;
+    }
+    normalizedKv[normalizedKey] = value;
+  }
+  if (unknownKeys.length > 0) {
+    throw new PmCliError(`${optionName} does not recognize key${unknownKeys.length > 1 ? "s" : ""} ${unknownKeys.map((key) => `"${key}"`).join(", ")}. Allowed keys: ${STRUCTURED_LINKED_TEST_KEYS.join(", ")}.`, EXIT_CODE.USAGE);
+  }
+  if (normalizedKv.cmd !== void 0) {
+    if (normalizedKv.command !== void 0 && normalizedKv.command.trim() !== normalizedKv.cmd.trim()) {
+      throw new PmCliError(`${optionName} command and cmd must match when both are provided`, EXIT_CODE.USAGE);
+    }
+    const { cmd, ...rest } = normalizedKv;
+    return { ...rest, command: rest.command ?? cmd };
+  }
+  return normalizedKv;
+}
+
+// dist/cli/commands/linked-test-parsers.js
+var LINKED_TEST_PROTECTED_ENV_KEYS = /* @__PURE__ */ new Set(["PM_PATH", "PM_GLOBAL_PATH", "FORCE_COLOR"]);
+var LINKED_TEST_ENV_NAME_PATTERN = /^[A-Za-z_][A-Za-z0-9_]*$/;
+var LINKED_TEST_PM_CONTEXT_MODE_VALUES = ["schema", "tracker", "auto"];
+function parseLinkedTestEnvSet(raw, optionName) {
+  if (!raw) {
+    return void 0;
+  }
+  const assignments = raw.split(/[;\n]/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (assignments.length === 0) {
+    throw new PmCliError(`${optionName} env_set must include at least one KEY=VALUE assignment`, EXIT_CODE.USAGE);
+  }
+  const envSet = {};
+  for (const assignment of assignments) {
+    const separatorIndex = assignment.indexOf("=");
+    if (separatorIndex <= 0) {
+      throw new PmCliError(`${optionName} env_set entries must use KEY=VALUE and be separated by semicolons. Example: env_set=PORT=0;PLAYWRIGHT_BASE_URL=http://127.0.0.1:4173`, EXIT_CODE.USAGE);
+    }
+    const key = assignment.slice(0, separatorIndex).trim();
+    const value = assignment.slice(separatorIndex + 1);
+    if (!LINKED_TEST_ENV_NAME_PATTERN.test(key)) {
+      throw new PmCliError(`${optionName} env_set key "${key}" is invalid`, EXIT_CODE.USAGE);
+    }
+    if (LINKED_TEST_PROTECTED_ENV_KEYS.has(key.toUpperCase())) {
+      throw new PmCliError(`${optionName} env_set key "${key}" is reserved for sandbox safety`, EXIT_CODE.USAGE);
+    }
+    envSet[key] = value;
+  }
+  return Object.keys(envSet).length > 0 ? envSet : void 0;
+}
+function parseLinkedTestEnvClear(raw, optionName) {
+  if (!raw) {
+    return void 0;
+  }
+  const keys = splitCommaList(raw, { separators: /[;,\n]/ });
+  if (keys.length === 0) {
+    throw new PmCliError(`${optionName} env_clear must include at least one environment variable name`, EXIT_CODE.USAGE);
+  }
+  for (const key of keys) {
+    if (!LINKED_TEST_ENV_NAME_PATTERN.test(key)) {
+      throw new PmCliError(`${optionName} env_clear key "${key}" is invalid`, EXIT_CODE.USAGE);
+    }
+    if (LINKED_TEST_PROTECTED_ENV_KEYS.has(key.toUpperCase())) {
+      throw new PmCliError(`${optionName} env_clear key "${key}" is reserved for sandbox safety`, EXIT_CODE.USAGE);
+    }
+  }
+  return keys;
+}
+function parseLinkedTestBoolean(raw, optionName, fieldLabel) {
+  if (!raw) {
+    return void 0;
+  }
+  const value = raw.trim().toLowerCase();
+  if (value === "true" || value === "1" || value === "yes") {
+    return true;
+  }
+  if (value === "false" || value === "0" || value === "no") {
+    return false;
+  }
+  throw new PmCliError(`${optionName} ${fieldLabel} must be one of true|false|1|0|yes|no`, EXIT_CODE.USAGE);
+}
+function parseLinkedTestContextMode(raw, optionName) {
+  if (!raw) {
+    return void 0;
+  }
+  const value = raw.trim().toLowerCase();
+  if (LINKED_TEST_PM_CONTEXT_MODE_VALUES.includes(value)) {
+    return value;
+  }
+  throw new PmCliError(`${optionName} pm_context_mode must be one of: ${LINKED_TEST_PM_CONTEXT_MODE_VALUES.join(", ")}`, EXIT_CODE.USAGE);
+}
+function parseLinkedTestStringList(raw) {
+  if (!raw) {
+    return void 0;
+  }
+  const values = splitCommaList(raw, { separators: /[;\n]/ });
+  return values.length > 0 ? values : void 0;
+}
+function parseLinkedTestRegexList(raw, optionName, fieldLabel) {
+  const values = parseLinkedTestStringList(raw);
+  if (!values || values.length === 0) {
+    return void 0;
+  }
+  for (const pattern of values) {
+    try {
+      new RegExp(pattern, "m");
+    } catch (error) {
+      throw new PmCliError(
+        /* c8 ignore next -- RegExp only throws SyntaxError (an Error); String(error) fallback is defensive. */
+        `${optionName} ${fieldLabel} includes invalid regex "${pattern}": ${error instanceof Error ? error.message : String(error)}`,
+        EXIT_CODE.USAGE
+      );
+    }
+  }
+  return values;
+}
+function parseLinkedTestMinLines(raw, optionName) {
+  if (!raw) {
+    return void 0;
+  }
+  const parsed = parseOptionalNumber(raw, "assert_stdout_min_lines");
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new PmCliError(`${optionName} assert_stdout_min_lines must be an integer >= 0`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseLinkedTestAssertionEqualsMap(raw, optionName) {
+  if (!raw) {
+    return void 0;
+  }
+  const assignments = raw.split(/[;\n]/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (assignments.length === 0) {
+    throw new PmCliError(`${optionName} assert_json_field_equals must include at least one path=value assignment`, EXIT_CODE.USAGE);
+  }
+  const values = {};
+  for (const assignment of assignments) {
+    const separatorIndex = assignment.indexOf("=");
+    if (separatorIndex <= 0) {
+      throw new PmCliError(`${optionName} assert_json_field_equals entries must use path=value and be separated by semicolons`, EXIT_CODE.USAGE);
+    }
+    const key = assignment.slice(0, separatorIndex).trim();
+    const value = assignment.slice(separatorIndex + 1).trim();
+    if (key.length === 0 || value.length === 0) {
+      throw new PmCliError(`${optionName} assert_json_field_equals entries must include non-empty path and value`, EXIT_CODE.USAGE);
+    }
+    values[key] = value;
+  }
+  return Object.keys(values).length > 0 ? values : void 0;
+}
+function parseLinkedTestAssertionGteMap(raw, optionName) {
+  if (!raw) {
+    return void 0;
+  }
+  const assignments = raw.split(/[;\n]/).map((entry) => entry.trim()).filter((entry) => entry.length > 0);
+  if (assignments.length === 0) {
+    throw new PmCliError(`${optionName} assert_json_field_gte must include at least one path=value assignment`, EXIT_CODE.USAGE);
+  }
+  const values = {};
+  for (const assignment of assignments) {
+    const separatorIndex = assignment.indexOf("=");
+    if (separatorIndex <= 0) {
+      throw new PmCliError(`${optionName} assert_json_field_gte entries must use path=value and be separated by semicolons`, EXIT_CODE.USAGE);
+    }
+    const key = assignment.slice(0, separatorIndex).trim();
+    const valueRaw = assignment.slice(separatorIndex + 1).trim();
+    if (key.length === 0 || valueRaw.length === 0) {
+      throw new PmCliError(`${optionName} assert_json_field_gte entries must include non-empty path and value`, EXIT_CODE.USAGE);
+    }
+    const value = Number.parseFloat(valueRaw);
+    if (!Number.isFinite(value)) {
+      throw new PmCliError(`${optionName} assert_json_field_gte value for "${key}" must be numeric`, EXIT_CODE.USAGE);
+    }
+    values[key] = value;
+  }
+  return Object.keys(values).length > 0 ? values : void 0;
+}
+var LINKED_TEST_JSON_KEY_SET = new Set(STRUCTURED_LINKED_TEST_KEYS);
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function normalizeJsonEntryKeys(entry, fail) {
+  const normalized = {};
+  const unknownKeys = [];
+  for (const [key, value] of Object.entries(entry)) {
+    const normalizedKey = key.toLowerCase();
+    if (!LINKED_TEST_JSON_KEY_SET.has(normalizedKey)) {
+      unknownKeys.push(key);
+      continue;
+    }
+    if (Object.hasOwn(normalized, normalizedKey)) {
+      throw fail(`provides key "${key}" more than once after case normalization`);
+    }
+    normalized[normalizedKey] = value;
+  }
+  if (unknownKeys.length > 0) {
+    throw fail(`does not recognize key${unknownKeys.length > 1 ? "s" : ""} ${unknownKeys.map((key) => `"${key}"`).join(", ")}. Allowed keys: ${STRUCTURED_LINKED_TEST_KEYS.join(", ")}.`);
+  }
+  return normalized;
+}
+function readJsonEntryString(entry, key, fail) {
+  if (!Object.hasOwn(entry, key)) {
+    return void 0;
+  }
+  const value = entry[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "string") {
+    throw fail(`field "${key}" must be a JSON string`);
+  }
+  return value;
+}
+function readJsonEntryStringList(entry, key, fail) {
+  if (!Object.hasOwn(entry, key)) {
+    return void 0;
+  }
+  const value = entry[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  const list = typeof value === "string" ? [value] : value;
+  if (!Array.isArray(list) || list.some((item) => typeof item !== "string")) {
+    throw fail(`field "${key}" must be a string or an array of strings`);
+  }
+  const values = list.filter((item) => item.length > 0);
+  return values.length > 0 ? values : void 0;
+}
+function readJsonEntryRegexList(entry, key, fail) {
+  const values = readJsonEntryStringList(entry, key, fail);
+  if (!values) {
+    return void 0;
+  }
+  for (const pattern of values) {
+    try {
+      new RegExp(pattern, "m");
+    } catch (error) {
+      throw fail(
+        /* c8 ignore next -- RegExp only throws SyntaxError (an Error); String(error) fallback is defensive. */
+        `field "${key}" includes invalid regex "${pattern}": ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  return values;
+}
+function readJsonEntryNumber(value, key, fail) {
+  const parsed = typeof value === "number" ? value : typeof value === "string" && value.trim().length > 0 ? Number(value.trim()) : Number.NaN;
+  if (typeof value === "boolean" || !Number.isFinite(parsed)) {
+    throw fail(`field "${key}" must be a finite number (or numeric string)`);
+  }
+  return parsed;
+}
+function readJsonEntryTimeoutSeconds(entry, fail) {
+  const timeoutSecondsRaw = entry.timeout_seconds;
+  const timeoutAliasRaw = entry.timeout;
+  if (timeoutSecondsRaw === void 0 && timeoutAliasRaw === void 0) {
+    return void 0;
+  }
+  const timeoutSeconds = timeoutSecondsRaw === void 0 ? void 0 : readJsonEntryNumber(timeoutSecondsRaw, "timeout_seconds", fail);
+  const timeoutAlias = timeoutAliasRaw === void 0 ? void 0 : readJsonEntryNumber(timeoutAliasRaw, "timeout", fail);
+  if (timeoutSeconds !== void 0 && timeoutAlias !== void 0 && timeoutSeconds !== timeoutAlias) {
+    throw fail("timeout and timeout_seconds must match when both are provided");
+  }
+  const timeout = timeoutSeconds ?? timeoutAlias;
+  if (!Number.isInteger(timeout) || timeout <= 0) {
+    throw fail("timeout_seconds must be a positive integer");
+  }
+  return timeout;
+}
+function readJsonEntryScope(entry, fail) {
+  const value = readJsonEntryString(entry, "scope", fail);
+  if (value === void 0) {
+    return "project";
+  }
+  if (!SCOPE_VALUES.includes(value)) {
+    throw fail(`field "scope" must be one of: ${SCOPE_VALUES.join(", ")}`);
+  }
+  return value;
+}
+function readJsonEntryEnvSet(entry, fail) {
+  if (!Object.hasOwn(entry, "env_set")) {
+    return void 0;
+  }
+  const value = entry.env_set;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isPlainObject(value)) {
+    throw fail('field "env_set" must be a JSON object mapping environment names to string values');
+  }
+  const envSet = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (typeof entryValue !== "string") {
+      throw fail(`field "env_set" value for "${key}" must be a string`);
+    }
+    if (!LINKED_TEST_ENV_NAME_PATTERN.test(key)) {
+      throw fail(`field "env_set" key "${key}" is invalid`);
+    }
+    if (LINKED_TEST_PROTECTED_ENV_KEYS.has(key.toUpperCase())) {
+      throw fail(`field "env_set" key "${key}" is reserved for sandbox safety`);
+    }
+    envSet[key] = entryValue;
+  }
+  return Object.keys(envSet).length > 0 ? envSet : void 0;
+}
+function readJsonEntryEnvClear(entry, fail) {
+  const keys = readJsonEntryStringList(entry, "env_clear", fail);
+  if (!keys) {
+    return void 0;
+  }
+  for (const key of keys) {
+    if (!LINKED_TEST_ENV_NAME_PATTERN.test(key)) {
+      throw fail(`field "env_clear" key "${key}" is invalid`);
+    }
+    if (LINKED_TEST_PROTECTED_ENV_KEYS.has(key.toUpperCase())) {
+      throw fail(`field "env_clear" key "${key}" is reserved for sandbox safety`);
+    }
+  }
+  return keys;
+}
+function readJsonEntryBoolean(entry, key, fail) {
+  if (!Object.hasOwn(entry, key)) {
+    return void 0;
+  }
+  const value = entry[key];
+  if (value === void 0) {
+    return void 0;
+  }
+  if (typeof value !== "boolean") {
+    throw fail(`field "${key}" must be a JSON boolean (true or false)`);
+  }
+  return value;
+}
+function readJsonEntryMinLines(entry, fail) {
+  if (!Object.hasOwn(entry, "assert_stdout_min_lines")) {
+    return void 0;
+  }
+  const value = entry.assert_stdout_min_lines;
+  if (value === void 0) {
+    return void 0;
+  }
+  const parsed = readJsonEntryNumber(value, "assert_stdout_min_lines", fail);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw fail('field "assert_stdout_min_lines" must be an integer >= 0');
+  }
+  return parsed;
+}
+function readJsonEntryEqualsMap(entry, fail) {
+  if (!Object.hasOwn(entry, "assert_json_field_equals")) {
+    return void 0;
+  }
+  const value = entry.assert_json_field_equals;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isPlainObject(value)) {
+    throw fail('field "assert_json_field_equals" must be a JSON object mapping field paths to expected values');
+  }
+  const values = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key.trim().length === 0) {
+      throw fail('field "assert_json_field_equals" keys must be non-empty field paths');
+    }
+    if (typeof entryValue !== "string" && typeof entryValue !== "number" && typeof entryValue !== "boolean") {
+      throw fail(`field "assert_json_field_equals" value for "${key}" must be a string, number, or boolean`);
+    }
+    values[key] = String(entryValue);
+  }
+  return Object.keys(values).length > 0 ? values : void 0;
+}
+function readJsonEntryGteMap(entry, fail) {
+  if (!Object.hasOwn(entry, "assert_json_field_gte")) {
+    return void 0;
+  }
+  const value = entry.assert_json_field_gte;
+  if (value === void 0) {
+    return void 0;
+  }
+  if (!isPlainObject(value)) {
+    throw fail('field "assert_json_field_gte" must be a JSON object mapping field paths to numeric minimums');
+  }
+  const values = {};
+  for (const [key, entryValue] of Object.entries(value)) {
+    if (key.trim().length === 0) {
+      throw fail('field "assert_json_field_gte" keys must be non-empty field paths');
+    }
+    values[key] = readJsonEntryNumber(entryValue, `assert_json_field_gte.${key}`, fail);
+  }
+  return Object.keys(values).length > 0 ? values : void 0;
+}
+function parseLinkedTestJsonEntry(rawEntry, label, optionName) {
+  const fail = (message) => new PmCliError(`${optionName} ${label} ${message}`, EXIT_CODE.USAGE);
+  if (!isPlainObject(rawEntry)) {
+    throw fail(`must be a JSON object with linked-test fields. Allowed keys: ${STRUCTURED_LINKED_TEST_KEYS.join(", ")}.`);
+  }
+  const entry = normalizeJsonEntryKeys(rawEntry, fail);
+  const commandValue = readJsonEntryString(entry, "command", fail);
+  const cmdAlias = readJsonEntryString(entry, "cmd", fail);
+  if (commandValue !== void 0 && cmdAlias !== void 0 && commandValue !== cmdAlias) {
+    throw fail("command and cmd must match when both are provided");
+  }
+  const command = commandValue ?? cmdAlias;
+  if (command === void 0 || command.trim().length === 0) {
+    throw fail('requires a non-empty "command" string');
+  }
+  const pathValue = readJsonEntryString(entry, "path", fail);
+  const pmContextModeValue = readJsonEntryString(entry, "pm_context_mode", fail);
+  if (pmContextModeValue !== void 0 && !LINKED_TEST_PM_CONTEXT_MODE_VALUES.includes(pmContextModeValue)) {
+    throw fail(`field "pm_context_mode" must be one of: ${LINKED_TEST_PM_CONTEXT_MODE_VALUES.join(", ")}`);
+  }
+  const noteValue = readJsonEntryString(entry, "note", fail);
+  return {
+    command,
+    path: pathValue !== void 0 && pathValue.length > 0 ? pathValue : void 0,
+    scope: readJsonEntryScope(entry, fail),
+    timeout_seconds: readJsonEntryTimeoutSeconds(entry, fail),
+    pm_context_mode: pmContextModeValue,
+    env_set: readJsonEntryEnvSet(entry, fail),
+    env_clear: readJsonEntryEnvClear(entry, fail),
+    shared_host_safe: readJsonEntryBoolean(entry, "shared_host_safe", fail),
+    assert_stdout_contains: readJsonEntryStringList(entry, "assert_stdout_contains", fail),
+    assert_stdout_regex: readJsonEntryRegexList(entry, "assert_stdout_regex", fail),
+    assert_stderr_contains: readJsonEntryStringList(entry, "assert_stderr_contains", fail),
+    assert_stderr_regex: readJsonEntryRegexList(entry, "assert_stderr_regex", fail),
+    assert_stdout_min_lines: readJsonEntryMinLines(entry, fail),
+    assert_json_field_equals: readJsonEntryEqualsMap(entry, fail),
+    assert_json_field_gte: readJsonEntryGteMap(entry, fail),
+    note: noteValue !== void 0 && noteValue.trim().length > 0 ? noteValue.trim() : void 0
+  };
+}
+function parseLinkedTestJsonEntries(raw, optionName) {
+  const trimmed = raw.trim();
+  if (trimmed.length === 0) {
+    throw new PmCliError(`${optionName} requires a JSON object or array of objects describing linked-test entries`, EXIT_CODE.USAGE);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(trimmed);
+  } catch (error) {
+    throw new PmCliError(
+      /* c8 ignore next -- JSON.parse only throws SyntaxError (an Error); String(error) fallback is defensive. */
+      `${optionName} value is not valid JSON: ${error instanceof Error ? error.message : String(error)}. Provide a JSON object or array of objects, e.g. '{"command":"node scripts/check.js --flag value, with commas","timeout_seconds":120}'.`,
+      EXIT_CODE.USAGE
+    );
+  }
+  const entries = Array.isArray(parsed) ? parsed : [parsed];
+  if (entries.length === 0) {
+    throw new PmCliError(`${optionName} array must include at least one linked-test entry object`, EXIT_CODE.USAGE);
+  }
+  return entries.map((entry, index) => parseLinkedTestJsonEntry(entry, entries.length > 1 ? `entry ${index + 1}` : "entry", optionName));
+}
+
 // dist/cli/commands/shared-unset-fields.js
 var COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON = [
   { canonical: "tags", aliases: ["tags"], optionKey: "tags", frontMatterKey: "tags" }
@@ -2111,6 +2580,20 @@ export {
   assertNoLegacyNoneToken,
   assertNoLegacyNoneTokens,
   applyLegacyNoneCollectionNormalizers,
+  looksLikeStructuredLinkedTestEntry,
+  normalizeStructuredLinkedTestEntry,
+  LINKED_TEST_PROTECTED_ENV_KEYS,
+  LINKED_TEST_PM_CONTEXT_MODE_VALUES,
+  parseLinkedTestEnvSet,
+  parseLinkedTestEnvClear,
+  parseLinkedTestBoolean,
+  parseLinkedTestContextMode,
+  parseLinkedTestStringList,
+  parseLinkedTestRegexList,
+  parseLinkedTestMinLines,
+  parseLinkedTestAssertionEqualsMap,
+  parseLinkedTestAssertionGteMap,
+  parseLinkedTestJsonEntries,
   COMMON_UNSET_FIELD_DEFINITIONS_BEFORE_CLOSE_REASON,
   COMMON_UNSET_FIELD_DEFINITIONS_AFTER_CLOSE_REASON_BEFORE_AUTHOR,
   COMMON_UNSET_FIELD_DEFINITIONS_AFTER_AUTHOR,
@@ -2127,6 +2610,6 @@ export {
   runCreate,
   _testOnlyCreateCommand
 };
-//# sourceMappingURL=chunk-TULGS6X6.js.map
+//# sourceMappingURL=chunk-QFBSP3NI.js.map
 
-//# debugId=3b2e2c0b-d9a3-51c6-ba51-0bad9aa69284
+//# debugId=59bf43ec-201a-5ebc-b1f7-9e467826b815