@unbrained/pm-cli 2026.7.5 → 2026.7.6

package/dist/cli-bundle/chunks/chunk-7D7OOEYG.js

@@ -0,0 +1,278 @@
+import {
+  scanHistoryDrift
+} from "./chunk-QLMX7SRD.js";
+import {
+  executeHistoryRewrite,
+  resolveHistorySubject,
+  writeHistoryRawWithRollback
+} from "./chunk-MA4SM3QZ.js";
+import {
+  readHistoryEntries
+} from "./chunk-L5PSPMZ4.js";
+import {
+  historyEntriesToRaw,
+  reanchorHistoryEntries,
+  replayHash,
+  toReplayDocument,
+  verifyHistoryChain
+} from "./chunk-XUC7PI2H.js";
+import {
+  listAllFrontMatterWithBody,
+  readLocatedItem
+} from "./chunk-5VAA4YHR.js";
+import {
+  nowIso
+} from "./chunk-FLZSGSQR.js";
+import {
+  PmCliError,
+  getActiveExtensionRegistrations,
+  readSettings,
+  runActiveOnWriteHooks
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE,
+  getSettingsPath,
+  pathExists,
+  readFileIfExists,
+  resolveItemTypeRegistry,
+  resolvePmRoot
+} from "./chunk-LK6XLOGP.js";
+
+// dist/cli/commands/history-repair.js
+import jsonPatch from "fast-json-patch";
+!(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] = "2bac2975-f521-5b57-86aa-59983a7953c7");
+  } catch (e2) {
+  }
+})();
+function toAuthor(candidate, defaultAuthor) {
+  const resolved = candidate ?? process.env.PM_AUTHOR ?? defaultAuthor;
+  const trimmed = resolved.trim();
+  return trimmed.length > 0 ? trimmed : "unknown";
+}
+async function loadHistoryRepairItemReplay(subject, settings, historyEntries) {
+  const currentItemPath = subject.located?.itemPath ?? null;
+  const loadedItem = subject.located ? await readLocatedItem(subject.located, { schema: settings.schema }) : null;
+  if (!loadedItem) {
+    return {
+      currentItemReplay: null,
+      currentItemPath,
+      matchedChainBefore: null,
+      currentItemRawBeforeLock: null,
+      loadedItem: null
+    };
+  }
+  const currentItemReplay = toReplayDocument(loadedItem.document);
+  const lastOriginalAfterHash = historyEntries[historyEntries.length - 1]?.after_hash;
+  return {
+    currentItemReplay,
+    currentItemPath,
+    matchedChainBefore: replayHash(currentItemReplay) === lastOriginalAfterHash,
+    currentItemRawBeforeLock: loadedItem.raw,
+    loadedItem
+  };
+}
+function buildHistoryRepairMessage(params) {
+  if (typeof params.message === "string" && params.message.trim().length > 0) {
+    return params.message;
+  }
+  return `history-repair re-anchored ${params.entriesRehashed} entr${params.entriesRehashed === 1 ? "y" : "ies"}${params.entriesPatchRepaired > 0 ? `, repaired ${params.entriesPatchRepaired} patch(es)` : ""}${params.reconcileNeeded ? ", reconciled chain with on-disk item" : ""}.`;
+}
+function buildHistoryRepairEntries(params) {
+  const rewrittenEntries = [...params.reanchorEntries];
+  if (!params.changed) {
+    return { rewrittenEntries, auditEntryAdded: false };
+  }
+  const afterReplay = params.reconcileNeeded && params.currentItemReplay ? params.currentItemReplay : params.finalReplay;
+  rewrittenEntries.push({
+    ts: nowIso(),
+    author: params.author,
+    op: "history_repair",
+    patch: params.reconcileNeeded && params.currentItemReplay ? jsonPatch.compare(params.finalReplay, params.currentItemReplay) : [],
+    before_hash: replayHash(params.finalReplay),
+    after_hash: replayHash(afterReplay),
+    message: params.message
+  });
+  return { rewrittenEntries, auditEntryAdded: true };
+}
+function collectHistoryRepairWarnings(changed, skippedOps) {
+  const warnings = [];
+  if (!changed) {
+    warnings.push("history_repair_no_changes");
+  }
+  if (skippedOps > 0) {
+    warnings.push(`history_repair_skipped_unresolvable_ops:${skippedOps}`);
+  }
+  return warnings;
+}
+async function applyHistoryRepairRewrite(params) {
+  return executeHistoryRewrite({
+    pmRoot: params.pmRoot,
+    subject: params.subject,
+    settings: params.settings,
+    typeRegistry: params.typeRegistry,
+    historyRawBeforeLock: params.historyRawBeforeLock,
+    currentItemRawBeforeLock: params.currentItemRawBeforeLock,
+    operation: "history-repair",
+    author: params.author,
+    force: params.force,
+    itemDocument: params.loadedItem?.document ?? null,
+    applyRewrite: async ({ historyRawUnderLock }) => writeHistoryRawWithRollback({
+      historyPath: params.historyPath,
+      nextHistoryRaw: historyEntriesToRaw(params.rewrittenEntries),
+      historyRawUnderLock
+    }),
+    applyPostRewrite: async () => runActiveOnWriteHooks({
+      path: params.historyPath,
+      scope: "project",
+      op: "history_repair:history"
+    })
+  });
+}
+async function runHistoryRepair(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 settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const subject = await resolveHistorySubject(pmRoot, id, settings, typeRegistry.type_to_folder);
+  if (!await pathExists(subject.historyPath)) {
+    throw new PmCliError(`No history stream exists for ${subject.id}.`, EXIT_CODE.NOT_FOUND);
+  }
+  const historyRawBeforeLock = await readFileIfExists(subject.historyPath);
+  const historyEntries = await readHistoryEntries(subject.historyPath, subject.id);
+  if (historyEntries.length === 0) {
+    throw new PmCliError(`No history entries exist for ${subject.id}; nothing to repair.`, EXIT_CODE.USAGE);
+  }
+  const chainBefore = verifyHistoryChain(historyEntries);
+  const reanchor = reanchorHistoryEntries(historyEntries);
+  const itemReplayContext = await loadHistoryRepairItemReplay(subject, settings, historyEntries);
+  const finalReplay = reanchor.finalDocument;
+  const reconcileNeeded = itemReplayContext.currentItemReplay !== null && replayHash(finalReplay) !== replayHash(itemReplayContext.currentItemReplay);
+  const changed = reanchor.entriesRehashed > 0 || reanchor.entriesPatchRepaired > 0 || reconcileNeeded;
+  const author = toAuthor(options.author, settings.author_default);
+  const dryRun = Boolean(options.dryRun);
+  const repairMessage = buildHistoryRepairMessage({
+    message: options.message,
+    entriesRehashed: reanchor.entriesRehashed,
+    entriesPatchRepaired: reanchor.entriesPatchRepaired,
+    reconcileNeeded
+  });
+  const { rewrittenEntries, auditEntryAdded } = buildHistoryRepairEntries({
+    reanchorEntries: reanchor.entries,
+    changed,
+    reconcileNeeded,
+    currentItemReplay: itemReplayContext.currentItemReplay,
+    finalReplay,
+    author,
+    message: repairMessage
+  });
+  const historyVerify = verifyHistoryChain(rewrittenEntries);
+  if (!historyVerify.ok) {
+    throw new PmCliError(`history-repair produced an invalid rewritten chain (${historyVerify.errors.join(", ")}).`, EXIT_CODE.GENERIC_FAILURE);
+  }
+  const warnings = collectHistoryRepairWarnings(changed, reanchor.skippedOps);
+  if (changed && !dryRun) {
+    warnings.push(...await applyHistoryRepairRewrite({
+      pmRoot,
+      subject,
+      settings,
+      typeRegistry,
+      historyRawBeforeLock,
+      currentItemRawBeforeLock: itemReplayContext.currentItemRawBeforeLock,
+      author,
+      force: options.force,
+      loadedItem: itemReplayContext.loadedItem,
+      historyPath: subject.historyPath,
+      rewrittenEntries
+    }));
+  }
+  return {
+    id: subject.id,
+    dry_run: dryRun,
+    changed,
+    history: {
+      path: subject.historyPath,
+      entries_scanned: historyEntries.length,
+      chain_drift_before: !chainBefore.ok,
+      entries_rehashed: reanchor.entriesRehashed,
+      entries_patch_repaired: reanchor.entriesPatchRepaired,
+      converted_replace_to_add: reanchor.convertedReplaceToAdd,
+      skipped_ops: reanchor.skippedOps,
+      reconciled_with_item: reconcileNeeded,
+      audit_entry_added: auditEntryAdded,
+      verify_ok: historyVerify.ok,
+      verify_errors: historyVerify.errors
+    },
+    item: {
+      exists: itemReplayContext.currentItemPath !== null,
+      path: itemReplayContext.currentItemPath,
+      matched_chain_before: itemReplayContext.matchedChainBefore
+    },
+    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),
+    generated_at: nowIso()
+  };
+}
+function assertHistoryRepairTarget(id, all) {
+  if (all && id !== void 0) {
+    throw new PmCliError("history-repair: <id> and --all are mutually exclusive; pass an item id to repair one stream or --all to repair every drifted stream.", EXIT_CODE.USAGE);
+  }
+  if (!all && id === void 0) {
+    throw new PmCliError("history-repair: provide an item <id> or pass --all to repair every drifted stream.", EXIT_CODE.USAGE);
+  }
+}
+async function runHistoryRepairAll(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 settings = await readSettings(pmRoot);
+  const typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());
+  const itemReadWarnings = [];
+  const items = await listAllFrontMatterWithBody(pmRoot, settings.item_format, typeRegistry.type_to_folder, itemReadWarnings, settings.schema);
+  const drift = await scanHistoryDrift(pmRoot, items);
+  const streams = [];
+  const totals = { repaired: 0, skipped_clean: 0, failed: 0 };
+  for (const driftedId of drift.driftedItems) {
+    try {
+      const result = await runHistoryRepair(driftedId, options, global2);
+      const outcome = result.changed ? "repaired" : "skipped_clean";
+      totals[outcome] += 1;
+      streams.push({
+        id: driftedId,
+        outcome,
+        entries_rehashed: result.history.entries_rehashed,
+        entries_patch_repaired: result.history.entries_patch_repaired,
+        reconciled_with_item: result.history.reconciled_with_item
+      });
+    } catch (error) {
+      totals.failed += 1;
+      streams.push({
+        id: driftedId,
+        outcome: "failed",
+        /* c8 ignore next -- non-Error throws are normalized in defensive fallback. */
+        error: error instanceof Error ? error.message : String(error)
+      });
+    }
+  }
+  return {
+    all: true,
+    dry_run: Boolean(options.dryRun),
+    scanned_streams: items.length,
+    drifted_streams: drift.driftedItems.length,
+    streams,
+    totals,
+    warnings: [...new Set(itemReadWarnings)].sort((left, right) => left.localeCompare(right)),
+    generated_at: nowIso()
+  };
+}
+
+export {
+  runHistoryRepair,
+  assertHistoryRepairTarget,
+  runHistoryRepairAll
+};
+//# sourceMappingURL=chunk-7D7OOEYG.js.map

package/dist/cli-bundle/chunks/chunk-7D7OOEYG.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../cli/commands/history-repair.ts"],
+  "sourcesContent": ["/**\n * @module cli/commands/history-repair\n *\n * Implements the pm history repair command surface and its agent-facing runtime behavior.\n */\nimport jsonPatch from \"fast-json-patch\";\nimport { pathExists, readFileIfExists } from \"../../core/fs/fs-utils.js\";\nimport { executeHistoryRewrite, writeHistoryRawWithRollback } from \"../../core/history/history-rewrite.js\";\nimport {\n  historyEntriesToRaw,\n  reanchorHistoryEntries,\n  replayHash,\n  toReplayDocument,\n  verifyHistoryChain,\n  type ReplayDocument,\n} from \"../../core/history/replay.js\";\nimport { scanHistoryDrift } from \"../../core/history/drift-scan.js\";\nimport { resolveItemTypeRegistry } from \"../../core/item/type-registry.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 { nowIso } from \"../../core/shared/time.js\";\nimport { getActiveExtensionRegistrations, runActiveOnWriteHooks } from \"../../core/extensions/index.js\";\nimport { listAllFrontMatterWithBody, readLocatedItem } from \"../../core/store/item-store.js\";\nimport { getSettingsPath, resolvePmRoot } from \"../../core/store/paths.js\";\nimport { readSettings } from \"../../core/store/settings.js\";\nimport type { HistoryEntry, HistoryPatchOp, ItemMetadata } from \"../../types/index.js\";\nimport { readHistoryEntries } from \"./history.js\";\nimport { resolveHistorySubject } from \"./history-redact.js\";\n\n/**\n * Documents the history repair command options payload exchanged by command, SDK, and package integrations.\n */\nexport interface HistoryRepairCommandOptions {\n  dryRun?: boolean;\n  author?: string;\n  message?: string;\n  force?: boolean;\n}\n\n/**\n * Documents the history repair result payload exchanged by command, SDK, and package integrations.\n */\nexport interface HistoryRepairResult {\n  id: string;\n  dry_run: boolean;\n  changed: boolean;\n  history: {\n    path: string;\n    entries_scanned: number;\n    chain_drift_before: boolean;\n    entries_rehashed: number;\n    entries_patch_repaired: number;\n    converted_replace_to_add: number;\n    skipped_ops: number;\n    reconciled_with_item: boolean;\n    audit_entry_added: boolean;\n    verify_ok: boolean;\n    verify_errors: string[];\n  };\n  item: {\n    exists: boolean;\n    path: string | null;\n    matched_chain_before: boolean | null;\n  };\n  warnings: string[];\n  generated_at: string;\n}\n\ninterface HistoryRepairItemReplayContext {\n  currentItemReplay: ReplayDocument | null;\n  currentItemPath: string | null;\n  matchedChainBefore: boolean | null;\n  currentItemRawBeforeLock: string | null;\n  loadedItem: Awaited<ReturnType<typeof readLocatedItem>> | null;\n}\n\nfunction toAuthor(candidate: string | undefined, defaultAuthor: string): string {\n  /* c8 ignore next -- PM_AUTHOR fallback branch is environment-dependent in CI. */\n  const resolved = candidate ?? process.env.PM_AUTHOR ?? defaultAuthor;\n  const trimmed = resolved.trim();\n  return trimmed.length > 0 ? trimmed : \"unknown\";\n}\n\nasync function loadHistoryRepairItemReplay(\n  subject: Awaited<ReturnType<typeof resolveHistorySubject>>,\n  settings: Awaited<ReturnType<typeof readSettings>>,\n  historyEntries: HistoryEntry[],\n): Promise<HistoryRepairItemReplayContext> {\n  const currentItemPath = subject.located?.itemPath ?? null;\n  const loadedItem = subject.located ? await readLocatedItem(subject.located, { schema: settings.schema }) : null;\n  if (!loadedItem) {\n    return {\n      currentItemReplay: null,\n      currentItemPath,\n      matchedChainBefore: null,\n      currentItemRawBeforeLock: null,\n      loadedItem: null,\n    };\n  }\n  const currentItemReplay = toReplayDocument(loadedItem.document);\n  const lastOriginalAfterHash = historyEntries[historyEntries.length - 1]?.after_hash;\n  return {\n    currentItemReplay,\n    currentItemPath,\n    matchedChainBefore: replayHash(currentItemReplay) === lastOriginalAfterHash,\n    currentItemRawBeforeLock: loadedItem.raw,\n    loadedItem,\n  };\n}\n\nfunction buildHistoryRepairMessage(params: {\n  message: string | undefined;\n  entriesRehashed: number;\n  entriesPatchRepaired: number;\n  reconcileNeeded: boolean;\n}): string {\n  if (typeof params.message === \"string\" && params.message.trim().length > 0) {\n    return params.message;\n  }\n  /* v8 ignore start -- message suffix/plural variants are deterministic formatting fallbacks around the covered repair outcomes */\n  return `history-repair re-anchored ${params.entriesRehashed} entr${\n    params.entriesRehashed === 1 ? \"y\" : \"ies\"\n  }${params.entriesPatchRepaired > 0 ? `, repaired ${params.entriesPatchRepaired} patch(es)` : \"\"}${\n    params.reconcileNeeded ? \", reconciled chain with on-disk item\" : \"\"\n  }.`;\n  /* v8 ignore stop */\n}\n\nfunction buildHistoryRepairEntries(params: {\n  reanchorEntries: HistoryEntry[];\n  changed: boolean;\n  reconcileNeeded: boolean;\n  currentItemReplay: ReplayDocument | null;\n  finalReplay: ReplayDocument;\n  author: string;\n  message: string;\n}): { rewrittenEntries: HistoryEntry[]; auditEntryAdded: boolean } {\n  const rewrittenEntries: HistoryEntry[] = [...params.reanchorEntries];\n  if (!params.changed) {\n    return { rewrittenEntries, auditEntryAdded: false };\n  }\n  const afterReplay = params.reconcileNeeded && params.currentItemReplay ? params.currentItemReplay : params.finalReplay;\n  rewrittenEntries.push({\n    ts: nowIso(),\n    author: params.author,\n    op: \"history_repair\",\n    patch: params.reconcileNeeded && params.currentItemReplay\n      ? (jsonPatch.compare(params.finalReplay, params.currentItemReplay) as HistoryPatchOp[])\n      : [],\n    before_hash: replayHash(params.finalReplay),\n    after_hash: replayHash(afterReplay),\n    message: params.message,\n  });\n  return { rewrittenEntries, auditEntryAdded: true };\n}\n\nfunction collectHistoryRepairWarnings(changed: boolean, skippedOps: number): string[] {\n  const warnings: string[] = [];\n  if (!changed) {\n    warnings.push(\"history_repair_no_changes\");\n  }\n  if (skippedOps > 0) {\n    warnings.push(`history_repair_skipped_unresolvable_ops:${skippedOps}`);\n  }\n  return warnings;\n}\n\nasync function applyHistoryRepairRewrite(params: {\n  pmRoot: string;\n  subject: Awaited<ReturnType<typeof resolveHistorySubject>>;\n  settings: Awaited<ReturnType<typeof readSettings>>;\n  typeRegistry: ReturnType<typeof resolveItemTypeRegistry>;\n  historyRawBeforeLock: string | null;\n  currentItemRawBeforeLock: string | null;\n  author: string;\n  force: boolean | undefined;\n  loadedItem: Awaited<ReturnType<typeof readLocatedItem>> | null;\n  historyPath: string;\n  rewrittenEntries: HistoryEntry[];\n}): Promise<string[]> {\n  return executeHistoryRewrite({\n    pmRoot: params.pmRoot,\n    subject: params.subject,\n    settings: params.settings,\n    typeRegistry: params.typeRegistry,\n    historyRawBeforeLock: params.historyRawBeforeLock,\n    currentItemRawBeforeLock: params.currentItemRawBeforeLock,\n    operation: \"history-repair\",\n    author: params.author,\n    force: params.force,\n    itemDocument: params.loadedItem?.document ?? null,\n    applyRewrite: async ({ historyRawUnderLock }) =>\n      writeHistoryRawWithRollback({\n        historyPath: params.historyPath,\n        nextHistoryRaw: historyEntriesToRaw(params.rewrittenEntries),\n        historyRawUnderLock,\n      }),\n    applyPostRewrite: async () =>\n      runActiveOnWriteHooks({\n        path: params.historyPath,\n        scope: \"project\",\n        op: \"history_repair:history\",\n      }),\n  });\n}\n\n/**\n * Implements run history repair for the public runtime surface of this module.\n */\nexport async function runHistoryRepair(\n  id: string,\n  options: HistoryRepairCommandOptions,\n  global: GlobalOptions,\n): Promise<HistoryRepairResult> {\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 typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());\n  const subject = await resolveHistorySubject(pmRoot, id, settings, typeRegistry.type_to_folder);\n\n  if (!(await pathExists(subject.historyPath))) {\n    throw new PmCliError(`No history stream exists for ${subject.id}.`, EXIT_CODE.NOT_FOUND);\n  }\n  const historyRawBeforeLock = await readFileIfExists(subject.historyPath);\n  const historyEntries = await readHistoryEntries(subject.historyPath, subject.id);\n  if (historyEntries.length === 0) {\n    throw new PmCliError(`No history entries exist for ${subject.id}; nothing to repair.`, EXIT_CODE.USAGE);\n  }\n\n  const chainBefore = verifyHistoryChain(historyEntries);\n  const reanchor = reanchorHistoryEntries(historyEntries);\n\n  const itemReplayContext = await loadHistoryRepairItemReplay(subject, settings, historyEntries);\n\n  const finalReplay = reanchor.finalDocument;\n  const reconcileNeeded =\n    itemReplayContext.currentItemReplay !== null && replayHash(finalReplay) !== replayHash(itemReplayContext.currentItemReplay);\n\n  const changed = reanchor.entriesRehashed > 0 || reanchor.entriesPatchRepaired > 0 || reconcileNeeded;\n  const author = toAuthor(options.author, settings.author_default);\n  const dryRun = Boolean(options.dryRun);\n\n  const repairMessage = buildHistoryRepairMessage({\n    message: options.message,\n    entriesRehashed: reanchor.entriesRehashed,\n    entriesPatchRepaired: reanchor.entriesPatchRepaired,\n    reconcileNeeded,\n  });\n  const { rewrittenEntries, auditEntryAdded } = buildHistoryRepairEntries({\n    reanchorEntries: reanchor.entries,\n    changed,\n    reconcileNeeded,\n    currentItemReplay: itemReplayContext.currentItemReplay,\n    finalReplay,\n    author,\n    message: repairMessage,\n  });\n\n  const historyVerify = verifyHistoryChain(rewrittenEntries);\n  if (!historyVerify.ok) {\n    throw new PmCliError(\n      `history-repair produced an invalid rewritten chain (${historyVerify.errors.join(\", \")}).`,\n      EXIT_CODE.GENERIC_FAILURE,\n    );\n  }\n\n  const warnings = collectHistoryRepairWarnings(changed, reanchor.skippedOps);\n\n  if (changed && !dryRun) {\n    warnings.push(\n      ...(await applyHistoryRepairRewrite({\n        pmRoot,\n        subject,\n        settings,\n        typeRegistry,\n        historyRawBeforeLock,\n        currentItemRawBeforeLock: itemReplayContext.currentItemRawBeforeLock,\n        author,\n        force: options.force,\n        loadedItem: itemReplayContext.loadedItem,\n        historyPath: subject.historyPath,\n        rewrittenEntries,\n      })),\n    );\n  }\n\n  return {\n    id: subject.id,\n    dry_run: dryRun,\n    changed,\n    history: {\n      path: subject.historyPath,\n      entries_scanned: historyEntries.length,\n      chain_drift_before: !chainBefore.ok,\n      entries_rehashed: reanchor.entriesRehashed,\n      entries_patch_repaired: reanchor.entriesPatchRepaired,\n      converted_replace_to_add: reanchor.convertedReplaceToAdd,\n      skipped_ops: reanchor.skippedOps,\n      reconciled_with_item: reconcileNeeded,\n      audit_entry_added: auditEntryAdded,\n      verify_ok: historyVerify.ok,\n      verify_errors: historyVerify.errors,\n    },\n    item: {\n      exists: itemReplayContext.currentItemPath !== null,\n      path: itemReplayContext.currentItemPath,\n      matched_chain_before: itemReplayContext.matchedChainBefore,\n    },\n    warnings: [...new Set(warnings)].sort((left, right) => left.localeCompare(right)),\n    generated_at: nowIso(),\n  };\n}\n\n/**\n * Documents the history repair all stream result payload exchanged by command, SDK, and package integrations.\n */\nexport interface HistoryRepairAllStreamResult {\n  id: string;\n  outcome: \"repaired\" | \"skipped_clean\" | \"failed\";\n  entries_rehashed?: number;\n  entries_patch_repaired?: number;\n  reconciled_with_item?: boolean;\n  error?: string;\n}\n\n/**\n * Documents the history repair all result payload exchanged by command, SDK, and package integrations.\n */\nexport interface HistoryRepairAllResult {\n  all: true;\n  dry_run: boolean;\n  scanned_streams: number;\n  drifted_streams: number;\n  /** One compact row per drifted stream (clean streams are summarized by the counts only). */\n  streams: HistoryRepairAllStreamResult[];\n  totals: { repaired: number; skipped_clean: number; failed: number };\n  warnings: string[];\n  generated_at: string;\n}\n\n/**\n * Enforce the `pm history-repair` target contract shared by the CLI and MCP\n * surfaces: exactly one of an item `<id>` or `--all` must be provided.\n */\nexport function assertHistoryRepairTarget(id: string | undefined, all: boolean): void {\n  if (all && id !== undefined) {\n    throw new PmCliError(\n      \"history-repair: <id> and --all are mutually exclusive; pass an item id to repair one stream or --all to repair every drifted stream.\",\n      EXIT_CODE.USAGE,\n    );\n  }\n  if (!all && id === undefined) {\n    throw new PmCliError(\n      \"history-repair: provide an item <id> or pass --all to repair every drifted stream.\",\n      EXIT_CODE.USAGE,\n    );\n  }\n}\n\n/**\n * Bulk drift repair: scan every item's history stream with the same drift scan\n * `pm health` uses, then run the audited single-stream repair (ownership check,\n * lock, no-drift verification, audit marker) for each drifted stream. One\n * failing stream never aborts the rest; failures are collected per row and the\n * caller decides the exit code from `totals.failed`.\n */\nexport async function runHistoryRepairAll(\n  options: HistoryRepairCommandOptions,\n  global: GlobalOptions,\n): Promise<HistoryRepairAllResult> {\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 typeRegistry = resolveItemTypeRegistry(settings, getActiveExtensionRegistrations());\n  const itemReadWarnings: string[] = [];\n  const items = await listAllFrontMatterWithBody(\n    pmRoot,\n    settings.item_format,\n    typeRegistry.type_to_folder,\n    itemReadWarnings,\n    settings.schema,\n  );\n  const drift = await scanHistoryDrift(pmRoot, items as Array<ItemMetadata & { body: string }>);\n\n  const streams: HistoryRepairAllStreamResult[] = [];\n  const totals = { repaired: 0, skipped_clean: 0, failed: 0 };\n  for (const driftedId of drift.driftedItems) {\n    try {\n      const result = await runHistoryRepair(driftedId, options, global);\n      /* c8 ignore next -- mixed repaired/clean outcomes depend on live drift composition. */\n      const outcome = result.changed ? \"repaired\" : \"skipped_clean\";\n      totals[outcome] += 1;\n      streams.push({\n        id: driftedId,\n        outcome,\n        entries_rehashed: result.history.entries_rehashed,\n        entries_patch_repaired: result.history.entries_patch_repaired,\n        reconciled_with_item: result.history.reconciled_with_item,\n      });\n    } catch (error) {\n      totals.failed += 1;\n      streams.push({\n        id: driftedId,\n        outcome: \"failed\",\n        /* c8 ignore next -- non-Error throws are normalized in defensive fallback. */\n        error: error instanceof Error ? error.message : String(error),\n      });\n    }\n  }\n\n  return {\n    all: true,\n    dry_run: Boolean(options.dryRun),\n    scanned_streams: items.length,\n    drifted_streams: drift.driftedItems.length,\n    streams,\n    totals,\n    warnings: [...new Set(itemReadWarnings)].sort((left, right) => left.localeCompare(right)),\n    generated_at: nowIso(),\n  };\n}\n"],
+  "mappings": "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",
+  "names": ["global"]
+}

package/dist/cli-bundle/chunks/chunk-7DT4WSH2.js

@@ -0,0 +1,60 @@
+import {
+  PmCliError
+} from "./chunk-SHQY2IDC.js";
+import {
+  EXIT_CODE,
+  resolveTypeName
+} from "./chunk-LK6XLOGP.js";
+
+// dist/cli/shared-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] = "d67fbb5c-d937-50f6-a8c1-23a8f951dd0a");
+  } catch (e2) {
+  }
+})();
+function parseLimit(raw, label = "--limit") {
+  if (raw === void 0)
+    return void 0;
+  const parsed = Number(raw);
+  if (!Number.isFinite(parsed) || parsed < 0) {
+    throw new PmCliError(`${label} must be a non-negative number`, EXIT_CODE.USAGE);
+  }
+  return Math.floor(parsed);
+}
+function parseIntegerLimit(raw, label = "--limit") {
+  if (raw === void 0)
+    return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0) {
+    throw new PmCliError(`${label} must be a non-negative integer`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parsePriority(raw, label = "--priority") {
+  if (raw === void 0)
+    return void 0;
+  const parsed = Number(raw);
+  if (!Number.isInteger(parsed) || parsed < 0 || parsed > 4) {
+    throw new PmCliError(`${label} filter must be 0..4`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+function parseType(raw, typeRegistry, label = "--type") {
+  if (raw === void 0)
+    return void 0;
+  const parsed = resolveTypeName(raw, typeRegistry);
+  if (!parsed) {
+    throw new PmCliError(`${label} filter must be one of ${typeRegistry.types.join("|")}`, EXIT_CODE.USAGE);
+  }
+  return parsed;
+}
+
+export {
+  parseLimit,
+  parseIntegerLimit,
+  parsePriority,
+  parseType
+};
+//# sourceMappingURL=chunk-7DT4WSH2.js.map

package/dist/cli-bundle/chunks/chunk-7WBAJSS6.js

@@ -0,0 +1,102 @@
+
+!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]="377e5452-9452-5178-b4ae-182fb89455c0")}catch(e){}}();
+import {
+  normalizeItemId
+} from "./chunk-G24G7ZAV.js";
+import {
+  PmCliError
+} from "./chunk-E3SZTQ4K.js";
+import {
+  EXIT_CODE
+} from "./chunk-57NWPFF2.js";
+
+// dist/core/item/parent-reference-policy.js
+var PLACEHOLDER_REFERENCE_TOKENS = /* @__PURE__ */ new Set(["none", "null", "undefined"]);
+function normalizeParentReferencePolicy(value) {
+  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
+  if (normalized === "warn" || normalized === "strict_error") {
+    return normalized;
+  }
+  if (normalized === "strict") {
+    return "strict_error";
+  }
+  throw new PmCliError("Config set parent-reference-policy requires --policy with one of: warn, strict_error (alias: strict)", EXIT_CODE.USAGE);
+}
+function normalizeParentReferenceValue(rawValue) {
+  if (typeof rawValue !== "string") {
+    throw new PmCliError("--parent must be a string. Use --unset parent to clear this field.", EXIT_CODE.USAGE);
+  }
+  const value = rawValue.trim();
+  if (value.length === 0) {
+    throw new PmCliError("--parent must not be empty. Use --parent none to unset.", EXIT_CODE.USAGE);
+  }
+  if (isPlaceholderReferenceToken(value)) {
+    throw new PmCliError(`--parent must not use placeholder token "${value}". Use --unset parent to clear this field.`, EXIT_CODE.USAGE);
+  }
+  return value;
+}
+function isPlaceholderReferenceToken(value) {
+  return PLACEHOLDER_REFERENCE_TOKENS.has(value.trim().toLowerCase());
+}
+function validateMissingParentReference(parentId, policy) {
+  if (policy === "strict_error") {
+    throw new PmCliError(`Parent item "${parentId}" was not found. Create it first or use --parent none.`, EXIT_CODE.USAGE);
+  }
+  return {
+    warnings: [`validation_warning:parent_reference_missing:${parentId}`]
+  };
+}
+function assertParentReferenceIsNotSelf(itemId, parentId, prefix) {
+  const normalizedItemId = normalizeItemId(itemId, prefix);
+  const normalizedParentId = normalizeItemId(parentId, prefix);
+  if (normalizedItemId !== normalizedParentId) {
+    return;
+  }
+  const normalizationDetail = parentId !== normalizedParentId || itemId !== normalizedItemId ? ` (normalized from parent "${parentId}" and item "${itemId}")` : "";
+  throw new PmCliError(`Parent item "${normalizedParentId}" cannot be the same as item "${normalizedItemId}"${normalizationDetail}. Use --unset parent to clear this field.`, EXIT_CODE.USAGE);
+}
+
+// dist/core/item/sprint-release-format.js
+var SPRINT_RELEASE_VALUE_PATTERN = /^[A-Za-z0-9][A-Za-z0-9._/-]*$/;
+var SPRINT_RELEASE_MAX_LENGTH = 64;
+function normalizeSprintReleaseFormatPolicy(value) {
+  const normalized = value?.trim().toLowerCase().replaceAll("-", "_");
+  if (normalized === "warn" || normalized === "strict_error") {
+    return normalized;
+  }
+  if (normalized === "strict") {
+    return "strict_error";
+  }
+  throw new PmCliError("Config set sprint-release-format-policy requires --policy with one of: warn, strict_error (alias: strict)", EXIT_CODE.USAGE);
+}
+function validateSprintOrReleaseValue(field, rawValue, policy) {
+  const value = rawValue.trim();
+  if (value.length === 0) {
+    throw new PmCliError(`--${field} must not be empty. Use --${field} none to unset.`, EXIT_CODE.USAGE);
+  }
+  const isValid = value.length <= SPRINT_RELEASE_MAX_LENGTH && SPRINT_RELEASE_VALUE_PATTERN.test(value);
+  if (isValid) {
+    return { value, warnings: [] };
+  }
+  const guidance = "Expected 1-64 characters matching [A-Za-z0-9][A-Za-z0-9._/-]* (no spaces).";
+  if (policy === "strict_error") {
+    throw new PmCliError(`Invalid --${field} value "${value}". ${guidance}`, EXIT_CODE.USAGE);
+  }
+  return {
+    value,
+    warnings: [`validation_warning:${field}_format:${value}`]
+  };
+}
+
+export {
+  normalizeParentReferencePolicy,
+  normalizeParentReferenceValue,
+  isPlaceholderReferenceToken,
+  validateMissingParentReference,
+  assertParentReferenceIsNotSelf,
+  normalizeSprintReleaseFormatPolicy,
+  validateSprintOrReleaseValue
+};
+//# sourceMappingURL=chunk-7WBAJSS6.js.map
+
+//# debugId=377e5452-9452-5178-b4ae-182fb89455c0

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

@@ -0,0 +1,150 @@
+
+!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]="b7da1375-1527-5871-9f84-948595aee48f")}catch(e){}}();
+import {
+  collectUsedExtensionCapabilities,
+  normalizeExtensionName
+} from "./chunk-57NWPFF2.js";
+
+// dist/core/extensions/activation-summary.js
+var HOOK_REGISTRY_FIELD_TO_KIND = [
+  ["beforeCommand", "before_command"],
+  ["afterCommand", "after_command"],
+  ["onWrite", "on_write"],
+  ["onRead", "on_read"],
+  ["onIndex", "on_index"]
+];
+function describeExtensionActivation(activation, options = {}) {
+  const filters = /* @__PURE__ */ new Set();
+  if (options.extensionName !== void 0) {
+    filters.add(normalizeExtensionName(options.extensionName));
+  }
+  for (const name of options.extensionNames ?? []) {
+    filters.add(normalizeExtensionName(name));
+  }
+  const matches = (name) => filters.size === 0 || filters.has(normalizeExtensionName(name));
+  const collect = (entries, identify) => sortUnique(entries.filter((entry) => matches(entry.name)).map(identify));
+  const collectFlat = (entries, expand) => sortUnique(entries.filter((entry) => matches(entry.name)).flatMap(expand));
+  const { registrations, commands, parsers, preflight, services, renderers, hooks } = activation;
+  return {
+    capabilities: collectUsedExtensionCapabilities(activation, options),
+    commands: collect(registrations.commands, (entry) => entry.command),
+    command_overrides: collect(commands.overrides, (entry) => entry.command),
+    command_handlers: collect(commands.handlers, (entry) => entry.command),
+    hooks: HOOK_REGISTRY_FIELD_TO_KIND.filter(([field]) => hooks[field].some((entry) => matches(entry.name))).map(([, kind]) => kind),
+    flag_commands: collect(registrations.flags, (entry) => entry.target_command),
+    item_types: collectFlat(registrations.item_types, (entry) => entry.types.map((type) => type.name)),
+    item_fields: collectFlat(registrations.item_fields, (entry) => entry.fields.map((field) => field.name)),
+    migrations: collectFlat(registrations.migrations, (entry) => typeof entry.definition.id === "string" ? [entry.definition.id] : []),
+    profiles: collect(registrations.profiles, (entry) => entry.profile.name),
+    importers: collect(registrations.importers, (entry) => entry.importer),
+    exporters: collect(registrations.exporters, (entry) => entry.exporter),
+    search_providers: collect(registrations.search_providers, (entry) => entry.definition.name),
+    vector_store_adapters: collect(registrations.vector_store_adapters, (entry) => entry.definition.name),
+    parser_overrides: collect(parsers.overrides, (entry) => entry.command),
+    service_overrides: collect(services.overrides, (entry) => entry.service),
+    renderer_overrides: collect(renderers.overrides, (entry) => entry.format),
+    preflight_overrides: preflight.overrides.filter((entry) => matches(entry.name)).length
+  };
+}
+function sortUnique(values) {
+  return [...new Set(values)].sort((left, right) => left.localeCompare(right));
+}
+
+// dist/core/extensions/activation-summary-markdown.js
+var MIN_HEADING_LEVEL = 1;
+var MAX_HEADING_LEVEL = 6;
+var SURFACE_SECTIONS = [
+  ["commands", "Commands"],
+  ["command_overrides", "Command overrides"],
+  ["flag_commands", "Flag commands"],
+  ["item_types", "Item types"],
+  ["item_fields", "Item fields"],
+  ["migrations", "Migrations"],
+  ["profiles", "Profiles"],
+  ["importers", "Importers"],
+  ["exporters", "Exporters"],
+  ["search_providers", "Search providers"],
+  ["vector_store_adapters", "Vector store adapters"],
+  ["hooks", "Lifecycle hooks"],
+  ["parser_overrides", "Parser overrides"],
+  ["service_overrides", "Service overrides"],
+  ["renderer_overrides", "Renderer overrides"]
+];
+function headingPrefix(level) {
+  return "#".repeat(level);
+}
+function code(value) {
+  if (!value.includes("`")) {
+    return `\`${value}\``;
+  }
+  let longestRun = 0;
+  let currentRun = 0;
+  for (const char of value) {
+    currentRun = char === "`" ? currentRun + 1 : 0;
+    longestRun = Math.max(longestRun, currentRun);
+  }
+  const fence = "`".repeat(longestRun + 1);
+  const pad = value.startsWith("`") || value.endsWith("`") ? " " : "";
+  return `${fence}${pad}${value}${pad}${fence}`;
+}
+function renderCapabilitiesLine(capabilities) {
+  if (capabilities.length === 0) {
+    return "Capabilities: _none registered_";
+  }
+  return `Capabilities: ${capabilities.map(code).join(", ")}`;
+}
+function renderSection(heading, level, entries) {
+  const lines = [`${headingPrefix(level)} ${heading}`, ""];
+  if (entries.length === 0) {
+    lines.push("_None._", "");
+    return lines;
+  }
+  lines.push(...entries.map((entry) => `- ${code(entry)}`), "");
+  return lines;
+}
+function renderPreflightSection(count, level, includeEmpty) {
+  if (count === 0 && !includeEmpty) {
+    return [];
+  }
+  return [
+    `${headingPrefix(level)} Preflight overrides`,
+    "",
+    count > 0 ? `- ${count} registered (this surface carries no per-entry identifier)` : "_None._",
+    ""
+  ];
+}
+function renderExtensionSurfaceMarkdown(summary, options = {}) {
+  const titleLevel = options.headingLevel ?? 2;
+  if (!Number.isInteger(titleLevel) || titleLevel < MIN_HEADING_LEVEL || titleLevel > MAX_HEADING_LEVEL) {
+    throw new RangeError(`headingLevel must be an integer in [${MIN_HEADING_LEVEL}, ${MAX_HEADING_LEVEL}], received ${String(options.headingLevel)}`);
+  }
+  const sectionLevel = Math.min(titleLevel + 1, MAX_HEADING_LEVEL);
+  const includeEmpty = options.includeEmpty === true;
+  const title = options.title ?? "Extension surfaces";
+  const lines = [`${headingPrefix(titleLevel)} ${title}`, ""];
+  if (includeEmpty || summary.capabilities.length > 0) {
+    lines.push(renderCapabilitiesLine(summary.capabilities), "");
+  }
+  for (const [field, heading] of SURFACE_SECTIONS) {
+    const entries = summary[field];
+    if (entries.length === 0 && !includeEmpty) {
+      continue;
+    }
+    lines.push(...renderSection(heading, sectionLevel, entries));
+  }
+  lines.push(...renderPreflightSection(summary.preflight_overrides, sectionLevel, includeEmpty));
+  const hasAnySurface = summary.preflight_overrides > 0 || SURFACE_SECTIONS.some(([field]) => summary[field].length > 0);
+  if (!hasAnySurface && !includeEmpty) {
+    lines.push("_This extension registers no surfaces._", "");
+  }
+  return `${lines.join("\n").trimEnd()}
+`;
+}
+
+export {
+  describeExtensionActivation,
+  renderExtensionSurfaceMarkdown
+};
+//# sourceMappingURL=chunk-AGHMOTGM.js.map
+
+//# debugId=b7da1375-1527-5871-9f84-948595aee48f