@unbrained/pm-cli 2026.6.10 → 2026.6.12

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

@@ -0,0 +1,220 @@
+// dist/core/lock/lock-gc.js
+import fs from "node:fs/promises";
+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] = "925ee778-ffe1-587a-9916-bdbd16065381");
+  } catch (e2) {
+  }
+})();
+function parseLock(raw) {
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    return null;
+  }
+  if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+    return null;
+  }
+  const candidate = parsed;
+  const { id, owner, created_at, ttl_seconds } = candidate;
+  if (typeof id !== "string" || typeof owner !== "string" || typeof created_at !== "string" || typeof ttl_seconds !== "number" || !Number.isFinite(ttl_seconds)) {
+    return null;
+  }
+  return { id, owner, created_at, ttl_seconds };
+}
+function isErrno(error, code) {
+  return typeof error === "object" && error !== null && "code" in error && error.code === code;
+}
+function classifyLockContent(file, raw, nowMs) {
+  const lock = parseLock(raw);
+  if (lock === null) {
+    return {
+      detail: "unparseable_json",
+      entry: {
+        file,
+        id: null,
+        owner: null,
+        created_at: null,
+        ttl_seconds: null,
+        age_seconds: null,
+        stale: false,
+        reason: "unparseable"
+      }
+    };
+  }
+  const createdAtMs = Date.parse(lock.created_at);
+  if (!Number.isFinite(createdAtMs)) {
+    return {
+      detail: "invalid_timestamp",
+      entry: {
+        file,
+        id: lock.id,
+        owner: lock.owner,
+        created_at: lock.created_at,
+        ttl_seconds: lock.ttl_seconds,
+        age_seconds: null,
+        stale: false,
+        reason: "unparseable"
+      }
+    };
+  }
+  const ageMs = nowMs - createdAtMs;
+  const age_seconds = Math.floor(ageMs / 1e3);
+  const stale = ageMs > lock.ttl_seconds * 1e3;
+  return {
+    detail: stale ? "expired" : "active",
+    entry: {
+      file,
+      id: lock.id,
+      owner: lock.owner,
+      created_at: lock.created_at,
+      ttl_seconds: lock.ttl_seconds,
+      age_seconds,
+      stale,
+      reason: stale ? "expired" : "active"
+    }
+  };
+}
+async function scanLockHealth(pmRoot, now) {
+  const nowMs = now ?? Date.now();
+  const locksDir = path.join(pmRoot, "locks");
+  const scan = {
+    scanned: 0,
+    active_lock_count: 0,
+    stale_lock_count: 0,
+    unreadable_lock_count: 0,
+    unparseable_lock_count: 0
+  };
+  let dirEntries;
+  try {
+    const rawDir = await fs.readdir(locksDir);
+    dirEntries = rawDir.filter((f) => f.endsWith(".lock")).sort();
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return scan;
+    }
+    throw error;
+  }
+  for (const file of dirEntries) {
+    let raw;
+    try {
+      raw = await fs.readFile(path.join(locksDir, file), "utf8");
+    } catch (readError) {
+      if (isErrno(readError, "ENOENT")) {
+        continue;
+      }
+      scan.scanned += 1;
+      scan.unreadable_lock_count += 1;
+      continue;
+    }
+    scan.scanned += 1;
+    const { detail } = classifyLockContent(file, raw, nowMs);
+    if (detail === "active") {
+      scan.active_lock_count += 1;
+    } else if (detail === "expired") {
+      scan.stale_lock_count += 1;
+    } else {
+      scan.unparseable_lock_count += 1;
+    }
+  }
+  return scan;
+}
+async function runLockGc(pmRoot, options) {
+  const { dryRun, hooks } = options;
+  const nowMs = options.now ?? Date.now();
+  const locksDir = path.join(pmRoot, "locks");
+  const result = {
+    scanned: 0,
+    removed: [],
+    retained: [],
+    warnings: [],
+    entries: []
+  };
+  let dirEntries;
+  try {
+    const raw = await fs.readdir(locksDir);
+    dirEntries = raw.filter((f) => f.endsWith(".lock")).sort();
+  } catch (error) {
+    if (isErrno(error, "ENOENT")) {
+      return result;
+    }
+    throw error;
+  }
+  for (const file of dirEntries) {
+    result.scanned += 1;
+    const absPath = path.join(locksDir, file);
+    const relPath = `locks/${file}`;
+    if (hooks?.onRead) {
+      const hookWarnings = await hooks.onRead(absPath);
+      result.warnings.push(...hookWarnings);
+    }
+    let raw;
+    try {
+      raw = await fs.readFile(absPath, "utf8");
+    } catch (readError) {
+      if (isErrno(readError, "ENOENT")) {
+        result.scanned -= 1;
+        continue;
+      }
+      result.warnings.push(`lock_unreadable:${file}`);
+      result.retained.push(relPath);
+      result.entries.push({
+        file,
+        id: null,
+        owner: null,
+        created_at: null,
+        ttl_seconds: null,
+        age_seconds: null,
+        stale: false,
+        reason: "unparseable"
+      });
+      continue;
+    }
+    const classified = classifyLockContent(file, raw, nowMs);
+    if (classified.detail === "unparseable_json") {
+      result.warnings.push(`lock_unparseable:${file}`);
+      result.retained.push(relPath);
+      result.entries.push(classified.entry);
+      continue;
+    }
+    if (classified.detail === "invalid_timestamp") {
+      result.warnings.push(`lock_invalid_timestamp:${file}`);
+      result.retained.push(relPath);
+      result.entries.push(classified.entry);
+      continue;
+    }
+    if (classified.detail === "active") {
+      result.retained.push(relPath);
+      result.entries.push(classified.entry);
+      continue;
+    }
+    if (!dryRun) {
+      try {
+        await fs.unlink(absPath);
+      } catch (unlinkError) {
+        if (!isErrno(unlinkError, "ENOENT")) {
+          result.warnings.push(`lock_remove_failed:${file}`);
+          result.retained.push(relPath);
+          result.entries.push(classified.entry);
+          continue;
+        }
+      }
+      if (hooks?.onWrite) {
+        const hookWarnings = await hooks.onWrite(absPath);
+        result.warnings.push(...hookWarnings);
+      }
+    }
+    result.removed.push(relPath);
+    result.entries.push(classified.entry);
+  }
+  return result;
+}
+
+export {
+  scanLockHealth,
+  runLockGc
+};
+//# sourceMappingURL=chunk-NAWVUHXH.js.map

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

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../../../../../../core/lock/lock-gc.ts"],
+  "sourcesContent": ["/**\n * lock-gc.ts — Stale lock file garbage collector.\n *\n * Safety-first policy: if a lock file cannot be read or parsed, it is RETAINED\n * rather than deleted. We only remove locks whose staleness can be conclusively\n * determined from the lock's own embedded `ttl_seconds` field.\n *\n * Staleness formula: (now_ms - Date.parse(created_at)) > ttl_seconds * 1000\n * Zero ttl means any lock older than 0 ms is stale. Negative ttl means always stale.\n */\n\nimport fs from \"node:fs/promises\";\nimport path from \"node:path\";\n\nexport interface StaleLockScanEntry {\n  /** e.g. \"pm-abc1.lock\" */\n  file: string;\n  /** parsed id, or null if unparseable */\n  id: string | null;\n  owner: string | null;\n  created_at: string | null;\n  ttl_seconds: number | null;\n  /** floor((now - created_at)/1000), null if unparseable */\n  age_seconds: number | null;\n  /** true only when classified expired */\n  stale: boolean;\n  reason: \"expired\" | \"active\" | \"unparseable\";\n}\n\nexport interface LockGcHooks {\n  onRead?: (lockPath: string) => Promise<string[]> | string[];\n  onWrite?: (lockPath: string) => Promise<string[]> | string[];\n}\n\nexport interface LockGcOptions {\n  dryRun: boolean;\n  /** epoch ms; defaults to Date.now() — injectable for deterministic tests */\n  now?: number;\n  hooks?: LockGcHooks;\n}\n\nexport interface LockGcResult {\n  /** number of *.lock files examined */\n  scanned: number;\n  /** relative paths like \"locks/pm-abc1.lock\" (removed, or would-remove under dryRun) */\n  removed: string[];\n  /** relative paths retained (active OR unparseable — never delete what we can't reason about) */\n  retained: string[];\n  warnings: string[];\n  /** one per scanned *.lock file, sorted by file name asc */\n  entries: StaleLockScanEntry[];\n}\n\ninterface ParsedLock {\n  id: string;\n  owner: string;\n  created_at: string;\n  ttl_seconds: number;\n}\n\nfunction parseLock(raw: string): ParsedLock | null {\n  let parsed: unknown;\n  try {\n    parsed = JSON.parse(raw) as unknown;\n  } catch {\n    return null;\n  }\n  if (typeof parsed !== \"object\" || parsed === null || Array.isArray(parsed)) {\n    return null;\n  }\n  const candidate = parsed as Record<string, unknown>;\n  const { id, owner, created_at, ttl_seconds } = candidate;\n  if (\n    typeof id !== \"string\" ||\n    typeof owner !== \"string\" ||\n    typeof created_at !== \"string\" ||\n    typeof ttl_seconds !== \"number\" ||\n    !Number.isFinite(ttl_seconds)\n  ) {\n    return null;\n  }\n  return { id, owner, created_at, ttl_seconds };\n}\n\nfunction isErrno(error: unknown, code: string): boolean {\n  return (\n    typeof error === \"object\" &&\n    error !== null &&\n    \"code\" in error &&\n    (error as { code?: string }).code === code\n  );\n}\n\n/**\n * Fine-grained classification outcome for one readable lock file's content.\n * `unparseable_json` and `invalid_timestamp` both surface as the coarse\n * `reason: \"unparseable\"` on the scan entry (gc retains both), but stay\n * distinct here so callers can emit precise warnings.\n */\nexport type LockClassificationDetail = \"active\" | \"expired\" | \"unparseable_json\" | \"invalid_timestamp\";\n\nexport interface LockContentClassification {\n  detail: LockClassificationDetail;\n  entry: StaleLockScanEntry;\n}\n\n/**\n * Pure classification of one lock file's raw content against `nowMs`. This is\n * the single staleness/parse policy shared by `pm gc --scope locks` (which acts\n * on it) and the `pm health` locks check (which only reports it).\n */\nexport function classifyLockContent(file: string, raw: string, nowMs: number): LockContentClassification {\n  const lock = parseLock(raw);\n  if (lock === null) {\n    return {\n      detail: \"unparseable_json\",\n      entry: {\n        file,\n        id: null,\n        owner: null,\n        created_at: null,\n        ttl_seconds: null,\n        age_seconds: null,\n        stale: false,\n        reason: \"unparseable\",\n      },\n    };\n  }\n  const createdAtMs = Date.parse(lock.created_at);\n  if (!Number.isFinite(createdAtMs)) {\n    return {\n      detail: \"invalid_timestamp\",\n      entry: {\n        file,\n        id: lock.id,\n        owner: lock.owner,\n        created_at: lock.created_at,\n        ttl_seconds: lock.ttl_seconds,\n        age_seconds: null,\n        stale: false,\n        reason: \"unparseable\",\n      },\n    };\n  }\n  const ageMs = nowMs - createdAtMs;\n  const age_seconds = Math.floor(ageMs / 1000);\n  const stale = ageMs > lock.ttl_seconds * 1000;\n  return {\n    detail: stale ? \"expired\" : \"active\",\n    entry: {\n      file,\n      id: lock.id,\n      owner: lock.owner,\n      created_at: lock.created_at,\n      ttl_seconds: lock.ttl_seconds,\n      age_seconds,\n      stale,\n      reason: stale ? \"expired\" : \"active\",\n    },\n  };\n}\n\nexport interface LockHealthScan {\n  /** number of *.lock files examined (ghost files that vanish mid-scan are skipped) */\n  scanned: number;\n  active_lock_count: number;\n  stale_lock_count: number;\n  unreadable_lock_count: number;\n  /** invalid JSON, wrong shape, or an unparseable created_at timestamp */\n  unparseable_lock_count: number;\n}\n\n/**\n * Read-only locks scan for `pm health`: classifies every lock file with the\n * same policy `pm gc --scope locks` uses but never removes anything.\n */\nexport async function scanLockHealth(pmRoot: string, now?: number): Promise<LockHealthScan> {\n  const nowMs = now ?? Date.now();\n  const locksDir = path.join(pmRoot, \"locks\");\n  const scan: LockHealthScan = {\n    scanned: 0,\n    active_lock_count: 0,\n    stale_lock_count: 0,\n    unreadable_lock_count: 0,\n    unparseable_lock_count: 0,\n  };\n\n  let dirEntries: string[];\n  try {\n    const rawDir = await fs.readdir(locksDir);\n    dirEntries = rawDir.filter((f) => f.endsWith(\".lock\")).sort();\n  } catch (error: unknown) {\n    if (isErrno(error, \"ENOENT\")) {\n      return scan;\n    }\n    throw error;\n  }\n\n  for (const file of dirEntries) {\n    let raw: string;\n    try {\n      raw = await fs.readFile(path.join(locksDir, file), \"utf8\");\n    } catch (readError: unknown) {\n      if (isErrno(readError, \"ENOENT\")) {\n        // Disappeared between readdir and readFile — treat as a ghost; skip quietly.\n        continue;\n      }\n      scan.scanned += 1;\n      scan.unreadable_lock_count += 1;\n      continue;\n    }\n    scan.scanned += 1;\n    const { detail } = classifyLockContent(file, raw, nowMs);\n    if (detail === \"active\") {\n      scan.active_lock_count += 1;\n    } else if (detail === \"expired\") {\n      scan.stale_lock_count += 1;\n    } else {\n      scan.unparseable_lock_count += 1;\n    }\n  }\n\n  return scan;\n}\n\nexport async function runLockGc(pmRoot: string, options: LockGcOptions): Promise<LockGcResult> {\n  const { dryRun, hooks } = options;\n  const nowMs = options.now ?? Date.now();\n  const locksDir = path.join(pmRoot, \"locks\");\n\n  const result: LockGcResult = {\n    scanned: 0,\n    removed: [],\n    retained: [],\n    warnings: [],\n    entries: [],\n  };\n\n  let dirEntries: string[];\n  try {\n    const raw = await fs.readdir(locksDir);\n    dirEntries = raw.filter((f) => f.endsWith(\".lock\")).sort();\n  } catch (error: unknown) {\n    if (isErrno(error, \"ENOENT\")) {\n      return result;\n    }\n    throw error;\n  }\n\n  for (const file of dirEntries) {\n    result.scanned += 1;\n    const absPath = path.join(locksDir, file);\n    const relPath = `locks/${file}`;\n\n    // --- onRead hook ---\n    if (hooks?.onRead) {\n      const hookWarnings = await hooks.onRead(absPath);\n      result.warnings.push(...hookWarnings);\n    }\n\n    // --- read file ---\n    let raw: string;\n    try {\n      raw = await fs.readFile(absPath, \"utf8\");\n    } catch (readError: unknown) {\n      if (isErrno(readError, \"ENOENT\")) {\n        // Disappeared between readdir and readFile — treat as a ghost; skip quietly.\n        result.scanned -= 1;\n        continue;\n      }\n      result.warnings.push(`lock_unreadable:${file}`);\n      result.retained.push(relPath);\n      result.entries.push({\n        file,\n        id: null,\n        owner: null,\n        created_at: null,\n        ttl_seconds: null,\n        age_seconds: null,\n        stale: false,\n        reason: \"unparseable\",\n      });\n      continue;\n    }\n\n    // --- classify (shared with the read-only pm health locks scan) ---\n    const classified = classifyLockContent(file, raw, nowMs);\n    if (classified.detail === \"unparseable_json\") {\n      result.warnings.push(`lock_unparseable:${file}`);\n      result.retained.push(relPath);\n      result.entries.push(classified.entry);\n      continue;\n    }\n    if (classified.detail === \"invalid_timestamp\") {\n      result.warnings.push(`lock_invalid_timestamp:${file}`);\n      result.retained.push(relPath);\n      result.entries.push(classified.entry);\n      continue;\n    }\n    if (classified.detail === \"active\") {\n      result.retained.push(relPath);\n      result.entries.push(classified.entry);\n      continue;\n    }\n\n    // --- stale: remove or preview ---\n    if (!dryRun) {\n      try {\n        await fs.unlink(absPath);\n      } catch (unlinkError: unknown) {\n        if (!isErrno(unlinkError, \"ENOENT\")) {\n          result.warnings.push(`lock_remove_failed:${file}`);\n          result.retained.push(relPath);\n          result.entries.push(classified.entry);\n          continue;\n        }\n        // ENOENT on unlink = already gone (race); treat as removed\n      }\n      // onWrite hook after successful removal\n      if (hooks?.onWrite) {\n        const hookWarnings = await hooks.onWrite(absPath);\n        result.warnings.push(...hookWarnings);\n      }\n    }\n\n    result.removed.push(relPath);\n    result.entries.push(classified.entry);\n  }\n\n  return result;\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/dist/cli-bundle/chunks/{chunk-6ADVKPVV.js → chunk-OASDW5UI.js}

@@ -5,21 +5,21 @@ import {
 } from "./chunk-J27KIHTG.js";
 import {
   parseCsvKv
-} from "./chunk-K7SXBA75.js";
+} from "./chunk-I7NYDZDV.js";
 import {
   parseLimit
-} from "./chunk-LYL32FT6.js";
+} from "./chunk-P5U5EOMA.js";
 import {
   locateItem,
   mutateItem,
   readLocatedItem
-} from "./chunk-MF6KSSMF.js";
+} from "./chunk-HI7STVF2.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-344GDQTH.js";
+} from "./chunk-CCX4RSYZ.js";
 import {
   nowIso
-} from "./chunk-PYULT32I.js";
+} from "./chunk-WUNFKP7M.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -28,7 +28,7 @@ import {
   pathExists,
   readSettings,
   resolvePmRoot
-} from "./chunk-WNMRICXH.js";
+} from "./chunk-A6LXQFO7.js";
 
 // dist/cli/commands/annotation-command.js
 function limitAnnotationEntries(values, limit) {
@@ -149,6 +149,6 @@ export {
   wrapOwnershipConflict,
   runAnnotationCommand
 };
-//# sourceMappingURL=chunk-6ADVKPVV.js.map
+//# sourceMappingURL=chunk-OASDW5UI.js.map
 
 //# debugId=2663dc72-ebe4-5c50-8d4c-28022abebefe

package/dist/cli-bundle/chunks/{chunk-EIS32UA4.js → chunk-OLKBSY4N.js}

@@ -1,6 +1,6 @@
 import {
   BUILTIN_ITEM_TYPE_VALUES
-} from "./chunk-OQGJSCZZ.js";
+} from "./chunk-FY4SPXSC.js";
 
 // dist/core/schema/item-types-file.js
 !(function() {
@@ -218,4 +218,4 @@ export {
   buildInvalidTypeHint,
   buildInvalidTypeError
 };
-//# sourceMappingURL=chunk-EIS32UA4.js.map
+//# sourceMappingURL=chunk-OLKBSY4N.js.map

package/dist/cli-bundle/chunks/{chunk-X3IPJU2O.js → chunk-P5BJOMBB.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-J27KIHTG.js";
 import {
   readHistoryEntries
-} from "./chunk-KHBRV5JU.js";
+} from "./chunk-HGLC63AU.js";
 import {
   EMPTY_REPLAY_DOCUMENT,
   historyEntriesToRaw,
@@ -13,27 +13,27 @@ import {
   replayToItemDocument,
   tryApplyReplayPatch,
   verifyHistoryChain
-} from "./chunk-BE5G7HEL.js";
+} from "./chunk-ZYNJNPYD.js";
 import {
   acquireLock,
   createHistoryEntry,
   locateItem,
   readLocatedItem
-} from "./chunk-MF6KSSMF.js";
+} from "./chunk-HI7STVF2.js";
 import {
   normalizeItemId,
   normalizeRawItemId
-} from "./chunk-UDWUDUJI.js";
+} from "./chunk-ATEES5SX.js";
 import {
   canonicalDocument,
   serializeItemDocument
-} from "./chunk-SNASEDXB.js";
+} from "./chunk-UUWGCWBU.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-344GDQTH.js";
+} from "./chunk-CCX4RSYZ.js";
 import {
   nowIso
-} from "./chunk-PYULT32I.js";
+} from "./chunk-WUNFKP7M.js";
 import {
   EXIT_CODE,
   PmCliError,
@@ -48,7 +48,7 @@ import {
   resolvePmRoot,
   runActiveOnWriteHooks,
   writeFileAtomic
-} from "./chunk-WNMRICXH.js";
+} from "./chunk-A6LXQFO7.js";
 
 // dist/cli/commands/history-redact.js
 import fs from "node:fs/promises";
@@ -535,6 +535,6 @@ export {
   resolveHistorySubject,
   runHistoryRedact
 };
-//# sourceMappingURL=chunk-X3IPJU2O.js.map
+//# sourceMappingURL=chunk-P5BJOMBB.js.map
 
 //# debugId=50104455-b180-5239-87c7-308e9abf62a2

package/dist/cli-bundle/chunks/{chunk-LYL32FT6.js → chunk-P5U5EOMA.js}

@@ -2,11 +2,11 @@
 !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]="5290e29c-a147-56df-94c4-59907951e37f")}catch(e){}}();
 import {
   resolveTypeName
-} from "./chunk-344GDQTH.js";
+} from "./chunk-CCX4RSYZ.js";
 import {
   EXIT_CODE,
   PmCliError
-} from "./chunk-WNMRICXH.js";
+} from "./chunk-A6LXQFO7.js";
 
 // dist/cli/shared-parsers.js
 function parseLimit(raw, label = "--limit") {
@@ -52,6 +52,6 @@ export {
   parsePriority,
   parseType
 };
-//# sourceMappingURL=chunk-LYL32FT6.js.map
+//# sourceMappingURL=chunk-P5U5EOMA.js.map
 
 //# debugId=5290e29c-a147-56df-94c4-59907951e37f

package/dist/cli-bundle/chunks/{chunk-EAQLLID6.js → chunk-PNYAAB4S.js}

@@ -1,185 +1,6 @@
-
-!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]="5597e7ea-39ad-5bd4-9a7a-5a7428ea5e27")}catch(e){}}();
-import {
-  verifyHistoryChain
-} from "./chunk-BE5G7HEL.js";
-import {
-  hashDocument
-} from "./chunk-MF6KSSMF.js";
-import {
-  getHistoryPath,
-  writeFileAtomic
-} from "./chunk-WNMRICXH.js";
-
-// dist/core/history/drift-scan.js
-import fs from "fs/promises";
-import { createHash } from "node:crypto";
-import path from "node:path";
-var DRIFT_CACHE_VERSION = 2;
-var DRIFT_CACHE_FILENAME = "history-drift-cache.json";
-function getDriftCachePath(pmRoot) {
-  return path.join(pmRoot, "runtime", DRIFT_CACHE_FILENAME);
-}
-async function loadDriftCache(pmRoot) {
-  try {
-    const raw = await fs.readFile(getDriftCachePath(pmRoot), "utf8");
-    const parsed = JSON.parse(raw);
-    if (parsed.version !== DRIFT_CACHE_VERSION || typeof parsed.entries !== "object" || parsed.entries === null) {
-      return null;
-    }
-    return parsed;
-  } catch {
-    return null;
-  }
-}
-function isErrno(error, code) {
-  return typeof error === "object" && error !== null && "code" in error && error.code === code;
-}
-function hashContent(raw) {
-  return createHash("sha256").update(raw).digest("hex");
-}
-async function readHistoryContentHash(historyPath) {
-  const raw = await fs.readFile(historyPath, "utf8");
-  return hashContent(raw);
-}
-async function verifyHistoryStream(historyPath) {
-  const raw = await fs.readFile(historyPath, "utf8");
-  const contentHash = hashContent(raw);
-  if (raw.trim().length === 0) {
-    return null;
-  }
-  const entries = [];
-  let latestAfterHash = null;
-  for (const line of raw.split(/\r?\n/)) {
-    const trimmed = line.trim();
-    if (trimmed.length === 0) {
-      continue;
-    }
-    const parsed = JSON.parse(trimmed);
-    if (typeof parsed.after_hash !== "string" || parsed.after_hash.trim().length === 0) {
-      throw new Error("missing after_hash");
-    }
-    entries.push(parsed);
-    latestAfterHash = parsed.after_hash;
-  }
-  if (!latestAfterHash) {
-    return null;
-  }
-  return {
-    latestAfterHash,
-    chainOk: verifyHistoryChain(entries).ok,
-    contentHash
-  };
-}
-async function scanHistoryDrift(pmRoot, items) {
-  const missingStreams = [];
-  const unreadableStreams = [];
-  const hashMismatches = [];
-  const chainMismatches = [];
-  const cache = await loadDriftCache(pmRoot);
-  const previousEntries = cache?.entries ?? {};
-  const nextEntries = {};
-  let cacheDirty = false;
-  for (const item of items) {
-    const historyPath = getHistoryPath(pmRoot, item.id);
-    let stat;
-    try {
-      stat = await fs.stat(historyPath);
-    } catch (error) {
-      if (isErrno(error, "ENOENT")) {
-        missingStreams.push(item.id);
-      } else {
-        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;
-      try {
-        currentContentHash = await readHistoryContentHash(historyPath);
-      } catch {
-        unreadableStreams.push(item.id);
-        continue;
-      }
-      if (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;
-    }
-    if (!verification.chainOk) {
-      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
-    };
-    const { body, ...frontMatter } = item;
-    const currentHash = hashDocument({
-      metadata: frontMatter,
-      body
-    });
-    if (currentHash !== verification.latestAfterHash) {
-      hashMismatches.push(item.id);
-    }
-  }
-  if (cacheDirty || Object.keys(previousEntries).length !== Object.keys(nextEntries).length) {
-    const cachePath = getDriftCachePath(pmRoot);
-    try {
-      await fs.mkdir(path.dirname(cachePath), { recursive: true });
-      await writeFileAtomic(cachePath, JSON.stringify({ version: DRIFT_CACHE_VERSION, entries: nextEntries }));
-    } catch {
-    }
-  }
-  const driftedItems = [.../* @__PURE__ */ new Set([...missingStreams, ...unreadableStreams, ...hashMismatches, ...chainMismatches])].sort((a, b) => a.localeCompare(b));
-  return { missingStreams, unreadableStreams, hashMismatches, chainMismatches, driftedItems };
-}
-
 // dist/core/diagnostics/remediation.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]="2348b67c-04ba-55f5-9eed-37c06b56f4cb")}catch(e){}}();
 var REMEDIATION_REGISTRY = Object.freeze([
   // --- pm health: directories ---
   {
@@ -282,25 +103,38 @@ var REMEDIATION_REGISTRY = Object.freeze([
     summary: "A history stream contains Git conflict markers; resolve the markers, then re-anchor the chain."
   },
   // --- pm health: history_drift ---
+  // `pm health` rewrites these commands to `pm history-repair --all` in the
+  // per-check remediation_map when more than one stream is drifted.
   {
     code: "history_drift_missing_stream",
     command: "pm history-repair <id>",
-    summary: "The item has no history stream; re-anchor the chain to rebuild it."
+    summary: "The item has no history stream; re-anchor the chain to rebuild it (pm history-repair --all repairs every drifted stream in one pass)."
   },
   {
     code: "history_drift_unreadable_stream",
     command: "pm history-repair <id>",
-    summary: "The item's history stream is unreadable; re-anchor the chain."
+    summary: "The item's history stream is unreadable; re-anchor the chain (pm history-repair --all repairs every drifted stream in one pass)."
   },
   {
     code: "history_drift_hash_mismatch",
     command: "pm history-repair <id>",
-    summary: "The item's content hash no longer matches its history; re-anchor the chain."
+    summary: "The item's content hash no longer matches its history; re-anchor the chain (pm history-repair --all repairs every drifted stream in one pass)."
   },
   {
     code: "history_drift_chain_mismatch",
     command: "pm history-repair <id>",
-    summary: "The item's history chain is broken; re-anchor the chain."
+    summary: "The item's history chain is broken; re-anchor the chain (pm history-repair --all repairs every drifted stream in one pass)."
+  },
+  // --- pm health: locks ---
+  {
+    code: "locks_stale_count",
+    command: "pm gc --scope locks",
+    summary: "Stale item-claim locks (embedded ttl elapsed) can block mutations; sweep them \u2014 gc retains active and unparseable locks."
+  },
+  {
+    code: "locks_unreadable",
+    command: "pm gc --scope locks --dry-run",
+    summary: "Some lock files could not be read; preview the sweep and inspect the unreadable files manually \u2014 gc never deletes what it cannot read."
   },
   // --- pm health: vectorization ---
   {
@@ -467,10 +301,9 @@ function buildRemediationCommands(warnings) {
 }
 
 export {
-  scanHistoryDrift,
   buildRemediationMap,
   buildRemediationCommands
 };
-//# sourceMappingURL=chunk-EAQLLID6.js.map
+//# sourceMappingURL=chunk-PNYAAB4S.js.map
 
-//# debugId=5597e7ea-39ad-5bd4-9a7a-5a7428ea5e27
+//# debugId=2348b67c-04ba-55f5-9eed-37c06b56f4cb