omp-fabric 1.25.28 → 1.25.31

package/CHANGELOG.md

@@ -1,5 +1,35 @@
 # Changelog
 
+## 1.25.31
+
+### Notes
+
+- Test-only fix for the Windows job: the temporary-tier sweep test removed the right ledger but compared that path against a freshly canonicalized one, which differs in path form between platforms. It now asserts one removal whose tail is the fixture project.
+- 1.25.29 and 1.25.30 both failed the windows-latest Test job and never published; every sweep change described under 1.25.29 and 1.25.30 ships in this release. Their `v1.25.29` and `v1.25.30` tags stay where they are.
+
+## 1.25.30
+
+### Fixed
+
+- Temporary-root detection survives Windows path forms. `os.tmpdir()` reports the short-name form (`C:\Users\RUNNER~1\AppData\Local\Temp`) while a project path that went through `realpath` is long-name, and the comparison was case-sensitive, so the temporary retention tier missed those projects on Windows. Both sides now resolve through `fs.realpathSync.native` (falling back to the deepest existing ancestor) and compare case-insensitively on win32.
+- The stale-record sweep test asserts on the record's path tail instead of a canonicalized equality, which differed between platforms.
+
+### Notes
+
+- 1.25.29's Test job failed on windows-latest for those two cases and it never published; its sweep changes ship in this release. Its `v1.25.29` tag stays where it is.
+
+## 1.25.29
+
+### Changed
+
+- Ledger sweep works on two retention tiers: a project path under a temporary root (`os.tmpdir()`, `/tmp`, `/var/tmp`) is reclaimed after 2 days instead of 30, because fixture and smoke repos are throwaway by construction while a real project directory can be missing temporarily (unmounted drive, renamed checkout) and still deserve its history. `sweepLedgers` takes `tempRetentionMs` for callers that want a different tier. The sweep interval stays 24h.
+- The sweep also drops a directory record whose ledger file is gone. It used to skip those records forever (`statSync` failed, `continue`), so every deleted ledger left a permanent entry in `projects.json`.
+
+### Notes
+
+- Measured before this change: the ledger root held 17.36GB across 69 files, and the biggest ones belong to real projects (Kaitech/Odoo19/modifier 2.5GB, Kaitech/Odoo19 2.4GB, apollo-coworker 2.0GB, paperclip-pro 1.9GB). Files whose project directory is gone totalled 0.15GB, so reclaiming abandoned paths is a hygiene fix, not a disk fix; per-project ledger growth is the real consumer and needs entry-level retention inside a ledger.
+- Operational hazard found while aligning the plugin tree: with `~/.omp/plugins` pinning `@oh-my-pi/pi-coding-agent` at 18.11.0 instead of 18.7.0, one measurement session logged a `session_start` timeout again, and reverting the pin cleared it (6 sessions clean at 18.7.0). Fabric eagerly imports host tool subpaths, which the tree resolves to raw TypeScript, so the tree's host pin changes the extension's own load cost. Making those imports lazy is the prerequisite for moving that pin.
+
 ## 1.25.28
 
 ### Fixed

package/dist/compaction/lcm-runtime.js

@@ -59,11 +59,51 @@ import crypto from "node:crypto";
 
 // src/storage/lcm-directory.ts
 import fs from "node:fs";
+import os from "node:os";
 import path from "node:path";
 var DIRECTORY_FILE = "projects.json";
 var DIRECTORY_VERSION = 1;
 var SWEEP_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var RETENTION_MS = 30 * 24 * 60 * 60 * 1e3;
+var TEMP_RETENTION_MS = 2 * 24 * 60 * 60 * 1e3;
+var tempRootCandidates = () => {
+  const roots = /* @__PURE__ */ new Set();
+  for (const root of [os.tmpdir(), "/tmp", "/var/tmp"]) {
+    const resolved = path.resolve(root);
+    roots.add(resolved);
+    try {
+      roots.add(fs.realpathSync.native(resolved));
+    } catch {
+    }
+  }
+  return [...roots];
+};
+var isUnderTempRoot = (target) => {
+  const resolved = path.resolve(target);
+  const candidates = /* @__PURE__ */ new Set([resolved]);
+  try {
+    candidates.add(fs.realpathSync.native(resolved));
+  } catch {
+    let probe = resolved;
+    while (true) {
+      const parent = path.dirname(probe);
+      if (parent === probe) break;
+      probe = parent;
+      try {
+        const real = fs.realpathSync.native(probe);
+        candidates.add(path.join(real, path.relative(probe, resolved)));
+        break;
+      } catch {
+      }
+    }
+  }
+  const normalize = (value) => process.platform === "win32" ? value.toLowerCase() : value;
+  const normalized = [...candidates].map(normalize);
+  return tempRootCandidates().some((root) => {
+    const base = normalize(root.endsWith(path.sep) ? root.slice(0, -1) : root);
+    return normalized.some((candidate) => candidate === base || candidate.startsWith(base + path.sep));
+  });
+};
 var empty = () => ({ version: DIRECTORY_VERSION, sweptAt: 0, projects: [] });
 var directoryFile = (rootDir) => path.join(rootDir, DIRECTORY_FILE);
 var read = (rootDir) => {
@@ -112,6 +152,7 @@ var stableProjectKey = (rootDir, identity, now = Date.now()) => {
 var sweepLedgers = (rootDir, options) => {
   const now = options.now ?? Date.now();
   const retentionMs = options.retentionMs ?? RETENTION_MS;
+  const tempRetentionMs = options.tempRetentionMs ?? TEMP_RETENTION_MS;
   const file = read(rootDir);
   if (!options.force && now - file.sweptAt < SWEEP_INTERVAL_MS) return { removed: [], bytes: 0, skipped: true };
   const removed = [];
@@ -123,9 +164,12 @@ var sweepLedgers = (rootDir, options) => {
     try {
       stats = fs.statSync(ledger);
     } catch {
+      if (record2.key !== options.keepKey) continue;
+      kept.push(record2);
       continue;
     }
-    const abandoned = record2.key !== options.keepKey && !fs.existsSync(record2.path) && now - Math.max(stats.mtimeMs, record2.updatedAt) >= retentionMs;
+    const retention = isUnderTempRoot(record2.path) ? tempRetentionMs : retentionMs;
+    const abandoned = record2.key !== options.keepKey && !fs.existsSync(record2.path) && now - Math.max(stats.mtimeMs, record2.updatedAt) >= retention;
     if (!abandoned) {
       kept.push(record2);
       continue;