@unbrained/pm-cli 2026.6.11 → 2026.6.13

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-P5U5EOMA.js → chunk-NN6RKGFW.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-CCX4RSYZ.js";
+} from "./chunk-32XSW44C.js";
 import {
   EXIT_CODE,
   PmCliError
-} from "./chunk-A6LXQFO7.js";
+} from "./chunk-S2CDTRJ6.js";
 
 // dist/cli/shared-parsers.js
 function parseLimit(raw, label = "--limit") {
@@ -52,6 +52,6 @@ export {
   parsePriority,
   parseType
 };
-//# sourceMappingURL=chunk-P5U5EOMA.js.map
+//# sourceMappingURL=chunk-NN6RKGFW.js.map
 
 //# debugId=5290e29c-a147-56df-94c4-59907951e37f

package/dist/cli-bundle/chunks/{chunk-GWZSYR6X.js → chunk-O3YCJOVX.js}

@@ -4,7 +4,7 @@ import {
   runActiveRendererOverride,
   runActiveServiceOverrideSync,
   setActiveCommandResult
-} from "./chunk-FY4SPXSC.js";
+} from "./chunk-LFW5NQUP.js";
 
 // dist/core/output/mutation-projection.js
 !(function() {
@@ -346,4 +346,4 @@ export {
   printResult,
   printError
 };
-//# sourceMappingURL=chunk-GWZSYR6X.js.map
+//# sourceMappingURL=chunk-O3YCJOVX.js.map

package/dist/cli-bundle/chunks/{chunk-7UGSRQCL.js → chunk-PEH7SZD2.js}

@@ -1,13 +1,13 @@
 import {
   locateItem,
   readLocatedItem
-} from "./chunk-3KLPFWZ4.js";
+} from "./chunk-XXLMJDUB.js";
 import {
   resolveItemTypeRegistry
-} from "./chunk-5SCT2JCT.js";
+} from "./chunk-W6KNFAMZ.js";
 import {
   nowIso
-} from "./chunk-IUKD4W6Z.js";
+} from "./chunk-IXVSSHGV.js";
 import {
   coercePositiveInteger,
   getActiveExtensionRegistrations,
@@ -22,7 +22,7 @@ import {
   toNonEmptyString,
   trimTrailingSlashes,
   writeFileAtomic
-} from "./chunk-FY4SPXSC.js";
+} from "./chunk-LFW5NQUP.js";
 
 // dist/core/search/http-client.js
 !(function() {
@@ -1365,7 +1365,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] = "20503452-0cee-5733-b1e8-7e6c6e93030a");
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "0e3fc214-b6c4-52a2-a5b4-54323fa752af");
   } catch (e2) {
   }
 })();
@@ -1435,7 +1435,7 @@ async function withQueueGate(pmRoot, fn, fallback) {
 }
 function delay(ms) {
   return new Promise((resolve2) => {
-    setTimeout(resolve2, ms).unref?.();
+    setTimeout(resolve2, ms);
   });
 }
 async function readPendingQueueIds(pmRoot) {
@@ -1914,4 +1914,4 @@ export {
   refreshSemanticEmbeddingsForMutatedItems,
   refreshSearchArtifactsForMutation
 };
-//# sourceMappingURL=chunk-7UGSRQCL.js.map
+//# sourceMappingURL=chunk-PEH7SZD2.js.map