@unbrained/pm-cli 2026.7.1 → 2026.7.3

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../../../cli/commands/activity.ts"],"sourcesContent":["/**\n * @module cli/commands/activity\n *\n * Implements the pm activity command surface and its agent-facing runtime behavior.\n */\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\nimport { getActiveExtensionRegistrations, runActiveOnReadHooks } from \"../../core/extensions/index.js\";\nimport { pathExists } from \"../../core/fs/fs-utils.js\";\nimport { enforceHistoryStreamPolicyForItems } from \"../../core/history/history-stream-policy.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 { compareTimestampStrings, nowIso, resolveIsoOrRelative } from \"../../core/shared/time.js\";\nimport { listAllFrontMatterLight } from \"../../core/store/item-store.js\";\nimport { getSettingsPath, resolvePmRoot } from \"../../core/store/paths.js\";\nimport { readSettings } from \"../../core/store/settings.js\";\nimport { readHistoryEntries } from \"./history.js\";\nimport { parseLimit } from \"../shared-parsers.js\";\nimport type { HistoryEntry } from \"../../types/index.js\";\n\n/**\n * Documents the activity command options payload exchanged by command, SDK, and package integrations.\n */\nexport interface ActivityCommandOptions {\n  id?: string;\n  op?: string;\n  author?: string;\n  from?: string;\n  to?: string;\n  limit?: string;\n  compact?: boolean;\n}\n\n/**\n * Documents the activity entry payload exchanged by command, SDK, and package integrations.\n */\nexport interface ActivityEntry extends HistoryEntry {\n  id: string;\n}\n\n/**\n * Documents the compact activity entry payload exchanged by command, SDK, and package integrations.\n */\nexport interface CompactActivityEntry {\n  id: string;\n  op: string;\n  ts: string;\n  author: string;\n  msg?: string;\n}\n\n/**\n * Documents the activity result payload exchanged by command, SDK, and package integrations.\n */\nexport interface ActivityResult {\n  activity: ActivityEntry[];\n  compact_activity?: CompactActivityEntry[];\n  compact: boolean;\n  count: number;\n  limit: number | null;\n}\n\ninterface ActivityFilters {\n  id: string | undefined;\n  op: string | undefined;\n  author: string | undefined;\n  from: string | undefined;\n  to: string | undefined;\n  limit: number | undefined;\n}\n\ninterface ActivityRuntimeContext {\n  pmRoot: string;\n  settings: Awaited<ReturnType<typeof readSettings>>;\n}\n\nfunction parseNonEmptyFilter(raw: string | undefined, flagLabel: string): string | undefined {\n  if (raw === undefined) return undefined;\n  const normalized = raw.trim();\n  if (normalized.length === 0) {\n    throw new PmCliError(`${flagLabel} must not be empty`, EXIT_CODE.USAGE);\n  }\n  return normalized;\n}\n\nfunction parseRangeBound(raw: string | undefined, nowValue: string, fieldLabel: string): string | undefined {\n  if (raw === undefined) return undefined;\n  const normalized = raw.trim();\n  if (normalized.length === 0) {\n    throw new PmCliError(\"Activity time bounds must not be empty\", EXIT_CODE.USAGE);\n  }\n  return resolveIsoOrRelative(normalized, new Date(nowValue), fieldLabel);\n}\n\nfunction includeByTimeWindow(entry: ActivityEntry, from: string | undefined, to: string | undefined): boolean {\n  if (entry.ts.length === 0 && (from || to)) {\n    return false;\n  }\n  if (from && compareTimestampStrings(entry.ts, from) < 0) {\n    return false;\n  }\n  if (to && compareTimestampStrings(entry.ts, to) >= 0) {\n    return false;\n  }\n  return true;\n}\n\nfunction limitEntries<T>(values: T[], limit: number | undefined): T[] {\n  if (limit === undefined) return values;\n  return values.slice(0, limit);\n}\n\nfunction readActivityString(value: unknown, fallback = \"\"): string {\n  return typeof value === \"string\" ? value : fallback;\n}\n\nfunction normalizeActivityEntry(id: string, entry: HistoryEntry): ActivityEntry {\n  return {\n    ...entry,\n    id,\n    ts: readActivityString(entry.ts),\n    author: readActivityString(entry.author, \"unknown\"),\n    op: readActivityString(entry.op, \"unknown\"),\n    patch: Array.isArray(entry.patch) ? entry.patch : [],\n    before_hash: readActivityString(entry.before_hash),\n    after_hash: readActivityString(entry.after_hash),\n  };\n}\n\nfunction sortActivity(entries: ActivityEntry[]): ActivityEntry[] {\n  return [...entries].sort((a, b) => {\n    const byTimestamp = b.ts.localeCompare(a.ts);\n    if (byTimestamp !== 0) return byTimestamp;\n    const byId = a.id.localeCompare(b.id);\n    if (byId !== 0) return byId;\n    return a.op.localeCompare(b.op);\n  });\n}\n\nasync function listHistoryFiles(historyDir: string): Promise<string[]> {\n  try {\n    return (await fs.readdir(historyDir))\n      .filter((entry) => entry.endsWith(\".jsonl\"))\n      .sort((a, b) => a.localeCompare(b));\n  } catch (error: unknown) {\n    // Activity should degrade gracefully when optional history storage is absent.\n    if ((error as NodeJS.ErrnoException).code === \"ENOENT\") {\n      return [];\n    }\n    throw error;\n  }\n}\n\nfunction resolveActivityFilters(options: ActivityCommandOptions): ActivityFilters {\n  const nowValue = nowIso();\n  const from = parseRangeBound(options.from, nowValue, \"--from\");\n  const to = parseRangeBound(options.to, nowValue, \"--to\");\n  if (from && to && compareTimestampStrings(from, to) >= 0) {\n    throw new PmCliError(\"Activity --from must be before --to\", EXIT_CODE.USAGE);\n  }\n  return {\n    id: parseNonEmptyFilter(options.id, \"Activity --id\"),\n    op: parseNonEmptyFilter(options.op, \"Activity --op\"),\n    author: parseNonEmptyFilter(options.author, \"Activity --author\"),\n    from,\n    to,\n    limit: parseLimit(options.limit),\n  };\n}\n\nasync function resolveActivityRuntimeContext(global: GlobalOptions): Promise<ActivityRuntimeContext> {\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  return {\n    pmRoot,\n    settings: await readSettings(pmRoot),\n  };\n}\n\nasync function prepareActivityHistoryRead(context: ActivityRuntimeContext): Promise<string> {\n  const typeRegistry = resolveItemTypeRegistry(context.settings, getActiveExtensionRegistrations());\n  const items = await listAllFrontMatterLight(\n    context.pmRoot,\n    context.settings.item_format,\n    typeRegistry.type_to_folder,\n    undefined,\n    context.settings.schema,\n  );\n  await enforceHistoryStreamPolicyForItems({\n    pmRoot: context.pmRoot,\n    settings: context.settings,\n    itemIds: items.map((item) => item.id),\n    commandLabel: \"activity\",\n  });\n  const historyDir = path.join(context.pmRoot, \"history\");\n  await runActiveOnReadHooks({\n    path: historyDir,\n    scope: \"project\",\n  });\n  return historyDir;\n}\n\nfunction includeActivityEntry(entry: HistoryEntry, candidate: ActivityEntry, filters: ActivityFilters): boolean {\n  // Preserve legacy filter semantics: op/author filters compare the raw\n  // history row before missing metadata is normalized to \"unknown\" for display.\n  if (filters.op && entry.op !== filters.op) {\n    return false;\n  }\n  if (filters.author && entry.author !== filters.author) {\n    return false;\n  }\n  return includeByTimeWindow(candidate, filters.from, filters.to);\n}\n\nasync function collectActivityEntries(historyDir: string, filters: ActivityFilters): Promise<ActivityEntry[]> {\n  const combined: ActivityEntry[] = [];\n  for (const file of await listHistoryFiles(historyDir)) {\n    const id = file.slice(0, -\".jsonl\".length);\n    if (filters.id && id !== filters.id) {\n      continue;\n    }\n    const entries = await readHistoryEntries(path.join(historyDir, file), id);\n    for (const entry of entries) {\n      const candidate = normalizeActivityEntry(id, entry);\n      if (includeActivityEntry(entry, candidate, filters)) {\n        combined.push(candidate);\n      }\n    }\n  }\n  return combined;\n}\n\nfunction formatCompactActivity(activity: ActivityEntry[]): CompactActivityEntry[] {\n  return activity.map((entry): CompactActivityEntry => ({\n    id: entry.id,\n    op: entry.op,\n    ts: entry.ts,\n    author: entry.author,\n    ...(entry.message ? { msg: entry.message } : {}),\n  }));\n}\n\nexport const _testOnly = {\n  parseNonEmptyFilter,\n  parseRangeBound,\n  includeByTimeWindow,\n  limitEntries,\n  readActivityString,\n  normalizeActivityEntry,\n  sortActivity,\n  listHistoryFiles,\n};\n\n/**\n * Implements run activity for the public runtime surface of this module.\n */\nexport async function runActivity(options: ActivityCommandOptions, global: GlobalOptions): Promise<ActivityResult> {\n  const context = await resolveActivityRuntimeContext(global);\n  const filters = resolveActivityFilters(options);\n  const historyDir = await prepareActivityHistoryRead(context);\n  const activity = limitEntries(sortActivity(await collectActivityEntries(historyDir, filters)), filters.limit);\n  const compact = options.compact === true;\n  const compactActivity = compact ? formatCompactActivity(activity) : undefined;\n  return {\n    activity: compact ? [] : activity,\n    compact_activity: compactActivity,\n    compact,\n    count: activity.length,\n    limit: filters.limit ?? null,\n  };\n}\n"],"names":[],"mappings":"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","debugId":"5c21d341-ddd5-5a54-9407-3c2ce31429af"}

package/dist/cli-bundle/chunks/{chunk-KNPEF7QG.js → chunk-LOWVNZBZ.js}

@@ -1,13 +1,13 @@
 import {
   verifyHistoryChain
-} from "./chunk-G7I7DEZA.js";
+} from "./chunk-T4XBKJ3F.js";
 import {
   hashDocument
-} from "./chunk-3K2M5OYU.js";
+} from "./chunk-6KRFL33E.js";
 import {
   getHistoryPath,
   writeFileAtomic
-} from "./chunk-RVUALSJF.js";
+} from "./chunk-KHVGM5CS.js";
 
 // dist/core/history/drift-scan.js
 import fs from "fs/promises";
@@ -16,7 +16,7 @@ import path from "node:path";
 !(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] = "a928aad0-855f-5c7f-aa00-77d698ddca80");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "91c6995a-7219-5402-b2d4-e50227bf0149");
   } catch (e2) {
   }
 })();
@@ -76,11 +76,64 @@ async function verifyHistoryStream(historyPath) {
     contentHash
   };
 }
+function cacheMetadataMatches(cached, stat) {
+  return cached !== void 0 && cached.mtime_ms === stat.mtimeMs && cached.ctime_ms === stat.ctimeMs && cached.size === stat.size;
+}
+async function loadFreshStreamVerification(itemId, historyPath, accumulator) {
+  try {
+    const loaded = await verifyHistoryStream(historyPath);
+    if (!loaded) {
+      accumulator.missingStreams.push(itemId);
+      return null;
+    }
+    return loaded;
+  } catch {
+    accumulator.unreadableStreams.push(itemId);
+    return null;
+  }
+}
+async function resolveStreamVerification(params) {
+  const cachedContentHash = typeof params.cached?.content_hash === "string" && params.cached.content_hash.length > 0 ? params.cached.content_hash : void 0;
+  const canUseCache = cacheMetadataMatches(params.cached, params.stat) && cachedContentHash !== void 0 && params.cached !== void 0;
+  if (!canUseCache || !params.cached) {
+    return {
+      verification: await loadFreshStreamVerification(params.itemId, params.historyPath, params.accumulator),
+      cacheDirty: true
+    };
+  }
+  let currentContentHash;
+  if (params.verifyCacheHitByContent) {
+    try {
+      currentContentHash = await readHistoryContentHash(params.historyPath);
+    } catch {
+      params.accumulator.unreadableStreams.push(params.itemId);
+      return { verification: null, cacheDirty: false };
+    }
+  } else {
+    currentContentHash = cachedContentHash;
+  }
+  if (!params.verifyCacheHitByContent || currentContentHash === cachedContentHash) {
+    return {
+      verification: {
+        latestAfterHash: params.cached.latest_after_hash,
+        chainOk: params.cached.chain_ok,
+        contentHash: currentContentHash
+      },
+      cacheDirty: false
+    };
+  }
+  return {
+    verification: await loadFreshStreamVerification(params.itemId, params.historyPath, params.accumulator),
+    cacheDirty: true
+  };
+}
 async function scanHistoryDrift(pmRoot, items, options = {}) {
-  const missingStreams = [];
-  const unreadableStreams = [];
-  const hashMismatches = [];
-  const chainMismatches = [];
+  const accumulator = {
+    missingStreams: [],
+    unreadableStreams: [],
+    hashMismatches: [],
+    chainMismatches: []
+  };
   const cache = await loadDriftCache(pmRoot);
   const previousEntries = cache?.entries ?? {};
   const nextEntries = {};
@@ -93,88 +146,43 @@ async function scanHistoryDrift(pmRoot, items, options = {}) {
       stat = await fs.stat(historyPath);
     } catch (error) {
       if (isErrno(error, "ENOENT")) {
-        missingStreams.push(item.id);
+        accumulator.missingStreams.push(item.id);
       } else {
-        unreadableStreams.push(item.id);
+        accumulator.unreadableStreams.push(item.id);
       }
       continue;
     }
-    const loadStreamVerification = async () => {
-      try {
-        return await verifyHistoryStream(historyPath);
-      } catch {
-        return "unreadable";
-      }
-    };
-    const loadFreshVerification = async () => {
-      const loaded = await loadStreamVerification();
-      if (loaded === "unreadable") {
-        unreadableStreams.push(item.id);
-        return null;
-      }
-      if (!loaded) {
-        missingStreams.push(item.id);
-        return null;
-      }
-      return loaded;
-    };
     const cached = previousEntries[item.id];
-    let verification;
-    const metadataMatchesCache = cached !== void 0 && cached.mtime_ms === stat.mtimeMs && cached.ctime_ms === stat.ctimeMs && cached.size === stat.size;
-    const cachedContentHash = typeof cached?.content_hash === "string" && cached.content_hash.length > 0 ? cached.content_hash : void 0;
-    const canUseCache = metadataMatchesCache && cachedContentHash !== void 0;
-    if (canUseCache && cached) {
-      let currentContentHash;
-      if (verifyCacheHitByContent) {
-        try {
-          currentContentHash = await readHistoryContentHash(historyPath);
-        } catch {
-          unreadableStreams.push(item.id);
-          continue;
-        }
-      } else {
-        currentContentHash = cachedContentHash;
-      }
-      if (!verifyCacheHitByContent || currentContentHash === cachedContentHash) {
-        verification = {
-          latestAfterHash: cached.latest_after_hash,
-          chainOk: cached.chain_ok,
-          contentHash: currentContentHash
-        };
-      } else {
-        cacheDirty = true;
-        const refreshed = await loadFreshVerification();
-        if (!refreshed) {
-          continue;
-        }
-        verification = refreshed;
-      }
-    } else {
-      cacheDirty = true;
-      const refreshed = await loadFreshVerification();
-      if (!refreshed) {
-        continue;
-      }
-      verification = refreshed;
+    const resolved = await resolveStreamVerification({
+      itemId: item.id,
+      historyPath,
+      stat,
+      cached,
+      verifyCacheHitByContent,
+      accumulator
+    });
+    cacheDirty ||= resolved.cacheDirty;
+    if (!resolved.verification) {
+      continue;
     }
-    if (!verification.chainOk) {
-      chainMismatches.push(item.id);
+    if (!resolved.verification.chainOk) {
+      accumulator.chainMismatches.push(item.id);
     }
     nextEntries[item.id] = {
       mtime_ms: stat.mtimeMs,
       ctime_ms: stat.ctimeMs,
       size: stat.size,
-      content_hash: verification.contentHash,
-      latest_after_hash: verification.latestAfterHash,
-      chain_ok: verification.chainOk
+      content_hash: resolved.verification.contentHash,
+      latest_after_hash: resolved.verification.latestAfterHash,
+      chain_ok: resolved.verification.chainOk
     };
     const { body, ...frontMatter } = item;
     const currentHash = hashDocument({
       metadata: frontMatter,
       body
     });
-    if (currentHash !== verification.latestAfterHash) {
-      hashMismatches.push(item.id);
+    if (currentHash !== resolved.verification.latestAfterHash) {
+      accumulator.hashMismatches.push(item.id);
     }
   }
   if (cacheDirty || Object.keys(previousEntries).length !== Object.keys(nextEntries).length) {
@@ -185,11 +193,18 @@ async function scanHistoryDrift(pmRoot, items, options = {}) {
     } catch {
     }
   }
-  const driftedItems = [.../* @__PURE__ */ new Set([...missingStreams, ...unreadableStreams, ...hashMismatches, ...chainMismatches])].sort((a, b) => a.localeCompare(b));
-  return { missingStreams, unreadableStreams, hashMismatches, chainMismatches, driftedItems };
+  const driftedItems = [
+    .../* @__PURE__ */ new Set([
+      ...accumulator.missingStreams,
+      ...accumulator.unreadableStreams,
+      ...accumulator.hashMismatches,
+      ...accumulator.chainMismatches
+    ])
+  ].sort((a, b) => a.localeCompare(b));
+  return { ...accumulator, driftedItems };
 }
 
 export {
   scanHistoryDrift
 };
-//# sourceMappingURL=chunk-KNPEF7QG.js.map
+//# sourceMappingURL=chunk-LOWVNZBZ.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../core/history/drift-scan.ts"],
+  "sourcesContent": ["/**\n * @module core/history/drift-scan\n *\n * Implements append-only history and replay behavior for Drift Scan.\n */\nimport fs from \"fs/promises\";\nimport { createHash } from \"node:crypto\";\nimport path from \"node:path\";\nimport { getHistoryPath } from \"../store/paths.js\";\nimport { writeFileAtomic } from \"../fs/fs-utils.js\";\nimport { hashDocument } from \"./history.js\";\nimport { verifyHistoryChain } from \"./replay.js\";\nimport type { HistoryEntry, ItemMetadata } from \"../../types/index.js\";\n\n/**\n * Documents the drift scan result payload exchanged by command, SDK, and package integrations.\n */\nexport interface DriftScanResult {\n  missingStreams: string[];\n  unreadableStreams: string[];\n  hashMismatches: string[];\n  chainMismatches: string[];\n  driftedItems: string[];\n}\n\nconst DRIFT_CACHE_VERSION = 3;\nconst DRIFT_CACHE_FILENAME = \"history-drift-cache.json\";\n\n/**\n * Controls how cached history stream verification is trusted when the file stat\n * tuple still matches a previous scan.\n */\nexport type DriftCacheHitVerification = \"content_hash\" | \"metadata\";\n\n/**\n * Documents the history drift scan options shared by health, validate, and\n * repair callers.\n */\nexport interface DriftScanOptions {\n  cacheHitVerification?: DriftCacheHitVerification;\n}\n\ninterface DriftCacheEntry {\n  mtime_ms: number;\n  ctime_ms: number;\n  size: number;\n  content_hash: string;\n  latest_after_hash: string;\n  chain_ok: boolean;\n}\n\ninterface DriftCacheEnvelope {\n  version: number;\n  entries: Record<string, DriftCacheEntry>;\n}\n\nfunction getDriftCachePath(pmRoot: string): string {\n  return path.join(pmRoot, \"runtime\", DRIFT_CACHE_FILENAME);\n}\n\nasync function loadDriftCache(pmRoot: string): Promise<DriftCacheEnvelope | null> {\n  try {\n    const raw = await fs.readFile(getDriftCachePath(pmRoot), \"utf8\");\n    const parsed = JSON.parse(raw) as DriftCacheEnvelope;\n    if (parsed.version !== DRIFT_CACHE_VERSION || typeof parsed.entries !== \"object\" || parsed.entries === null) {\n      return null;\n    }\n    return parsed;\n  } catch {\n    return null;\n  }\n}\n\nfunction isErrno(error: unknown, code: string): boolean {\n  return typeof error === \"object\" && error !== null && \"code\" in error && (error as { code?: string }).code === code;\n}\n\ninterface StreamVerification {\n  latestAfterHash: string;\n  chainOk: boolean;\n  contentHash: string;\n}\n\ninterface DriftScanAccumulator {\n  missingStreams: string[];\n  unreadableStreams: string[];\n  hashMismatches: string[];\n  chainMismatches: string[];\n}\n\nfunction hashContent(raw: string): string {\n  return createHash(\"sha256\").update(raw).digest(\"hex\");\n}\n\nasync function readHistoryContentHash(historyPath: string): Promise<string> {\n  const raw = await fs.readFile(historyPath, \"utf8\");\n  return hashContent(raw);\n}\n\n/**\n * Read and fully verify one history stream's hash chain. Returns null for an\n * empty/missing stream (caller records it as a missing stream).\n */\nasync function verifyHistoryStream(historyPath: string): Promise<StreamVerification | null> {\n  const raw = await fs.readFile(historyPath, \"utf8\");\n  const contentHash = hashContent(raw);\n  if (raw.trim().length === 0) {\n    return null;\n  }\n  const entries: HistoryEntry[] = [];\n  let latestAfterHash: string | null = null;\n  for (const line of raw.split(/\\r?\\n/)) {\n    const trimmed = line.trim();\n    if (trimmed.length === 0) {\n      continue;\n    }\n    const parsed = JSON.parse(trimmed) as HistoryEntry;\n    if (typeof parsed.after_hash !== \"string\" || parsed.after_hash.trim().length === 0) {\n      throw new Error(\"missing after_hash\");\n    }\n    entries.push(parsed);\n    latestAfterHash = parsed.after_hash;\n  }\n  /* c8 ignore start -- defensive guard for future history schema changes. */\n  if (!latestAfterHash) {\n    return null;\n  }\n  /* c8 ignore stop */\n  return {\n    latestAfterHash,\n    chainOk: verifyHistoryChain(entries).ok,\n    contentHash,\n  };\n}\n\nfunction cacheMetadataMatches(cached: DriftCacheEntry | undefined, stat: Awaited<ReturnType<typeof fs.stat>>): boolean {\n  return cached !== undefined && cached.mtime_ms === stat.mtimeMs && cached.ctime_ms === stat.ctimeMs && cached.size === stat.size;\n}\n\nasync function loadFreshStreamVerification(\n  itemId: string,\n  historyPath: string,\n  accumulator: DriftScanAccumulator,\n): Promise<StreamVerification | null> {\n  try {\n    const loaded = await verifyHistoryStream(historyPath);\n    if (!loaded) {\n      accumulator.missingStreams.push(itemId);\n      return null;\n    }\n    return loaded;\n  } catch {\n    accumulator.unreadableStreams.push(itemId);\n    return null;\n  }\n}\n\nasync function resolveStreamVerification(params: {\n  itemId: string;\n  historyPath: string;\n  stat: Awaited<ReturnType<typeof fs.stat>>;\n  cached: DriftCacheEntry | undefined;\n  verifyCacheHitByContent: boolean;\n  accumulator: DriftScanAccumulator;\n}): Promise<{ verification: StreamVerification | null; cacheDirty: boolean }> {\n  const cachedContentHash =\n    typeof params.cached?.content_hash === \"string\" && params.cached.content_hash.length > 0\n      ? params.cached.content_hash\n      : undefined;\n  const canUseCache = cacheMetadataMatches(params.cached, params.stat) && cachedContentHash !== undefined && params.cached !== undefined;\n  if (!canUseCache || !params.cached) {\n    return {\n      verification: await loadFreshStreamVerification(params.itemId, params.historyPath, params.accumulator),\n      cacheDirty: true,\n    };\n  }\n  let currentContentHash: string;\n  if (params.verifyCacheHitByContent) {\n    try {\n      currentContentHash = await readHistoryContentHash(params.historyPath);\n    } catch {\n      params.accumulator.unreadableStreams.push(params.itemId);\n      return { verification: null, cacheDirty: false };\n    }\n  } else {\n    currentContentHash = cachedContentHash;\n  }\n  if (!params.verifyCacheHitByContent || currentContentHash === cachedContentHash) {\n    return {\n      verification: {\n        latestAfterHash: params.cached.latest_after_hash,\n        chainOk: params.cached.chain_ok,\n        contentHash: currentContentHash,\n      },\n      cacheDirty: false,\n    };\n  }\n  return {\n    verification: await loadFreshStreamVerification(params.itemId, params.historyPath, params.accumulator),\n    cacheDirty: true,\n  };\n}\n\n/**\n * Scan every item's history stream for drift (missing/unreadable streams, broken\n * hash chains, and item/history hash mismatches).\n *\n * Full chain re-verification of a large history tree is the dominant cost of\n * `pm health`. We cache the per-stream verification keyed by the history file's\n * mtime/ctime/size plus content hash. Strict callers keep recomputing the\n * content hash on metadata hits; latency-sensitive health checks can opt into\n * trusting the stat tuple and skip rereading unchanged streams.\n */\nexport async function scanHistoryDrift(\n  pmRoot: string,\n  items: Array<ItemMetadata & { body: string }>,\n  options: DriftScanOptions = {},\n): Promise<DriftScanResult> {\n  const accumulator: DriftScanAccumulator = {\n    missingStreams: [],\n    unreadableStreams: [],\n    hashMismatches: [],\n    chainMismatches: [],\n  };\n\n  const cache = await loadDriftCache(pmRoot);\n  const previousEntries: Record<string, DriftCacheEntry> = cache?.entries ?? {};\n  const nextEntries: Record<string, DriftCacheEntry> = {};\n  let cacheDirty = false;\n  // Metadata mode does not open a stat-matched stream, so unreadable-after-stat\n  // failures are intentionally deferred to strict validate/history-repair scans.\n  const verifyCacheHitByContent = options.cacheHitVerification !== \"metadata\";\n\n  for (const item of items) {\n    const historyPath = getHistoryPath(pmRoot, item.id);\n\n    let stat: Awaited<ReturnType<typeof fs.stat>>;\n    try {\n      stat = await fs.stat(historyPath);\n    } catch (error: unknown) {\n      if (isErrno(error, \"ENOENT\")) {\n        accumulator.missingStreams.push(item.id);\n      } else {\n        accumulator.unreadableStreams.push(item.id);\n      }\n      continue;\n    }\n\n    const cached = previousEntries[item.id];\n    const resolved = await resolveStreamVerification({\n      itemId: item.id,\n      historyPath,\n      stat,\n      cached,\n      verifyCacheHitByContent,\n      accumulator,\n    });\n    cacheDirty ||= resolved.cacheDirty;\n    if (!resolved.verification) {\n      continue;\n    }\n\n    if (!resolved.verification.chainOk) {\n      accumulator.chainMismatches.push(item.id);\n    }\n    nextEntries[item.id] = {\n      mtime_ms: stat.mtimeMs,\n      ctime_ms: stat.ctimeMs,\n      size: stat.size,\n      content_hash: resolved.verification.contentHash,\n      latest_after_hash: resolved.verification.latestAfterHash,\n      chain_ok: resolved.verification.chainOk,\n    };\n\n    const { body, ...frontMatter } = item;\n    const currentHash = hashDocument({\n      metadata: frontMatter as ItemMetadata,\n      body,\n    });\n    if (currentHash !== resolved.verification.latestAfterHash) {\n      accumulator.hashMismatches.push(item.id);\n    }\n  }\n\n  if (cacheDirty || Object.keys(previousEntries).length !== Object.keys(nextEntries).length) {\n    const cachePath = getDriftCachePath(pmRoot);\n    try {\n      await fs.mkdir(path.dirname(cachePath), { recursive: true });\n      await writeFileAtomic(cachePath, JSON.stringify({ version: DRIFT_CACHE_VERSION, entries: nextEntries }));\n    } catch {\n      // Best-effort cache write: a failed persist must never fail a health scan.\n    }\n  }\n\n  const driftedItems = [\n    ...new Set([\n      ...accumulator.missingStreams,\n      ...accumulator.unreadableStreams,\n      ...accumulator.hashMismatches,\n      ...accumulator.chainMismatches,\n    ]),\n  ].sort((a, b) => a.localeCompare(b));\n  return { ...accumulator, driftedItems };\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cli-bundle/chunks/{chunk-HYTGA6GI.js → chunk-MDHWWBNZ.js}

@@ -1,6 +1,6 @@
 import {
   parseOptionalNumber
-} from "./chunk-DDPTYJIM.js";
+} from "./chunk-P5L7Z2O6.js";
 import {
   splitCommaList
 } from "./chunk-5HIZDR5A.js";
@@ -8,7 +8,7 @@ import {
   EXIT_CODE,
   PmCliError,
   SCOPE_VALUES
-} from "./chunk-RVUALSJF.js";
+} from "./chunk-KHVGM5CS.js";
 
 // dist/cli/commands/linked-test-entry.js
 !(function() {
@@ -525,4 +525,4 @@ export {
   parseLinkedTestAssertionGteMap,
   parseLinkedTestJsonEntries
 };
-//# sourceMappingURL=chunk-HYTGA6GI.js.map
+//# sourceMappingURL=chunk-MDHWWBNZ.js.map

package/dist/cli-bundle/chunks/{chunk-N74UMG5H.js → chunk-MEZZZBYX.js}

@@ -3,7 +3,7 @@
 import {
   getRuntimePath,
   writeFileAtomic
-} from "./chunk-7R4QEMZZ.js";
+} from "./chunk-L4SLHV6G.js";
 
 // dist/core/session/session-state.js
 import { promises as fs } from "node:fs";
@@ -53,6 +53,6 @@ export {
   setFocusedItem,
   clearFocusedItem
 };
-//# sourceMappingURL=chunk-N74UMG5H.js.map
+//# sourceMappingURL=chunk-MEZZZBYX.js.map
 
 //# debugId=c63f67f8-15be-5ba4-9853-406782c70ecb