@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-KSRUHV2H.js

@@ -0,0 +1,76 @@
+
+!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]="784042df-8ddd-5a48-90f8-9118a8ebeddd")}catch(e){}}();
+import {
+  runCreate
+} from "./chunk-TULGS6X6.js";
+
+// dist/cli/commands/scheduling-shortcuts.js
+var DEFAULT_DURATION = "1h";
+var DEFAULT_START = "now";
+var DEFAULT_REMINDER_AT = "+1d";
+function quoteCsvValue(value) {
+  return `"${value.replace(/\\/g, "\\\\").replace(/"/g, '\\"')}"`;
+}
+function appendPair(pairs, key, value) {
+  if (value !== void 0) {
+    pairs.push(`${key}=${quoteCsvValue(value)}`);
+  }
+}
+function buildCommonOptions(type, title, options) {
+  return {
+    type,
+    title,
+    schedulePreset: "lightweight",
+    parent: options.parent,
+    allowMissingParent: options.allowMissingParent,
+    tags: options.tags,
+    priority: options.priority,
+    body: options.body,
+    description: options.description,
+    author: options.author,
+    message: options.message
+  };
+}
+function buildEventEntry(options) {
+  const pairs = [];
+  appendPair(pairs, "start", options.start ?? DEFAULT_START);
+  if (options.end !== void 0) {
+    appendPair(pairs, "end", options.end);
+  } else {
+    appendPair(pairs, "duration", options.duration ?? DEFAULT_DURATION);
+  }
+  appendPair(pairs, "location", options.location);
+  appendPair(pairs, "timezone", options.timezone);
+  if (options.allDay === true) {
+    appendPair(pairs, "all_day", "true");
+  }
+  return pairs.join(",");
+}
+async function createScheduled(type, title, options, global) {
+  const createOptions = buildCommonOptions(type, title, options);
+  createOptions.event = [buildEventEntry(options)];
+  return runCreate(createOptions, global);
+}
+function runMeet(title, options, global) {
+  return createScheduled("Meeting", title, options, global);
+}
+function runEvent(title, options, global) {
+  return createScheduled("Event", title, options, global);
+}
+function runRemind(title, options, global) {
+  const createOptions = buildCommonOptions("Reminder", title, options);
+  const pairs = [];
+  appendPair(pairs, "at", options.at ?? DEFAULT_REMINDER_AT);
+  appendPair(pairs, "text", options.text ?? title);
+  createOptions.reminder = [pairs.join(",")];
+  return runCreate(createOptions, global);
+}
+
+export {
+  runMeet,
+  runEvent,
+  runRemind
+};
+//# sourceMappingURL=chunk-KSRUHV2H.js.map
+
+//# debugId=784042df-8ddd-5a48-90f8-9118a8ebeddd

package/dist/cli-bundle/chunks/chunk-KSRUHV2H.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../cli/commands/scheduling-shortcuts.ts"],"sourcesContent":["/**\n * @module cli/commands/scheduling-shortcuts\n *\n * Implements the pm scheduling shortcuts command surface and its agent-facing runtime behavior.\n */\nimport type { GlobalOptions } from \"../../core/shared/command-types.js\";\nimport { runCreate, type CreateCommandOptions, type CreateResult } from \"./create.js\";\n\n/**\n * GH-217: low-friction creation shortcuts for the scheduling item types\n * (Meeting/Event/Reminder), which sit unused because `pm create --type Event`\n * demands structured `--event`/`--reminder` CSV entries. These commands accept\n * friendly time flags (`--start`, `--duration`, `--end`, `--at`) and translate\n * them into the canonical scheduling fields, then delegate to `runCreate` so the\n * full create pipeline (parent/focus inheritance, governance, hooks, validation)\n * applies unchanged. The `lightweight` schedule preset is applied so progressive\n * scheduling fields are not demanded up front.\n */\n\n/** Options shared by every scheduling shortcut, forwarded to `runCreate`. */\nexport interface SchedulingShortcutCommonOptions {\n  parent?: string;\n  allowMissingParent?: boolean;\n  tags?: string;\n  priority?: string;\n  body?: string;\n  description?: string;\n  author?: string;\n  message?: string;\n}\n\n/** Options for `pm meet` and `pm event` (a start time plus a span). */\nexport interface MeetingEventShortcutOptions extends SchedulingShortcutCommonOptions {\n  start?: string;\n  duration?: string;\n  end?: string;\n  location?: string;\n  timezone?: string;\n  allDay?: boolean;\n}\n\n/** Options for `pm remind` (a single point in time). */\nexport interface ReminderShortcutOptions extends SchedulingShortcutCommonOptions {\n  at?: string;\n  text?: string;\n}\n\n/** Default span applied when neither `--end` nor `--duration` is given. */\nconst DEFAULT_DURATION = \"1h\";\n/** Default start applied when `--start` is omitted (keeps the item calendar-visible). */\nconst DEFAULT_START = \"now\";\n/** Default reminder time applied when `--at` is omitted. */\nconst DEFAULT_REMINDER_AT = \"+1d\";\n\n/**\n * Wrap a free-text value (reminder text, event location) in double quotes so\n * commas and colons survive the CSV round-trip into `--reminder`/`--event`.\n * Backslashes are escaped first, then embedded quotes — escaping quotes alone\n * would let a trailing backslash escape the closing quote and break out of the\n * quoted field (CSV injection). The parser's `unquoteValue` strips the wrapping\n * quotes and unescapes `\\\"` back to `\"`.\n */\nfunction quoteCsvValue(value: string): string {\n  return `\"${value.replace(/\\\\/g, \"\\\\\\\\\").replace(/\"/g, \"\\\\\\\"\")}\"`;\n}\n\n/**\n * Append a `key=\"value\"` pair. EVERY value is double-quoted (not just free-text\n * fields) so a comma or `=` in any token — `start`, `duration`, `at`, etc. —\n * cannot inject extra CSV key/value pairs into the `--event`/`--reminder`\n * entry. The parser's `parseCsvKv` unquotes every value before use, so quoting\n * is transparent to ISO/relative/timezone tokens.\n */\nfunction appendPair(pairs: string[], key: string, value: string | undefined): void {\n  if (value !== undefined) {\n    pairs.push(`${key}=${quoteCsvValue(value)}`);\n  }\n}\n\nfunction buildCommonOptions(\n  type: string,\n  title: string,\n  options: SchedulingShortcutCommonOptions,\n): CreateCommandOptions {\n  return {\n    type,\n    title,\n    schedulePreset: \"lightweight\",\n    parent: options.parent,\n    allowMissingParent: options.allowMissingParent,\n    tags: options.tags,\n    priority: options.priority,\n    body: options.body,\n    description: options.description,\n    author: options.author,\n    message: options.message,\n  };\n}\n\nfunction buildEventEntry(options: MeetingEventShortcutOptions): string {\n  const pairs: string[] = [];\n  appendPair(pairs, \"start\", options.start ?? DEFAULT_START);\n  if (options.end !== undefined) {\n    appendPair(pairs, \"end\", options.end);\n  } else {\n    appendPair(pairs, \"duration\", options.duration ?? DEFAULT_DURATION);\n  }\n  appendPair(pairs, \"location\", options.location);\n  appendPair(pairs, \"timezone\", options.timezone);\n  if (options.allDay === true) {\n    appendPair(pairs, \"all_day\", \"true\");\n  }\n  return pairs.join(\",\");\n}\n\nasync function createScheduled(\n  type: string,\n  title: string,\n  options: MeetingEventShortcutOptions,\n  global: GlobalOptions,\n): Promise<CreateResult> {\n  const createOptions = buildCommonOptions(type, title, options);\n  createOptions.event = [buildEventEntry(options)];\n  return runCreate(createOptions, global);\n}\n\n/** `pm meet \"<title>\"` — create a Meeting with sensible scheduling defaults. */\nexport function runMeet(\n  title: string,\n  options: MeetingEventShortcutOptions,\n  global: GlobalOptions,\n): Promise<CreateResult> {\n  return createScheduled(\"Meeting\", title, options, global);\n}\n\n/** `pm event \"<title>\"` — create an Event with sensible scheduling defaults. */\nexport function runEvent(\n  title: string,\n  options: MeetingEventShortcutOptions,\n  global: GlobalOptions,\n): Promise<CreateResult> {\n  return createScheduled(\"Event\", title, options, global);\n}\n\n/** `pm remind \"<title>\"` — create a Reminder from a single point in time. */\nexport function runRemind(\n  title: string,\n  options: ReminderShortcutOptions,\n  global: GlobalOptions,\n): Promise<CreateResult> {\n  const createOptions = buildCommonOptions(\"Reminder\", title, options);\n  const pairs: string[] = [];\n  appendPair(pairs, \"at\", options.at ?? DEFAULT_REMINDER_AT);\n  appendPair(pairs, \"text\", options.text ?? title);\n  createOptions.reminder = [pairs.join(\",\")];\n  return runCreate(createOptions, global);\n}\n"],"names":[],"mappings":";;;;;;;AAgDA,IAAM,mBAAmB;AAEzB,IAAM,gBAAgB;AAEtB,IAAM,sBAAsB;AAU5B,SAAS,cAAc,OAAa;AAClC,SAAO,IAAI,MAAM,QAAQ,OAAO,MAAM,EAAE,QAAQ,MAAM,KAAM,CAAC;AAC/D;AASA,SAAS,WAAW,OAAiB,KAAa,OAAyB;AACzE,MAAI,UAAU,QAAW;AACvB,UAAM,KAAK,GAAG,GAAG,IAAI,cAAc,KAAK,CAAC,EAAE;EAC7C;AACF;AAEA,SAAS,mBACP,MACA,OACA,SAAwC;AAExC,SAAO;IACL;IACA;IACA,gBAAgB;IAChB,QAAQ,QAAQ;IAChB,oBAAoB,QAAQ;IAC5B,MAAM,QAAQ;IACd,UAAU,QAAQ;IAClB,MAAM,QAAQ;IACd,aAAa,QAAQ;IACrB,QAAQ,QAAQ;IAChB,SAAS,QAAQ;;AAErB;AAEA,SAAS,gBAAgB,SAAoC;AAC3D,QAAM,QAAkB,CAAA;AACxB,aAAW,OAAO,SAAS,QAAQ,SAAS,aAAa;AACzD,MAAI,QAAQ,QAAQ,QAAW;AAC7B,eAAW,OAAO,OAAO,QAAQ,GAAG;EACtC,OAAO;AACL,eAAW,OAAO,YAAY,QAAQ,YAAY,gBAAgB;EACpE;AACA,aAAW,OAAO,YAAY,QAAQ,QAAQ;AAC9C,aAAW,OAAO,YAAY,QAAQ,QAAQ;AAC9C,MAAI,QAAQ,WAAW,MAAM;AAC3B,eAAW,OAAO,WAAW,MAAM;EACrC;AACA,SAAO,MAAM,KAAK,GAAG;AACvB;AAEA,eAAe,gBACb,MACA,OACA,SACA,QAAqB;AAErB,QAAM,gBAAgB,mBAAmB,MAAM,OAAO,OAAO;AAC7D,gBAAc,QAAQ,CAAC,gBAAgB,OAAO,CAAC;AAC/C,SAAO,UAAU,eAAe,MAAM;AACxC;AAGM,SAAU,QACd,OACA,SACA,QAAqB;AAErB,SAAO,gBAAgB,WAAW,OAAO,SAAS,MAAM;AAC1D;AAGM,SAAU,SACd,OACA,SACA,QAAqB;AAErB,SAAO,gBAAgB,SAAS,OAAO,SAAS,MAAM;AACxD;AAGM,SAAU,UACd,OACA,SACA,QAAqB;AAErB,QAAM,gBAAgB,mBAAmB,YAAY,OAAO,OAAO;AACnE,QAAM,QAAkB,CAAA;AACxB,aAAW,OAAO,MAAM,QAAQ,MAAM,mBAAmB;AACzD,aAAW,OAAO,QAAQ,QAAQ,QAAQ,KAAK;AAC/C,gBAAc,WAAW,CAAC,MAAM,KAAK,GAAG,CAAC;AACzC,SAAO,UAAU,eAAe,MAAM;AACxC","debugId":"784042df-8ddd-5a48-90f8-9118a8ebeddd"}

package/dist/cli-bundle/chunks/chunk-KUOOJR35.js

@@ -0,0 +1,260 @@
+
+!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]="1b7c28c0-5af8-526d-a895-fe83ffb2841e")}catch(e){}}();
+import {
+  BUILTIN_ITEM_TYPE_VALUES,
+  toDefaultFolder
+} from "./chunk-57NWPFF2.js";
+
+// dist/core/schema/item-types-file.js
+var BUILTIN_NAME_LOOKUP = new Map(BUILTIN_ITEM_TYPE_VALUES.map((name) => [name.toLowerCase(), name]));
+var TYPE_NAME_TOKEN_PATTERN = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function assertValidTypeToken(value, label) {
+  if (!TYPE_NAME_TOKEN_PATTERN.test(value)) {
+    throw new Error(`${label} "${value}" is not a valid identifier. Use a single letter-led token of letters, digits, hyphen, or underscore with no spaces or punctuation (e.g. "Spike" or "code-review").`);
+  }
+}
+function matchBuiltinTypeName(name) {
+  return BUILTIN_NAME_LOOKUP.get(name.trim().toLowerCase());
+}
+function coerceAliasArray(value) {
+  return Array.isArray(value) ? value.filter((entry) => typeof entry === "string") : [];
+}
+function escapeForDoubleQuotes(value) {
+  return value.replace(/[\\"`$]/g, (char) => `\\${char}`);
+}
+function dedupeAliases(values) {
+  const seen = /* @__PURE__ */ new Map();
+  for (const value of values) {
+    const trimmed = value.trim();
+    if (trimmed.length === 0) {
+      continue;
+    }
+    const key = trimmed.toLowerCase();
+    if (!seen.has(key)) {
+      seen.set(key, trimmed);
+    }
+  }
+  return [...seen.values()].sort((left, right) => left.localeCompare(right));
+}
+function normalizeAddTypeInput(raw) {
+  const name = (raw.name ?? "").trim();
+  if (name.length === 0) {
+    throw new Error("Type name must not be empty.");
+  }
+  assertValidTypeToken(name, "Type name");
+  const builtinMatch = matchBuiltinTypeName(name);
+  if (builtinMatch) {
+    throw new Error(`Cannot redefine built-in item type "${builtinMatch}". Built-in types are reserved: ${BUILTIN_ITEM_TYPE_VALUES.join(", ")}.`);
+  }
+  const description = raw.description?.trim();
+  const defaultStatus = raw.defaultStatus?.trim();
+  const folder = raw.folder?.trim();
+  const aliases = dedupeAliases(raw.aliases ?? []);
+  for (const alias of aliases) {
+    assertValidTypeToken(alias, "Alias");
+    const aliasBuiltin = matchBuiltinTypeName(alias);
+    if (aliasBuiltin) {
+      throw new Error(`Alias "${alias}" collides with built-in item type "${aliasBuiltin}". Built-in types are reserved: ${BUILTIN_ITEM_TYPE_VALUES.join(", ")}.`);
+    }
+  }
+  return {
+    name,
+    description: description && description.length > 0 ? description : void 0,
+    defaultStatus: defaultStatus && defaultStatus.length > 0 ? defaultStatus : void 0,
+    folder: folder && folder.length > 0 ? folder : void 0,
+    aliases
+  };
+}
+function assertAliasesAvailable(input, existing) {
+  const selfLower = input.name.toLowerCase();
+  const taken = /* @__PURE__ */ new Map();
+  for (const definition of existing.definitions) {
+    if (typeof definition.name !== "string") {
+      continue;
+    }
+    const definitionName = definition.name.trim();
+    if (definitionName.length === 0 || definitionName.toLowerCase() === selfLower) {
+      continue;
+    }
+    taken.set(definitionName.toLowerCase(), definitionName);
+    for (const alias of coerceAliasArray(definition.aliases)) {
+      if (alias.trim().length > 0) {
+        taken.set(alias.trim().toLowerCase(), definitionName);
+      }
+    }
+  }
+  const nameOwner = taken.get(selfLower);
+  if (nameOwner) {
+    throw new Error(`Type name "${input.name}" collides with an alias of existing item type "${nameOwner}".`);
+  }
+  for (const alias of input.aliases) {
+    const owner = taken.get(alias.toLowerCase());
+    if (owner) {
+      throw new Error(`Alias "${alias}" already maps to existing item type "${owner}".`);
+    }
+  }
+}
+function resolveDefinitionFolder(name, folder) {
+  if (typeof folder === "string" && folder.trim().length > 0) {
+    return folder.trim().toLowerCase();
+  }
+  return toDefaultFolder(name).toLowerCase();
+}
+function assertTypeFolderAvailable(input, existing, reservedFolders) {
+  const selfLower = input.name.toLowerCase();
+  const inputFolder = resolveDefinitionFolder(input.name, input.folder);
+  const fail = (ownerName) => {
+    throw new Error(`Item type "${input.name}" would store items in folder "${inputFolder}", which already belongs to existing item type "${ownerName}". Pass a distinct --folder to keep their storage separate.`);
+  };
+  for (const definition of existing.definitions) {
+    if (typeof definition.name !== "string") {
+      continue;
+    }
+    const definitionName = definition.name.trim();
+    if (definitionName.length === 0 || definitionName.toLowerCase() === selfLower) {
+      continue;
+    }
+    if (resolveDefinitionFolder(definitionName, definition.folder) === inputFolder) {
+      fail(definitionName);
+    }
+  }
+  const reservedOwner = reservedFolders?.get(inputFolder);
+  if (reservedOwner !== void 0 && reservedOwner.toLowerCase() !== selfLower) {
+    fail(reservedOwner);
+  }
+}
+function parseItemTypesFile(raw) {
+  if (raw === null || raw === void 0 || raw.trim().length === 0) {
+    return { definitions: [] };
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new Error("schema/types.json contains invalid JSON.");
+  }
+  return { definitions: extractDefinitions(parsed) };
+}
+function extractDefinitions(parsed) {
+  const candidate = selectDefinitionsArray(parsed);
+  if (!candidate) {
+    return [];
+  }
+  const definitions = [];
+  for (const entry of candidate) {
+    if (typeof entry !== "object" || entry === null || Array.isArray(entry)) {
+      continue;
+    }
+    const record = entry;
+    if (typeof record.name !== "string" || record.name.trim().length === 0) {
+      continue;
+    }
+    definitions.push(record);
+  }
+  return definitions;
+}
+function selectDefinitionsArray(parsed) {
+  if (Array.isArray(parsed)) {
+    return parsed;
+  }
+  if (typeof parsed !== "object" || parsed === null) {
+    return void 0;
+  }
+  const record = parsed;
+  if (Array.isArray(record.definitions)) {
+    return record.definitions;
+  }
+  if (typeof record.item_types === "object" && record.item_types !== null) {
+    const nested = record.item_types;
+    if (Array.isArray(nested.definitions)) {
+      return nested.definitions;
+    }
+  }
+  return void 0;
+}
+function upsertItemType(file, input) {
+  const lowerName = input.name.toLowerCase();
+  const definitions = file.definitions.slice();
+  const existingIndex = definitions.findIndex((definition) => typeof definition.name === "string" && definition.name.trim().toLowerCase() === lowerName);
+  const existing = existingIndex >= 0 ? definitions[existingIndex] : void 0;
+  const mergedAliases = dedupeAliases([...coerceAliasArray(existing?.aliases), ...input.aliases]);
+  const next = {
+    ...existing,
+    name: input.name
+  };
+  if (input.folder !== void 0) {
+    next.folder = input.folder;
+  }
+  if (mergedAliases.length > 0) {
+    next.aliases = mergedAliases;
+  } else if (next.aliases !== void 0) {
+    delete next.aliases;
+  }
+  applyAttribute(next, "description", input.description);
+  applyAttribute(next, "default_status", input.defaultStatus);
+  if (existingIndex >= 0) {
+    definitions[existingIndex] = next;
+  } else {
+    definitions.push(next);
+  }
+  definitions.sort((left, right) => left.name.localeCompare(right.name));
+  return {
+    file: { definitions },
+    definition: next,
+    replaced: existingIndex >= 0,
+    ...existing && typeof existing.name === "string" ? { previousName: existing.name } : {}
+  };
+}
+function removeItemType(file, name) {
+  const trimmed = (name ?? "").trim();
+  if (trimmed.length === 0) {
+    throw new Error("Type name must not be empty.");
+  }
+  const builtinMatch = matchBuiltinTypeName(trimmed);
+  if (builtinMatch) {
+    throw new Error(`Cannot remove built-in item type "${builtinMatch}". Built-in types are reserved: ${BUILTIN_ITEM_TYPE_VALUES.join(", ")}.`);
+  }
+  const lowerName = trimmed.toLowerCase();
+  const definitions = file.definitions.slice();
+  const existingIndex = definitions.findIndex((definition2) => typeof definition2.name === "string" && definition2.name.trim().toLowerCase() === lowerName);
+  if (existingIndex < 0) {
+    return { file: { definitions }, removed: false };
+  }
+  const [definition] = definitions.splice(existingIndex, 1);
+  return { file: { definitions }, removed: true, definition };
+}
+function applyAttribute(definition, key, value) {
+  const record = definition;
+  if (value !== void 0) {
+    record[key] = value;
+  }
+}
+function serializeItemTypesFile(file) {
+  return `${JSON.stringify({ definitions: file.definitions }, null, 2)}
+`;
+}
+function buildInvalidTypeHint(name, typesFilePath) {
+  const safeName = name.trim().length > 0 ? name.trim() : name;
+  const target = typesFilePath?.trim() || ".agents/pm/schema/types.json";
+  return `To register a custom type, run: pm schema add-type "${escapeForDoubleQuotes(safeName)}" (writes ${target}).`;
+}
+function buildInvalidTypeError(name, allowedTypes, typesFilePath) {
+  return `Invalid type value "${name}". Allowed: ${allowedTypes.join(", ")}. ${buildInvalidTypeHint(name, typesFilePath)}`;
+}
+
+export {
+  matchBuiltinTypeName,
+  escapeForDoubleQuotes,
+  normalizeAddTypeInput,
+  assertAliasesAvailable,
+  assertTypeFolderAvailable,
+  parseItemTypesFile,
+  upsertItemType,
+  removeItemType,
+  serializeItemTypesFile,
+  buildInvalidTypeHint,
+  buildInvalidTypeError
+};
+//# sourceMappingURL=chunk-KUOOJR35.js.map
+
+//# debugId=1b7c28c0-5af8-526d-a895-fe83ffb2841e

package/dist/cli-bundle/chunks/chunk-L5PSPMZ4.js

@@ -0,0 +1,277 @@
+import {
+  cloneEmptyReplayDocument,
+  normalizeReplayPatchOps,
+  tryApplyReplayPatch,
+  verifyHistoryChain
+} from "./chunk-XUC7PI2H.js";
+import {
+  parseLimit
+} from "./chunk-7DT4WSH2.js";
+import {
+  enforceHistoryStreamPolicyForItem,
+  hashDocument,
+  hashEmptyDocument,
+  locateItem,
+  readLocatedItem
+} from "./chunk-5VAA4YHR.js";
+import {
+  findFirstMergeConflictMarker,
+  normalizeItemId
+} from "./chunk-NMP5I3I5.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  runActiveOnReadHooks
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE,
+  getHistoryPath,
+  getSettingsPath,
+  pathExists,
+  readFileIfExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot
+} from "./chunk-LK6XLOGP.js";
+
+// dist/core/history/history-diff.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] = "c7930d48-5a36-54db-a658-c94664073e13");
+  } catch (e2) {
+  }
+})();
+function decodeJsonPointerSegment(segment) {
+  return segment.replaceAll("~1", "/").replaceAll("~0", "~");
+}
+function patchPathToChangedField(path) {
+  if (path === "/body" || path.startsWith("/body/"))
+    return "body";
+  if (path === "/metadata" || path.startsWith("/metadata/") || path === "/front_matter" || path.startsWith("/front_matter/")) {
+    const segment2 = path.replace(/^\/(?:metadata|front_matter)\/?/, "").split("/")[0];
+    if (!segment2)
+      return "metadata";
+    return decodeJsonPointerSegment(segment2);
+  }
+  const segment = path.replace(/^\//, "").split("/")[0];
+  return segment ? decodeJsonPointerSegment(segment) : "root";
+}
+function readFieldValue(doc, field) {
+  if (field === "body")
+    return doc.body;
+  if (field === "metadata")
+    return doc.metadata;
+  if (field === "root")
+    return doc;
+  return doc.metadata[field];
+}
+function computeHistoryDiff(fullEntries, options) {
+  const windowStartIndex = options?.windowStartIndex ?? 0;
+  const fieldFilter = options?.field;
+  if (fullEntries.length === 0 || windowStartIndex >= fullEntries.length) {
+    return [];
+  }
+  let current = cloneEmptyReplayDocument();
+  const result = [];
+  for (let p = 0; p < fullEntries.length; p += 1) {
+    const entry = fullEntries[p];
+    const beforeDoc = current;
+    const applied = tryApplyReplayPatch(current, entry.patch);
+    let afterDoc;
+    if (applied.ok) {
+      afterDoc = applied.document;
+      current = afterDoc;
+    } else {
+      afterDoc = beforeDoc;
+    }
+    const changedFieldSet = /* @__PURE__ */ new Set();
+    for (const patchOp of entry.patch) {
+      changedFieldSet.add(patchPathToChangedField(patchOp.path));
+      if (patchOp.from !== void 0) {
+        changedFieldSet.add(patchPathToChangedField(patchOp.from));
+      }
+    }
+    const sortedFields = [...changedFieldSet].sort((a, b) => a.localeCompare(b));
+    if (p >= windowStartIndex) {
+      if (fieldFilter !== void 0) {
+        if (!changedFieldSet.has(fieldFilter)) {
+          continue;
+        }
+        const change = {
+          field: fieldFilter,
+          before: readFieldValue(beforeDoc, fieldFilter),
+          after: readFieldValue(afterDoc, fieldFilter)
+        };
+        result.push({
+          index: p + 1,
+          ts: entry.ts,
+          op: entry.op,
+          author: entry.author,
+          patch_ops: entry.patch.length,
+          changed_fields: [fieldFilter],
+          changes: [change]
+        });
+      } else {
+        const changes = sortedFields.map((field) => ({
+          field,
+          before: readFieldValue(beforeDoc, field),
+          after: readFieldValue(afterDoc, field)
+        }));
+        result.push({
+          index: p + 1,
+          ts: entry.ts,
+          op: entry.op,
+          author: entry.author,
+          patch_ops: entry.patch.length,
+          changed_fields: sortedFields,
+          changes
+        });
+      }
+    }
+  }
+  return result;
+}
+
+// dist/cli/commands/history.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] = "710a323b-06aa-5b7c-9820-f9a26faf6c4a");
+  } catch (e2) {
+  }
+})();
+function limitEntries(values, limit) {
+  if (limit === void 0)
+    return values;
+  return values.slice(Math.max(0, values.length - limit));
+}
+function buildDiffEntries(entries, startIndex) {
+  return entries.map((entry, index) => {
+    const changedFields = /* @__PURE__ */ new Set();
+    const patch = normalizeReplayPatchOps(entry.patch);
+    for (const op of patch) {
+      changedFields.add(patchPathToChangedField(op.path));
+      if (op.from) {
+        changedFields.add(patchPathToChangedField(op.from));
+      }
+    }
+    return {
+      index: startIndex + index + 1,
+      ts: entry.ts,
+      op: entry.op,
+      author: entry.author,
+      patch_ops: patch.length,
+      changed_fields: [...changedFields].sort((left, right) => left.localeCompare(right))
+    };
+  });
+}
+async function readHistoryEntries(historyPath, itemId) {
+  const raw = await readFileIfExists(historyPath);
+  if (raw === null) {
+    return [];
+  }
+  await runActiveOnReadHooks({
+    path: historyPath,
+    scope: "project"
+  });
+  if (raw.trim() === "") {
+    return [];
+  }
+  const conflictMarker = findFirstMergeConflictMarker(raw);
+  if (conflictMarker) {
+    throw new PmCliError(`History for ${itemId} contains merge conflict markers at line ${conflictMarker.line} (${conflictMarker.marker}). Resolve <<<<<<< ======= >>>>>>> markers and retry.`, EXIT_CODE.GENERIC_FAILURE, {
+      code: "history_merge_conflict_markers_detected",
+      required: "Repair the history stream by resolving merge-conflict markers.",
+      why: "Conflict markers break JSONL parsing and invalidate deterministic audit history.",
+      examples: [`pm history ${itemId}`, `pm restore ${itemId} <timestamp-or-version>`],
+      nextSteps: ["Resolve or restore the history file, then rerun the command."]
+    });
+  }
+  const entries = [];
+  const lines = raw.split(/\r?\n/);
+  for (let index = 0; index < lines.length; index += 1) {
+    const line = lines[index]?.trim();
+    if (!line)
+      continue;
+    try {
+      entries.push(JSON.parse(line));
+    } catch {
+      throw new PmCliError(`History for ${itemId} contains invalid JSON at line ${index + 1}. Repair or restore the history stream and retry.`, EXIT_CODE.GENERIC_FAILURE);
+    }
+  }
+  return entries;
+}
+async function runHistory(id, options, global2) {
+  const pmRoot = resolvePmRoot(process.cwd(), global2.path);
+  if (!await pathExists(getSettingsPath(pmRoot))) {
+    throw new PmCliError(`Tracker is not initialized at ${pmRoot}. Run pm init first.`, EXIT_CODE.NOT_FOUND);
+  }
+  const limit = parseLimit(options.limit);
+  const settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const normalizedId = normalizeItemId(id, settings.id_prefix);
+  const located = await locateItem(pmRoot, normalizedId, settings.id_prefix, settings.item_format, typeRegistry.type_to_folder);
+  const resolvedId = located?.id ?? normalizedId;
+  const historyPath = getHistoryPath(pmRoot, resolvedId);
+  if (!located && !await pathExists(historyPath)) {
+    throw new PmCliError(`Item ${id} not found`, EXIT_CODE.NOT_FOUND);
+  }
+  if (located) {
+    await enforceHistoryStreamPolicyForItem({
+      pmRoot,
+      settings,
+      itemId: located.id,
+      commandLabel: "history"
+    });
+  }
+  const fullHistory = await readHistoryEntries(historyPath, resolvedId);
+  const history = limitEntries(fullHistory, limit);
+  const compact = options.compact === true;
+  const compactHistory = compact ? buildDiffEntries(history, Math.max(0, fullHistory.length - history.length)) : void 0;
+  const result = {
+    id: resolvedId,
+    history: compact ? [] : history,
+    compact_history: compactHistory,
+    compact,
+    count: history.length,
+    limit: limit ?? null
+  };
+  if (options.diff || options.field !== void 0) {
+    result.diff = computeHistoryDiff(fullHistory, {
+      windowStartIndex: Math.max(0, fullHistory.length - history.length),
+      field: options.field
+    });
+  }
+  if (options.verify) {
+    const verification = verifyHistoryChain(fullHistory);
+    const latestAfterHash = fullHistory.length > 0 ? fullHistory[fullHistory.length - 1].after_hash : hashEmptyDocument();
+    let currentItemHash;
+    let currentMatchesLatest;
+    const errors = [...verification.errors];
+    if (located) {
+      const loaded = await readLocatedItem(located, { schema: settings.schema });
+      currentItemHash = hashDocument(loaded.document);
+      currentMatchesLatest = currentItemHash === latestAfterHash;
+      if (!currentMatchesLatest) {
+        errors.push("verify_failed:current_item_hash_mismatch");
+      }
+    }
+    result.verification = {
+      ok: errors.length === 0,
+      entries: fullHistory.length,
+      errors,
+      /* c8 ignore next -- empty-history verification payloads are covered by lower-level stream tests. */
+      latest_after_hash: fullHistory.length > 0 ? fullHistory[fullHistory.length - 1].after_hash : void 0,
+      current_item_hash: currentItemHash,
+      current_matches_latest: currentMatchesLatest
+    };
+  }
+  return result;
+}
+
+export {
+  readHistoryEntries,
+  runHistory
+};
+//# sourceMappingURL=chunk-L5PSPMZ4.js.map