@unbrained/pm-cli 2026.7.14 → 2026.7.15

package/dist/cli-bundle/main.js

@@ -1,32 +1,25 @@
 #!/usr/bin/env node
+import {
+  applyInvocationAuthorOverride,
+  createPmCliProgram
+} from "./chunks/chunk-ZKRZY773.js";
 import {
   deriveTelemetryCommandResolution,
   deriveTelemetryCommandTaxonomy,
   emitTelemetryErrorEvent,
   finishTelemetryCommand,
   startTelemetryCommand
-} from "./chunks/chunk-WRKB56FC.js";
+} from "./chunks/chunk-NP22ERDF.js";
 import {
   migrateItemFilesToFormat
-} from "./chunks/chunk-MD6ULIPJ.js";
+} from "./chunks/chunk-BCOFWYW4.js";
 import {
-  EXECUTABLE_COMMAND_ALIASES,
-  applyBootstrapPagerPolicy,
-  extractProvidedOptionFlags,
-  normalizeBootstrapInvocation,
   normalizeExtensionNameForMatch,
-  normalizeLongFlag,
-  normalizeLongOptionFlag,
-  parseBootstrapCommandName,
-  parseBootstrapGlobalOptions,
-  parseBootstrapHelpRequest,
-  parseBootstrapTypeValue,
-  renderPmCommand,
-  stripGlobalBootstrapTokens
-} from "./chunks/chunk-FO7GMJKG.js";
+  renderPmCommand
+} from "./chunks/chunk-PENXZX3U.js";
 import {
   recordContextUsageTouches
-} from "./chunks/chunk-Y72FV7RM.js";
+} from "./chunks/chunk-YCQET3OT.js";
 import {
   applyDefaultOutputFormat,
   clearResolvedGlobalOptions,
@@ -37,16 +30,17 @@ import {
   invalidateSearchCachesForMutation,
   setResolvedGlobalOptions,
   syncCommanderActionOptions
-} from "./chunks/chunk-ZUKSZVBW.js";
+} from "./chunks/chunk-7B67ZL4N.js";
 import {
+  EXECUTABLE_COMMAND_ALIASES,
   PM_CORE_COMMAND_NAMES,
   resolveSubcommandFlagContractsForCommand
-} from "./chunks/chunk-2QIQGYPW.js";
+} from "./chunks/chunk-H5APFTHZ.js";
 import {
   printError,
   printResult,
   writeStdout
-} from "./chunks/chunk-JL7WZ4O2.js";
+} from "./chunks/chunk-IG3SWA4A.js";
 import {
   clearActiveExtensionHooks,
   consumeAfterCommandAffectedItems,
@@ -70,7 +64,7 @@ import {
   setActiveExtensionRenderers,
   setActiveExtensionServices,
   writeSettings
-} from "./chunks/chunk-T4BRCB6Z.js";
+} from "./chunks/chunk-XSJUSQAE.js";
 import {
   BUILTIN_ITEM_TYPE_VALUES,
   EXIT_CODE,
@@ -98,7 +92,7 @@ import {
   runAfterCommandHooks,
   runBeforeCommandHooks,
   toNonEmptyStringOrUndefined
-} from "./chunks/chunk-AFWZRL7M.js";
+} from "./chunks/chunk-BSEQUTQP.js";
 
 // dist/cli/main.js
 import { Command } from "commander";
@@ -500,7 +494,7 @@ function getSentry() {
 !(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] = "b9353ece-0a99-5a54-85c7-573fc71856ec");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "d955a7f2-a85b-5200-8108-58c6684cb23a");
   } catch (e2) {
   }
 })();
@@ -661,7 +655,13 @@ function shouldCaptureCliError(error) {
   if (error instanceof PmCliError) {
     return false;
   }
+  if (error instanceof Error && error.name === "AbortError" && /(?:ctrl\+c|sigint|user[- ]initiated)/i.test(error.message)) {
+    return false;
+  }
   if (typeof error === "object" && error !== null && "exitCode" in error && typeof error.exitCode === "number") {
+    if (error instanceof Error && error.name === "CommandError") {
+      return false;
+    }
     const exitCode = Math.trunc(error.exitCode);
     const expectedExitCodes = /* @__PURE__ */ new Set([
       EXIT_CODE.SUCCESS,
@@ -687,7 +687,7 @@ async function sentryFlush(timeoutMs = 3e3) {
 !(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] = "0c102c68-f173-5412-a254-395b6fe01fa1");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "9e25c820-f946-58a4-84ad-e5ce6a58f9d4");
   } catch (e2) {
   }
 })();
@@ -925,7 +925,7 @@ function applyFlagDefault(defaultValue, kind, isListFlag) {
 }
 function readOrderedLooseListValues(occurrenceSource, optionKeys, fallback) {
   const occurrences = occurrenceSource[LOOSE_OPTION_OCCURRENCES];
-  if (!occurrences) {
+  if (!occurrences || occurrences.length === 0) {
     return fallback;
   }
   const acceptedKeys = new Set(optionKeys);
@@ -1072,7 +1072,7 @@ function stripLooseCommandOptionTokens(args, definitions) {
 !(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] = "764e7866-3ff1-5da2-8679-9fb948bd23f8");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "16bbb507-3edd-5f68-9262-c784c1ed5caa");
   } catch (e2) {
   }
 })();
@@ -1603,12 +1603,16 @@ var HELP_BY_COMMAND_PATH = {
     examples: [
       "pm get pm-a1b2",
       "pm get pm-a1b2 --depth brief --json",
-      "pm get pm-a1b2 --fields id,title,status,parent,type --json"
+      "pm get pm-a1b2 --fields id,title,status,parent,type --json",
+      "pm get pm-a1b2 --at 7 --fields id,title,status,body --json"
     ],
     tips: [
       "Default depth is standard for body plus linked artifacts without append-only logs; use brief for metadata-only checks or --full for complete history-heavy metadata.",
       "Use --fields for the smallest deterministic item metadata payload when an agent only needs specific fields.",
-      "JSON output shape is { item, linked, claim_state, children }; body is nested at item.body (parity with list --include-body), and children appears for requested/container rollups."
+      "Schedule metadata is normalized under schedule; request schedule.start_at or schedule.location for narrow calendar reads.",
+      "Children are type-agnostic and include bounded deterministic samples plus continuation metadata when a parent has direct children.",
+      "Use --at <version|timestamp> for a verified read-only historical projection; reconstructed/as_of fields distinguish it from current state.",
+      "JSON output shape is { item, linked, claim_state, schedule, children }; body is nested at item.body (parity with list --include-body)."
     ]
   },
   history: {
@@ -1939,6 +1943,39 @@ function attachRichHelpText(program2, argv = process.argv.slice(2)) {
   }
 }
 
+// dist/cli/argv-utils.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] = "e931035a-0e65-560e-9480-cdafdeb01ecf");
+  } catch (e2) {
+  }
+})();
+function normalizeLongFlag(flag) {
+  return `--${flag.replace(/^--?/, "").replace(/_/g, "-").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase()}`;
+}
+function normalizeLongOptionFlag(token) {
+  if (!token.startsWith("--")) {
+    return void 0;
+  }
+  const key = token.includes("=") ? token.slice(0, token.indexOf("=")) : token;
+  return normalizeLongFlag(key);
+}
+function extractProvidedOptionFlags(argv) {
+  const provided = /* @__PURE__ */ new Set();
+  const ordered = [];
+  for (const token of argv) {
+    const normalized = normalizeLongOptionFlag(token);
+    if (normalized) {
+      if (!provided.has(normalized)) {
+        ordered.push(normalized);
+      }
+      provided.add(normalized);
+    }
+  }
+  return ordered;
+}
+
 // dist/cli/error-guidance.js
 !(function() {
   try {
@@ -2889,10 +2926,11 @@ function createLazyModule(importer) {
 }
 
 // dist/cli/extension-command-help.js
+import { Option } from "commander";
 !(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] = "1e6b6cdc-855a-5090-a7bd-36d47c55295e");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "ea4608a9-3e2f-55a8-a01b-a3c53ade6c3c");
   } catch (e2) {
   }
 })();
@@ -3220,7 +3258,15 @@ function applyDynamicExtensionFlagOptions(command, definitions) {
     if (!flags) {
       continue;
     }
-    command.option(flags, formatDynamicExtensionOptionDescription(definition));
+    const description = formatDynamicExtensionOptionDescription(definition);
+    if (definition.list !== true) {
+      command.option(flags, description);
+      continue;
+    }
+    command.addOption(new Option(flags, description).argParser((value, previous = []) => [
+      ...Array.isArray(previous) ? previous : [previous],
+      value
+    ]));
   }
 }
 function buildResidualDynamicExtensionFlagHelp(command, definitions) {
@@ -3371,6 +3417,731 @@ function ensureCommandPath(root, pathParts) {
   return current;
 }
 
+// dist/cli/bootstrap-args.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] = "c8537d1b-6df6-53b0-a308-f91e09d39cf3");
+  } catch (e2) {
+  }
+})();
+var GLOBAL_VALUE_CONSUMING_FLAGS = /* @__PURE__ */ new Set([
+  "--pm-path",
+  "--path",
+  "--author"
+]);
+var isInlineGlobalValueToken = (token) => {
+  const equalsIndex = token.indexOf("=");
+  return equalsIndex > 0 && GLOBAL_VALUE_CONSUMING_FLAGS.has(token.slice(0, equalsIndex));
+};
+var consumesBootstrapAuthorValue = (next) => {
+  return typeof next === "string" && !next.startsWith("-");
+};
+function parseBootstrapPathToken(token, next) {
+  if (token === "--path" || token === "--pm-path") {
+    if (typeof next === "string" && next.length > 0) {
+      return {
+        consumed: 2,
+        pathValue: next,
+        preferred: token === "--pm-path"
+      };
+    }
+    return {
+      consumed: 1,
+      preferred: token === "--pm-path"
+    };
+  }
+  const inlinePrefix = token.startsWith("--path=") ? "--path=" : token.startsWith("--pm-path=") ? "--pm-path=" : void 0;
+  if (!inlinePrefix) {
+    return null;
+  }
+  const value = token.slice(inlinePrefix.length);
+  if (value.length > 0) {
+    return {
+      consumed: 1,
+      pathValue: value,
+      preferred: inlinePrefix === "--pm-path="
+    };
+  }
+  return {
+    consumed: 1,
+    preferred: inlinePrefix === "--pm-path="
+  };
+}
+function parseBootstrapGlobalOptions(argv) {
+  let legacyPathValue;
+  let pmPathValue;
+  let noExtensions = false;
+  let noPager = false;
+  let json = false;
+  let quiet = false;
+  let author;
+  let authorMissingValue = false;
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--no-extensions") {
+      noExtensions = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--no-pager") {
+      noPager = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--json") {
+      json = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--quiet") {
+      quiet = true;
+      index += 1;
+      continue;
+    }
+    const parsedPath = parseBootstrapPathToken(token, argv[index + 1]);
+    if (parsedPath) {
+      if (parsedPath.pathValue !== void 0) {
+        if (parsedPath.preferred) {
+          pmPathValue = parsedPath.pathValue;
+        } else {
+          legacyPathValue = parsedPath.pathValue;
+        }
+      }
+      index += parsedPath.consumed;
+      continue;
+    }
+    if (token === "--author") {
+      if (consumesBootstrapAuthorValue(argv[index + 1])) {
+        author = argv[index + 1];
+        index += 2;
+      } else {
+        authorMissingValue = true;
+        index += 1;
+      }
+      continue;
+    }
+    if (token.startsWith("--author=")) {
+      author = token.slice("--author=".length);
+      index += 1;
+      continue;
+    }
+    index += 1;
+  }
+  return {
+    path: pmPathValue ?? legacyPathValue,
+    noExtensions,
+    noPager,
+    json,
+    quiet,
+    ...author !== void 0 ? { author } : {},
+    ...authorMissingValue ? { authorMissingValue: true } : {}
+  };
+}
+function stripGlobalBootstrapTokens(argv) {
+  const remaining = [];
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--json" || token === "--quiet" || token === "--no-extensions" || token === "--no-pager" || token === "--profile" || token === "--id-only" || token === "--explain") {
+      index += 1;
+      continue;
+    }
+    if (token === "--author") {
+      index += consumesBootstrapAuthorValue(argv[index + 1]) ? 2 : 1;
+      continue;
+    }
+    if (GLOBAL_VALUE_CONSUMING_FLAGS.has(token)) {
+      index += 2;
+      continue;
+    }
+    if (isInlineGlobalValueToken(token)) {
+      index += 1;
+      continue;
+    }
+    remaining.push(token);
+    index += 1;
+  }
+  return remaining;
+}
+function parseBootstrapHelpRequest(argv) {
+  const stripped = stripGlobalBootstrapTokens(argv);
+  const first = stripped[0]?.trim().toLowerCase();
+  if (first === "help") {
+    const commandPathTokens2 = [];
+    for (let index = 1; index < stripped.length; index += 1) {
+      const token = stripped[index];
+      if (token.startsWith("-")) {
+        break;
+      }
+      commandPathTokens2.push(token.trim().toLowerCase());
+    }
+    return {
+      requested: true,
+      commandPathTokens: commandPathTokens2
+    };
+  }
+  const helpFlagIndex = stripped.findIndex((token) => token === "--help" || token === "-h");
+  if (helpFlagIndex < 0) {
+    return {
+      requested: false,
+      commandPathTokens: []
+    };
+  }
+  const commandPathTokens = [];
+  for (const token of stripped) {
+    if (token.startsWith("-")) {
+      break;
+    }
+    commandPathTokens.push(token.trim().toLowerCase());
+  }
+  return {
+    requested: true,
+    commandPathTokens
+  };
+}
+function findCommandTokenIndex(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--") {
+      return void 0;
+    }
+    if (token === "--author") {
+      index += consumesBootstrapAuthorValue(argv[index + 1]) ? 1 : 0;
+      continue;
+    }
+    if (GLOBAL_VALUE_CONSUMING_FLAGS.has(token)) {
+      index += 1;
+      continue;
+    }
+    if (isInlineGlobalValueToken(token) || token === "--json" || token === "--quiet" || token === "--no-extensions" || token === "--no-pager" || token === "--profile" || token === "--id-only" || token === "--explain") {
+      continue;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    return index;
+  }
+  return void 0;
+}
+function parseBootstrapCommandName(argv) {
+  const index = findCommandTokenIndex(argv);
+  return index === void 0 ? void 0 : argv[index].trim().toLowerCase();
+}
+function shouldDisablePagerForInvocation(argv, bootstrapGlobal) {
+  if (bootstrapGlobal.noPager) {
+    return true;
+  }
+  if (process.stdout.isTTY === true) {
+    return false;
+  }
+  const helpRequest = parseBootstrapHelpRequest(argv);
+  return helpRequest.requested;
+}
+function applyBootstrapPagerPolicy(argv) {
+  const bootstrapGlobal = parseBootstrapGlobalOptions(argv);
+  if (!shouldDisablePagerForInvocation(argv, bootstrapGlobal)) {
+    return;
+  }
+  process.env.PAGER = "cat";
+  process.env.MANPAGER = "cat";
+  process.env.GIT_PAGER = "cat";
+  if (typeof process.env.LESS !== "string" || process.env.LESS.trim().length === 0) {
+    process.env.LESS = "FRX";
+  }
+}
+var EXTENSION_ACTION_SYNTAX_TOKENS = /* @__PURE__ */ new Set([
+  "install",
+  "uninstall",
+  "explore",
+  "manage",
+  "doctor",
+  "adopt",
+  "adopt-all",
+  "activate",
+  "deactivate"
+]);
+function normalizeLegacyExtensionActionSyntax(argv) {
+  const extensionIndex = argv.findIndex((token) => token === "extension");
+  if (extensionIndex < 0) {
+    return [...argv];
+  }
+  const actionToken = argv[extensionIndex + 1];
+  if (!actionToken || actionToken.startsWith("-")) {
+    return [...argv];
+  }
+  if (!EXTENSION_ACTION_SYNTAX_TOKENS.has(actionToken)) {
+    return [...argv];
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    return [...argv];
+  }
+  const forcedActionFlag = `--${actionToken}`;
+  if (argv.includes(forcedActionFlag)) {
+    return [...argv];
+  }
+  return [
+    ...argv.slice(0, extensionIndex + 1),
+    forcedActionFlag,
+    ...argv.slice(extensionIndex + 2)
+  ];
+}
+function rewriteCommandAlias(argv, trace) {
+  const index = findCommandTokenIndex(argv);
+  if (index === void 0) {
+    return argv;
+  }
+  const token = argv[index];
+  const canonical = EXECUTABLE_COMMAND_ALIASES[token.trim().toLowerCase()];
+  if (!canonical) {
+    return argv;
+  }
+  const rewritten = [...argv];
+  rewritten[index] = canonical;
+  trace.push({
+    from: token,
+    to: [canonical],
+    reason: "command_alias",
+    confidence: "high"
+  });
+  return rewritten;
+}
+function normalizeFlagKeyToken(raw) {
+  const withoutPrefix = raw.replace(/^--?/, "");
+  return withoutPrefix.replace(/_/g, "-").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toComparableFlagKey(raw) {
+  return normalizeFlagKeyToken(raw).replace(/-/g, "");
+}
+function markUnambiguousFlag(map, key, canonicalFlag) {
+  const existing = map.get(key);
+  if (existing === void 0) {
+    map.set(key, canonicalFlag);
+    return;
+  }
+  if (existing !== canonicalFlag) {
+    map.set(key, null);
+  }
+}
+function collectLongFlagCandidates(contract) {
+  const candidates = [];
+  const pushLongFlag = (value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    if (!value.startsWith("--")) {
+      return;
+    }
+    candidates.push(value);
+  };
+  pushLongFlag(contract.flag);
+  for (const alias of contract.aliases ?? []) {
+    pushLongFlag(alias);
+  }
+  return candidates;
+}
+function buildFlagLookup(commandName, contractsOverride) {
+  const contracts = contractsOverride ?? resolveSubcommandFlagContractsForCommand(commandName);
+  const canonicalByNormalized = /* @__PURE__ */ new Map();
+  const canonicalByCompact = /* @__PURE__ */ new Map();
+  const canonicalComparablesMap = /* @__PURE__ */ new Map();
+  const listCanonicalFlags = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    const longCandidates = collectLongFlagCandidates(contract);
+    if (longCandidates.length === 0) {
+      continue;
+    }
+    const canonicalFlag = `--${normalizeFlagKeyToken(longCandidates[0])}`;
+    for (const candidate of longCandidates) {
+      markUnambiguousFlag(canonicalByNormalized, normalizeFlagKeyToken(candidate), canonicalFlag);
+      markUnambiguousFlag(canonicalByCompact, toComparableFlagKey(candidate), canonicalFlag);
+    }
+    const comparable = toComparableFlagKey(canonicalFlag);
+    if (!canonicalComparablesMap.has(canonicalFlag)) {
+      canonicalComparablesMap.set(canonicalFlag, comparable);
+    }
+    if (contract.list === true) {
+      listCanonicalFlags.add(canonicalFlag);
+    }
+  }
+  return {
+    canonicalByNormalized,
+    canonicalByCompact,
+    canonicalComparables: [...canonicalComparablesMap.entries()].map(([canonicalFlag, comparable]) => ({
+      canonicalFlag,
+      comparable
+    })),
+    listCanonicalFlags
+  };
+}
+function resolveCanonicalFlag(rawKey, lookup) {
+  const normalizedKey = normalizeFlagKeyToken(rawKey);
+  const direct = lookup.canonicalByNormalized.get(normalizedKey);
+  if (typeof direct === "string") {
+    return {
+      flag: direct,
+      reason: "flag_alias",
+      confidence: "high"
+    };
+  }
+  const comparableKey = normalizedKey.replace(/-/g, "");
+  const compactMatch = lookup.canonicalByCompact.get(comparableKey);
+  if (typeof compactMatch === "string") {
+    return {
+      flag: compactMatch,
+      reason: "flag_alias",
+      confidence: "high"
+    };
+  }
+  const maxDistance = comparableKey.length >= 8 ? 2 : 1;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let bestFlag;
+  let tied = false;
+  for (const candidate of lookup.canonicalComparables) {
+    const distance = levenshteinDistanceWithinLimit(comparableKey, candidate.comparable, maxDistance);
+    if (distance === null) {
+      continue;
+    }
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      bestFlag = candidate.canonicalFlag;
+      tied = false;
+      continue;
+    }
+    if (distance === bestDistance && bestFlag !== candidate.canonicalFlag) {
+      tied = true;
+    }
+  }
+  if (!bestFlag || tied || !Number.isFinite(bestDistance) || bestDistance <= 0) {
+    return null;
+  }
+  return {
+    flag: bestFlag,
+    reason: "flag_typo",
+    confidence: bestDistance >= 2 ? "medium" : "high"
+  };
+}
+function parseBareKeyValueToken(token) {
+  if (token.includes("://")) {
+    return null;
+  }
+  const match = token.match(/^([A-Za-z][A-Za-z0-9_-]{1,63})([:=])(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const key = match[1];
+  const value = match[3];
+  if (value.length === 0) {
+    return null;
+  }
+  return {
+    key,
+    value
+  };
+}
+function normalizeLongOptionToken(token, lookup) {
+  if (!token.startsWith("--")) {
+    return { tokens: [token] };
+  }
+  const equalsIndex = token.indexOf("=");
+  const key = equalsIndex >= 0 ? token.slice(0, equalsIndex) : token;
+  const inlineValue = equalsIndex >= 0 ? token.slice(equalsIndex + 1) : void 0;
+  const resolution = resolveCanonicalFlag(key, lookup);
+  if (!resolution) {
+    return { tokens: [token] };
+  }
+  const normalizedToken = inlineValue === void 0 ? resolution.flag : `${resolution.flag}=${inlineValue}`;
+  if (normalizedToken === token) {
+    return { tokens: [token] };
+  }
+  return {
+    tokens: [normalizedToken],
+    event: {
+      from: token,
+      to: [normalizedToken],
+      reason: resolution.reason,
+      confidence: resolution.confidence
+    }
+  };
+}
+function splitCanonicalListToken(token) {
+  if (!token.startsWith("--")) {
+    return null;
+  }
+  const equalsIndex = token.indexOf("=");
+  if (equalsIndex < 0) {
+    return { flag: token };
+  }
+  return {
+    flag: token.slice(0, equalsIndex),
+    inlineValue: token.slice(equalsIndex + 1)
+  };
+}
+function copyValueConsumingFlag(argv, index, result) {
+  result.push(argv[index]);
+  const next = argv[index + 1];
+  if (typeof next === "string" && next !== "--") {
+    result.push(next);
+    return index + 2;
+  }
+  return index + 1;
+}
+function readListFlagOccurrence(argv, index, parsed, multiValueListFlags) {
+  if (parsed.inlineValue !== void 0) {
+    return {
+      originalTokens: [argv[index]],
+      value: parsed.inlineValue,
+      consumed: 1
+    };
+  }
+  const values = [];
+  let valueIndex = index + 1;
+  while (valueIndex < argv.length && argv[valueIndex] !== "--" && !argv[valueIndex].startsWith("-") && (values.length === 0 || multiValueListFlags.has(parsed.flag))) {
+    values.push(argv[valueIndex]);
+    valueIndex += 1;
+  }
+  const consumed = values.length === 0 ? 1 : 1 + values.length;
+  return {
+    originalTokens: argv.slice(index, index + consumed),
+    value: values.length === 0 ? void 0 : values.join(","),
+    consumed
+  };
+}
+function recordListFlagOccurrence(slots, result, flag, occurrence) {
+  const existing = slots.get(flag);
+  if (existing) {
+    existing.values.push(occurrence.value);
+    existing.occurrences += 1;
+    return;
+  }
+  slots.set(flag, {
+    outputIndex: result.length,
+    originalTokens: occurrence.originalTokens,
+    values: [occurrence.value],
+    occurrences: 1
+  });
+  result.push(null);
+}
+function buildListFlagCoalescingSplices(slots, multiValueListFlags) {
+  const events = [];
+  const splices = [];
+  for (const [flag, slot] of slots) {
+    const shouldMerge = slot.occurrences >= 2 || multiValueListFlags.has(flag) && slot.originalTokens.length > 2;
+    if (!shouldMerge) {
+      splices.push({
+        outputIndex: slot.outputIndex,
+        tokens: slot.originalTokens
+      });
+      continue;
+    }
+    const mergedToken = `${flag}=${slot.values.join(",")}`;
+    splices.push({ outputIndex: slot.outputIndex, tokens: [mergedToken] });
+    events.push({
+      from: `${flag} (x${slot.occurrences})`,
+      to: [mergedToken],
+      reason: "list_merge",
+      confidence: "high"
+    });
+  }
+  return { events, splices };
+}
+function applyListFlagSplices(result, splices) {
+  splices.sort((a, b) => b.outputIndex - a.outputIndex);
+  for (const splice of splices) {
+    result.splice(splice.outputIndex, 1, ...splice.tokens);
+  }
+}
+function coalesceRepeatedListFlags(argv, listFlags, valueConsumingFlags = /* @__PURE__ */ new Set(), multiValueListFlags = /* @__PURE__ */ new Set()) {
+  if (listFlags.size === 0) {
+    return { argv: [...argv], events: [] };
+  }
+  const result = [];
+  const slots = /* @__PURE__ */ new Map();
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      result.push(...argv.slice(index));
+      break;
+    }
+    if (valueConsumingFlags.has(token)) {
+      index = copyValueConsumingFlag(argv, index, result);
+      continue;
+    }
+    const parsed = splitCanonicalListToken(token);
+    if (!parsed || !listFlags.has(parsed.flag)) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    const occurrence = readListFlagOccurrence(argv, index, parsed, multiValueListFlags);
+    if (occurrence.value === void 0) {
+      result.push(token);
+      index += occurrence.consumed;
+      continue;
+    }
+    recordListFlagOccurrence(slots, result, parsed.flag, {
+      originalTokens: occurrence.originalTokens,
+      value: occurrence.value
+    });
+    index += occurrence.consumed;
+  }
+  const { events, splices } = buildListFlagCoalescingSplices(slots, multiValueListFlags);
+  applyListFlagSplices(result, splices);
+  return { argv: result, events };
+}
+var LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG = /* @__PURE__ */ new Map([
+  ["--add", /* @__PURE__ */ new Set(["command", "cmd", "path"])],
+  ["--remove", /* @__PURE__ */ new Set(["command", "path"])]
+]);
+function isLinkedTestTwoTokenValuePosition(commandName, emittedTokens) {
+  if (commandName !== "test" || emittedTokens.length < 2) {
+    return false;
+  }
+  const key = emittedTokens[emittedTokens.length - 1];
+  const flag = emittedTokens[emittedTokens.length - 2];
+  const keys = LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG.get(flag);
+  return keys !== void 0 && keys.has(key);
+}
+function shouldPreserveBareKeyValueToken(commandName, emittedTokens) {
+  return commandName === "search" || isLinkedTestTwoTokenValuePosition(commandName, emittedTokens);
+}
+function mergeLinkedTestTwoTokenEntries(argv, commandName, trace) {
+  if (commandName !== "test") {
+    return argv;
+  }
+  const result = [];
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      result.push(...argv.slice(index));
+      return result;
+    }
+    const keys = LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG.get(token);
+    const key = keys ? argv[index + 1] : void 0;
+    if (!keys || typeof key !== "string" || !keys.has(key)) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    let runEnd = index + 2;
+    while (runEnd < argv.length && !argv[runEnd].startsWith("-")) {
+      runEnd += 1;
+    }
+    if (runEnd - (index + 2) !== 1) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    const value = argv[index + 2];
+    const mergedValue = `${key}=${value}`;
+    result.push(token, mergedValue);
+    trace.push({
+      from: `${token} ${key} ${value}`,
+      to: [token, mergedValue],
+      reason: "bare_key_value",
+      confidence: "high"
+    });
+    index += 3;
+  }
+  return result;
+}
+function normalizeBootstrapInvocation(argv) {
+  const trace = [];
+  const legacyNormalized = normalizeLegacyExtensionActionSyntax(argv);
+  if (legacyNormalized.length !== argv.length || legacyNormalized.some((token, index) => token !== argv[index])) {
+    trace.push({
+      from: argv.join(" "),
+      to: [...legacyNormalized],
+      reason: "legacy_extension_action",
+      confidence: "high"
+    });
+  }
+  const aliasNormalized = rewriteCommandAlias(legacyNormalized, trace);
+  const commandName = parseBootstrapCommandName(aliasNormalized);
+  const commandPathName = parseBootstrapCommandPathName(aliasNormalized);
+  const lookup = buildFlagLookup(commandPathName ?? commandName);
+  const normalizedArgv = [];
+  for (let index = 0; index < aliasNormalized.length; index += 1) {
+    const token = aliasNormalized[index];
+    if (token === "--") {
+      normalizedArgv.push(...aliasNormalized.slice(index));
+      break;
+    }
+    const previous = normalizedArgv[normalizedArgv.length - 1];
+    if (token.startsWith("--")) {
+      const normalizedToken = normalizeLongOptionToken(token, lookup);
+      normalizedArgv.push(...normalizedToken.tokens);
+      if (normalizedToken.event) {
+        trace.push(normalizedToken.event);
+      }
+      continue;
+    }
+    const bareKeyValue = parseBareKeyValueToken(token);
+    if (bareKeyValue && !(typeof previous === "string" && previous.startsWith("-")) && !shouldPreserveBareKeyValueToken(commandName, normalizedArgv)) {
+      const resolution = resolveCanonicalFlag(bareKeyValue.key, lookup);
+      if (resolution) {
+        const replacement = [resolution.flag, bareKeyValue.value];
+        normalizedArgv.push(...replacement);
+        trace.push({
+          from: token,
+          to: replacement,
+          reason: "bare_key_value",
+          confidence: resolution.confidence
+        });
+        continue;
+      }
+    }
+    normalizedArgv.push(token);
+  }
+  const linkedTestNormalized = mergeLinkedTestTwoTokenEntries(normalizedArgv, commandName, trace);
+  const coalesced = coalesceRepeatedListFlags(linkedTestNormalized, lookup.listCanonicalFlags, GLOBAL_VALUE_CONSUMING_FLAGS, commandName === "create" ? /* @__PURE__ */ new Set(["--tags"]) : /* @__PURE__ */ new Set());
+  for (const event of coalesced.events) {
+    trace.push(event);
+  }
+  return {
+    argv: coalesced.argv,
+    commandName,
+    trace
+  };
+}
+function parseBootstrapCommandPathName(argv) {
+  const stripped = stripGlobalBootstrapTokens(argv);
+  const first = stripped[0]?.trim().toLowerCase();
+  const second = stripped[1]?.trim().toLowerCase();
+  if ((first === "extension" || first === "package" || first === "packages") && typeof second === "string" && second.length > 0 && !second.startsWith("-")) {
+    return `${first} ${second}`;
+  }
+  return first;
+}
+function parseBootstrapTypeValue(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--type") {
+      const candidate = argv[index + 1];
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
+      continue;
+    }
+    if (token.startsWith("--type=")) {
+      const candidate = token.slice("--type=".length).trim();
+      if (candidate.length > 0) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+
 // dist/cli/migration-gates.js
 !(function() {
   try {
@@ -3506,6 +4277,15 @@ async function enforceItemFormatWriteGateAndPreflightMigration(commandPath, opti
   }
 }
 
+// dist/cli/commands/extension/shared.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] = "7bcb2c6c-3b04-5a62-8863-3596d9f0f7ac");
+  } catch (e2) {
+  }
+})();
+
 // dist/cli/commander-usage.js
 !(function() {
   try {
@@ -4322,7 +5102,7 @@ function attachCreateUpdatePolicyHelpText(rootProgram, typeRegistry, argv) {
 !(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] = "e1e2f806-6259-50db-8255-8a1656b69c5c");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "422e7133-3086-5221-ab89-27a20135ee08");
   } catch (e2) {
   }
 })();
@@ -4378,10 +5158,10 @@ var EXPECTED_HANDLED_ERROR_EXIT_CODES = /* @__PURE__ */ new Set([
   EXIT_CODE.CONFLICT
 ]);
 var TRUE_LIKE_ENV_VALUES = /* @__PURE__ */ new Set(["1", "true", "yes", "on"]);
-var loadSetupRegistrationModule = createLazyModule(() => import("./chunks/register-setup-5XNGKJ22.js"));
-var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-BUWCYHBT.js"));
-var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-UELYYOR7.js"));
-var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-ISUX6LY5.js"));
+var loadSetupRegistrationModule = createLazyModule(() => import("./chunks/register-setup-BCVLFEYS.js"));
+var loadListQueryRegistrationModule = createLazyModule(() => import("./chunks/register-list-query-DKA3EH5D.js"));
+var loadMutationRegistrationModule = createLazyModule(() => import("./chunks/register-mutation-ARFHRW55.js"));
+var loadOperationRegistrationModule = createLazyModule(() => import("./chunks/register-operations-ZUJ5JWPE.js"));
 function describeUnknownError(error) {
   if (error instanceof PmCliError) {
     return error.message;
@@ -5716,15 +6496,7 @@ async function registerDynamicExtensionCommandPaths(rootProgram, invocationArgv)
   }
 }
 var CLI_VERSION = resolvePmCliVersion(import.meta.url, ["../.."]) ?? "0.0.0";
-var program = new Command();
-program.name("pm").description("Universal, flexible, extensible, agent-optimized project management CLI for any project or programming language.").version(CLI_VERSION).showHelpAfterError(false).allowExcessArguments(false).allowUnknownOption(false).configureOutput({
-  writeOut: (str) => {
-    writeStdout(str);
-  },
-  // Commander errors are rendered in our own catch path.
-  writeErr: () => {
-  }
-}).option("--json", "Output JSON instead of TOON").option("--quiet", "Suppress stdout output").option("--no-changed-fields", "Omit the changed_fields array from mutation output (keeps changed_field_count)").option("--id-only", "Print only id and status for single-item mutation output").option("--pm-path <dir>", "Explicit tracker storage path for this command (preferred over --path)").option("--path <dir>", "Backward-compatible alias for --pm-path; this is the tracker storage path, not a workspace cwd").option("--no-extensions", "Disable extension loading").option("--no-pager", "Disable pager integration for help and long output").option("--explain", "Render extended rationale and examples in help output").option("--profile", "Print deterministic timing diagnostics").exitOverride();
+var program = createPmCliProgram(CLI_VERSION);
 program.hook("preAction", async (_thisCommand, actionCommand) => {
   activeExtensionHookContext = null;
   activeTelemetryCommandContext = null;
@@ -6418,7 +7190,16 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
     ...invocationArgv
   ];
   const isBareInvocation = invocationArgv.length === 0;
+  let restorePmAuthor;
   try {
+    const bootstrapGlobal = parseBootstrapGlobalOptions(invocationArgv);
+    if (bootstrapGlobal.authorMissingValue) {
+      throw new PmCliError("--author requires a non-empty value.", EXIT_CODE.USAGE, {
+        code: "missing_required_argument",
+        nextSteps: ["Pass an explicit author identifier with --author <id>."]
+      });
+    }
+    restorePmAuthor = applyInvocationAuthorOverride(bootstrapGlobal.author);
     enforceExplicitRetryForFlagTypos(bootstrapInvocation);
     applyBootstrapPagerPolicy(invocationArgv);
     const registrationSelection = resolveCoreCommandRegistrationSelection(invocationArgv);
@@ -6448,6 +7229,8 @@ async function runPmCli(rawArgv = process.argv.slice(2)) {
     await program.parseAsync(invocationProcessArgv);
   } catch (error) {
     await handleRunPmCliError({ error, invocationArgv });
+  } finally {
+    restorePmAuthor?.();
   }
 }
 var _testOnly = {