@unbrained/pm-cli 2026.7.5 → 2026.7.7

package/dist/cli-bundle/chunks/{delete-62JQTYT4.js → chunk-XBX5CBRQ.js}

@@ -2,22 +2,17 @@ import {
   resolveAuthor
 } from "./chunk-WW4E2DC3.js";
 import {
+  PmCliError,
   deleteItem,
+  readSettings,
   toItemRecord
-} from "./chunk-3U3VEWK6.js";
-import "./chunk-EZFKWSC7.js";
-import "./chunk-DRBV5UC2.js";
-import {
-  PmCliError,
-  readSettings
-} from "./chunk-P5YORJRH.js";
-import "./chunk-7C2O74AE.js";
+} from "./chunk-YNCFP5AR.js";
 import {
   EXIT_CODE,
   getSettingsPath,
   pathExists,
   resolvePmRoot
-} from "./chunk-5VVUKE3U.js";
+} from "./chunk-LCFJ7XAM.js";
 
 // dist/cli/commands/delete.js
 import path from "node:path";
@@ -53,7 +48,8 @@ async function runDelete(id, options, global2) {
     warnings: result.warnings
   };
 }
+
 export {
   runDelete
 };
-//# sourceMappingURL=delete-62JQTYT4.js.map
+//# sourceMappingURL=chunk-XBX5CBRQ.js.map

package/dist/cli-bundle/chunks/{delete-62JQTYT4.js.map → chunk-XBX5CBRQ.js.map}

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../../../../../../cli/commands/delete.ts"],
   "sourcesContent": ["/**\n * @module cli/commands/delete\n *\n * Implements the pm delete command surface and its agent-facing runtime behavior.\n */\nimport path from \"node:path\";\nimport { pathExists } from \"../../core/fs/fs-utils.js\";\nimport { EXIT_CODE } from \"../../core/shared/constants.js\";\nimport type { GlobalOptions } from \"../../core/shared/command-types.js\";\nimport { PmCliError } from \"../../core/shared/errors.js\";\nimport { toItemRecord } from \"../../core/item/item-record.js\";\nimport { deleteItem } from \"../../core/store/item-store.js\";\nimport { getSettingsPath, resolvePmRoot } from \"../../core/store/paths.js\";\nimport { readSettings } from \"../../core/store/settings.js\";\nimport { resolveAuthor } from \"../../core/shared/author.js\";\n\n/**\n * Documents the delete command options payload exchanged by command, SDK, and package integrations.\n */\nexport interface DeleteCommandOptions {\n  author?: string;\n  message?: string;\n  force?: boolean;\n  dryRun?: boolean;\n}\n\n/**\n * Documents the delete result payload exchanged by command, SDK, and package integrations.\n */\nexport interface DeleteResult {\n  item: Record<string, unknown>;\n  changed_fields: string[];\n  dry_run: boolean;\n  target_path?: string;\n  warnings: string[];\n}\n\n/**\n * Implements run delete for the public runtime surface of this module.\n */\nexport async function runDelete(id: string, options: DeleteCommandOptions, global: GlobalOptions): Promise<DeleteResult> {\n  const pmRoot = resolvePmRoot(process.cwd(), global.path);\n  if (!(await pathExists(getSettingsPath(pmRoot)))) {\n    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);\n  }\n\n  const settings = await readSettings(pmRoot);\n  const author = resolveAuthor(options.author, settings.author_default);\n\n  const result = await deleteItem({\n    pmRoot,\n    settings,\n    id,\n    author,\n    message: options.message,\n    force: options.force,\n    dryRun: options.dryRun,\n  });\n  const targetPath = result.targetPath ? path.relative(pmRoot, result.targetPath).split(path.sep).join(\"/\") : undefined;\n\n  return {\n    item: toItemRecord(result.item),\n    changed_fields: result.changedFields,\n    dry_run: options.dryRun === true,\n    ...(targetPath ? { target_path: targetPath } : {}),\n    warnings: result.warnings,\n  };\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;AAKA,OAAO,UAAU;;;;;;;;AAmCjB,eAAsB,UAAU,IAAY,SAA+BA,SAAqB;AAC9F,QAAM,SAAS,cAAc,QAAQ,IAAG,GAAIA,QAAO,IAAI;AACvD,MAAI,CAAE,MAAM,WAAW,gBAAgB,MAAM,CAAC,GAAI;AAChD,UAAM,IAAI,WAAW,iCAAiC,MAAM,wBAAwB,UAAU,SAAS;EACzG;AAEA,QAAM,WAAW,MAAM,aAAa,MAAM;AAC1C,QAAM,SAAS,cAAc,QAAQ,QAAQ,SAAS,cAAc;AAEpE,QAAM,SAAS,MAAM,WAAW;IAC9B;IACA;IACA;IACA;IACA,SAAS,QAAQ;IACjB,OAAO,QAAQ;IACf,QAAQ,QAAQ;GACjB;AACD,QAAM,aAAa,OAAO,aAAa,KAAK,SAAS,QAAQ,OAAO,UAAU,EAAE,MAAM,KAAK,GAAG,EAAE,KAAK,GAAG,IAAI;AAE5G,SAAO;IACL,MAAM,aAAa,OAAO,IAAI;IAC9B,gBAAgB,OAAO;IACvB,SAAS,QAAQ,WAAW;IAC5B,GAAI,aAAa,EAAE,aAAa,WAAU,IAAK,CAAA;IAC/C,UAAU,OAAO;;AAErB;",
+  "mappings": ";;;;;;;;;;;;;;;;;AAKA,OAAO,UAAU;;;;;;;;AAmCjB,eAAsB,UAAU,IAAY,SAA+BA,SAAqB;AAC9F,QAAM,SAAS,cAAc,QAAQ,IAAG,GAAIA,QAAO,IAAI;AACvD,MAAI,CAAE,MAAM,WAAW,gBAAgB,MAAM,CAAC,GAAI;AAChD,UAAM,IAAI,WAAW,iCAAiC,MAAM,wBAAwB,UAAU,SAAS;EACzG;AAEA,QAAM,WAAW,MAAM,aAAa,MAAM;AAC1C,QAAM,SAAS,cAAc,QAAQ,QAAQ,SAAS,cAAc;AAEpE,QAAM,SAAS,MAAM,WAAW;IAC9B;IACA;IACA;IACA;IACA,SAAS,QAAQ;IACjB,OAAO,QAAQ;IACf,QAAQ,QAAQ;GACjB;AACD,QAAM,aAAa,OAAO,aAAa,KAAK,SAAS,QAAQ,OAAO,UAAU,EAAE,MAAM,KAAK,GAAG,EAAE,KAAK,GAAG,IAAI;AAE5G,SAAO;IACL,MAAM,aAAa,OAAO,IAAI;IAC9B,gBAAgB,OAAO;IACvB,SAAS,QAAQ,WAAW;IAC5B,GAAI,aAAa,EAAE,aAAa,WAAU,IAAK,CAAA;IAC/C,UAAU,OAAO;;AAErB;",
   "names": ["global"]
 }

package/dist/cli-bundle/chunks/{chunk-MTTXDAK4.js → chunk-XC3X7BQR.js}

@@ -1,16 +1,6 @@
 import {
-  looksLikeStructuredLinkedTestEntry,
-  normalizeStructuredLinkedTestEntry,
-  parseLinkedTestAssertionEqualsMap,
-  parseLinkedTestAssertionGteMap,
-  parseLinkedTestBoolean,
-  parseLinkedTestContextMode,
-  parseLinkedTestEnvClear,
-  parseLinkedTestEnvSet,
-  parseLinkedTestMinLines,
-  parseLinkedTestRegexList,
-  parseLinkedTestStringList
-} from "./chunk-BVEUCSH2.js";
+  getFocusedItem
+} from "./chunk-WCWVEXGA.js";
 import {
   assertNoUnknownCsvKeys,
   createStdinTokenResolver,
@@ -19,54 +9,48 @@ import {
   parseCsvKv,
   parseOptionalNumber,
   parseTags
-} from "./chunk-T3ABIMGW.js";
-import {
-  getFocusedItem
-} from "./chunk-ZMD35NYG.js";
-import {
-  printError
-} from "./chunk-ZD34OFFQ.js";
-import {
-  acquireLock,
-  appendHistoryEntry,
-  applyRegisteredItemFieldDefaultsAndValidation,
-  collectRegisteredItemFieldNames,
-  createHistoryEntry,
-  locateItem,
-  parseRegisteredItemFieldAssignments
-} from "./chunk-3U3VEWK6.js";
+} from "./chunk-2TILG6F2.js";
 import {
   assertParentReferenceIsNotSelf,
   isPlaceholderReferenceToken,
   normalizeParentReferenceValue,
   validateMissingParentReference,
   validateSprintOrReleaseValue
-} from "./chunk-OWTIRHX4.js";
+} from "./chunk-43YSKY75.js";
+import {
+  buildInvalidTypeError
+} from "./chunk-YPMZMKN7.js";
+import {
+  splitCommaList
+} from "./chunk-5HIZDR5A.js";
 import {
+  printError
+} from "./chunk-SY75LYXR.js";
+import {
+  PmCliError,
+  acquireLock,
+  appendHistoryEntry,
+  applyRegisteredItemFieldDefaultsAndValidation,
   canonicalDocument,
+  collectRegisteredItemFieldNames,
   collectRuntimeCreateFieldValues,
+  createHistoryEntry,
   generateItemId,
+  getActiveExtensionRegistrations,
+  locateItem,
   normalizeFrontMatter,
   normalizeItemId,
   normalizeStatusInput,
-  serializeItemDocument
-} from "./chunk-EZFKWSC7.js";
-import {
   nowIso,
-  resolveIsoOrRelative
-} from "./chunk-DRBV5UC2.js";
-import {
-  PmCliError,
-  getActiveExtensionRegistrations,
+  parseRegisteredItemFieldAssignments,
   projectAfterCommandItemSnapshot,
   readSettings,
   recordAfterCommandAffectedItem,
+  resolveIsoOrRelative,
   runActiveCommandHandler,
-  runActiveOnWriteHooks
-} from "./chunk-P5YORJRH.js";
-import {
-  buildInvalidTypeError
-} from "./chunk-T35XLYZF.js";
+  runActiveOnWriteHooks,
+  serializeItemDocument
+} from "./chunk-YNCFP5AR.js";
 import {
   CONFIDENCE_TEXT_VALUES,
   CREATE_DIRECT_CLOSE_REASON_DEFAULT,
@@ -97,7 +81,7 @@ import {
   validateTypeOptions,
   weekdayOrderIndex,
   writeFileAtomic
-} from "./chunk-5VVUKE3U.js";
+} from "./chunk-LCFJ7XAM.js";
 
 // dist/core/item/priority.js
 !(function() {
@@ -303,6 +287,505 @@ function suggestNextLifecycleTransition(id, type, status, statusRegistry) {
   return { command: `pm start-task ${id}`, to_status: inProgress };
 }
 
+// dist/cli/commands/linked-test-entry.js
+!(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] = "1ba13c71-81a4-50df-a271-8e10d36ca2ef");
+  } catch (e2) {
+  }
+})();
+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
+!(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] = "a35f5390-111f-519f-bc99-551f1505c260");
+  } catch (e2) {
+  }
+})();
+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
 !(function() {
   try {
@@ -2179,6 +2662,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,
@@ -2195,4 +2692,4 @@ export {
   runCreate,
   _testOnlyCreateCommand
 };
-//# sourceMappingURL=chunk-MTTXDAK4.js.map
+//# sourceMappingURL=chunk-XC3X7BQR.js.map