@event4u/agent-config 17.0.0 → 17.2.0

package/dist/install/installThinLayer.js

@@ -157,6 +157,7 @@ export function thinInstalledRuleLayer(opts) {
         try {
             if (next !== installed) {
                 fs.writeFileSync(target, next, 'utf-8');
+                opts.onWrite?.(target);
                 rewritten += 1;
             }
             thinned += 1;

package/dist/install/loggedWrites.js

@@ -0,0 +1,142 @@
+/**
+ * The install transaction log read as an ownership record.
+ *
+ * WHY. The writer preserves any managed file it cannot prove is still the bytes
+ * it wrote. For a file deployed before the ownership ledger recorded digests,
+ * the ledger has nothing to compare against, so EVERY such file was preserved
+ * and a sidecar staged beside it — thousands of them on one upgrade, all
+ * untouched. Worse, the ledger then records the staged digest for each target,
+ * so the next run calls the same untouched file "user-modified".
+ *
+ * The proof was on disk the whole time. `src/scripts/install.ts` appends a
+ * `write` entry carrying the SHA-256 of the target's bytes immediately after
+ * every copy. A file whose bytes equal a digest the log records this installer
+ * writing to that exact path is the installer's own output, unedited. A path
+ * with no matching record keeps the existing answer. WHEN that proof may decide
+ * is narrower than "whenever it matches" — see `decideDeployWrite`.
+ *
+ * WHAT IS READ. The active log and every rotated sibling, plain or gzipped
+ * (`txlog.ts` rotates at 10 MB or 30 days, and the gzip step can leave both
+ * forms behind). An unreadable or truncated file contributes nothing — the
+ * failure direction is "no proof", which preserves.
+ *
+ * COST. Parsed per FILE and cached on that file's size and mtime. A rotated
+ * archive never changes, so only the active log is re-read when it grows — and
+ * an install appends to it after every file it touches, so a cache keyed on the
+ * whole set would re-parse the entire history once per candidate.
+ */
+import { gunzipSync } from 'node:zlib';
+import { existsSync, readdirSync, readFileSync, realpathSync, statSync } from 'node:fs';
+import { basename, dirname, join, relative, resolve, sep } from 'node:path';
+import { getLogPath } from './paths.js';
+const WRITE_MARKER = '"kind":"write"';
+const fileCache = new Map();
+const dirRealpaths = new Map();
+/**
+ * One canonical spelling for a path: its directory realpath'd, its basename
+ * kept. Both the log keys and the queries go through it, so `/var/…` and its
+ * macOS realpath twin meet. The directory is realpath'd rather than the file
+ * because the file may not exist, and is memoised because a log names a few
+ * hundred directories across tens of thousands of entries.
+ */
+export function canonicalPath(p) {
+    const abs = resolve(p);
+    const dir = dirname(abs);
+    let real = dirRealpaths.get(dir);
+    if (real === undefined) {
+        try {
+            real = realpathSync(dir);
+        }
+        catch {
+            real = dir;
+        }
+        dirRealpaths.set(dir, real);
+    }
+    return join(real, basename(abs));
+}
+/** The active log plus its rotated siblings, sorted by name. */
+function logFiles(logPath) {
+    const dir = dirname(logPath);
+    if (!existsSync(dir))
+        return [];
+    const stem = basename(logPath).replace(/\.jsonl$/, '');
+    try {
+        return readdirSync(dir)
+            .filter((n) => n.startsWith(stem) && (n.endsWith('.jsonl') || n.endsWith('.jsonl.gz')))
+            .map((n) => join(dir, n))
+            .sort();
+    }
+    catch {
+        return [];
+    }
+}
+function writesIn(file) {
+    let stamp;
+    try {
+        const st = statSync(file);
+        stamp = `${st.size}:${Math.trunc(st.mtimeMs)}`;
+    }
+    catch {
+        return [];
+    }
+    const cached = fileCache.get(file);
+    if (cached !== undefined && cached.stamp === stamp)
+        return cached.entries;
+    let text = '';
+    try {
+        const raw = readFileSync(file);
+        text = (file.endsWith('.gz') ? gunzipSync(raw) : raw).toString('utf8');
+    }
+    catch {
+        text = '';
+    }
+    const entries = [];
+    for (const line of text.split('\n')) {
+        if (!line.includes(WRITE_MARKER))
+            continue;
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof entry.path !== 'string' || typeof entry.sha256 !== 'string' || entry.sha256 === '')
+            continue;
+        entries.push([canonicalPath(entry.path), entry.sha256]);
+    }
+    fileCache.set(file, { stamp, entries });
+    return entries;
+}
+/** Every `write` the transaction log records, keyed by canonical path. */
+export function loggedWriteDigests(logPath = getLogPath()) {
+    const writes = new Map();
+    for (const file of logFiles(logPath)) {
+        for (const [target, sha] of writesIn(file)) {
+            let set = writes.get(target);
+            if (set === undefined)
+                writes.set(target, (set = new Set()));
+            set.add(sha);
+        }
+    }
+    return writes;
+}
+/**
+ * Wrap a log writer so it records only paths this run's copy deploys.
+ *
+ * The claude-code rewrite and thinning passes walk the whole rule directory,
+ * including rules the user authored there; logging those rewrites would make
+ * the log vouch for content that was never the package's.
+ */
+export function onlyDeployed(anchor, currentFiles, log) {
+    return (target) => {
+        const rel = relative(resolve(anchor), resolve(target)).split(sep).join('/');
+        if (currentFiles.has(rel))
+            log(target);
+    };
+}
+/** Did this installer write exactly `onDiskSha256` to `target`? */
+export function wroteTheseBytes(target, onDiskSha256, writes) {
+    return writes.get(canonicalPath(target))?.has(onDiskSha256) === true;
+}
+//# sourceMappingURL=loggedWrites.js.map

package/dist/install/paths.js

@@ -61,12 +61,22 @@ export function getInstallRoot(home) {
     return join(resolveHome(home), INSTALL_ROOT_SUBPATH);
 }
 /**
- * Absolute path to the active transaction log:
- * `~/.event4u/agent-config/install-log.jsonl`.
+ * Absolute path to the active transaction log: `install-log.jsonl` in
+ * `$EVENT4U_CONFIG_HOME` when that is set and no explicit `home` is given,
+ * otherwise in `~/.event4u/agent-config/`.
  *
  * Phase A4 writers append here on every successful atomic rename.
+ *
+ * Without the variable, the hermetic test environment — which sets only that
+ * variable — appended every test install to the real user's log, and the log
+ * is now read back as ownership proof. A history written under the other root
+ * before a user switched roots is not read; the failure direction is "no
+ * proof", which preserves.
  */
 export function getLogPath(home) {
+    const configHome = home ? undefined : process.env['EVENT4U_CONFIG_HOME'];
+    if (configHome)
+        return join(configHome, INSTALL_LOG_FILENAME);
     return join(getInstallRoot(home), INSTALL_LOG_FILENAME);
 }
 /**

package/dist/install/preserve.js

@@ -80,7 +80,7 @@ export const EXIT_COMPLETED_WITH_CONFLICTS = 3;
  * behaviour stands rather than being changed on a case nobody reasoned about.
  */
 export function isLedgerMigration(inputs) {
-    if (!inputs.exists || inputs.force)
+    if (!inputs.exists || inputs.force || inputs.loggedWrite === true)
         return false;
     if (inputs.ledgerListed !== true)
         return false;
@@ -88,12 +88,31 @@ export function isLedgerMigration(inputs) {
         return false;
     return classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256) === 'unknown';
 }
+/**
+ * May the transaction-log proof decide this target? Only where the verdict
+ * would otherwise be a preservation the record cannot justify: a ledger-listed
+ * file with no digest (the migration branch), or a `recorded-modified` file
+ * whose recorded digest is a staged one. Everywhere else the log is not read —
+ * the ledger alone already decides, and a genuine edit must stay preserved.
+ */
+export function logProofApplies(inputs) {
+    if (!inputs.exists || inputs.force || inputs.onDiskSha256 === null)
+        return false;
+    const ownership = classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256);
+    if (ownership === 'recorded-modified')
+        return inputs.recordedIsStaged === true;
+    // `loggedWrite` is cleared because `isLedgerMigration` excludes a proven
+    // target, and this asks whether the target is a candidate BEFORE the proof.
+    return ownership === 'unknown' && isLedgerMigration({ ...inputs, loggedWrite: false });
+}
 /**
  * Decide whether the writer may replace one managed file.
  *
- * A target that does not exist is written. A forced run writes. Otherwise the
- * recorded-ownership verdict decides: `recorded-modified` preserves, and
- * `recorded-unchanged` writes.
+ * A target that does not exist is written. A forced run writes. A target whose
+ * bytes the transaction log records this installer writing there is written
+ * where {@link logProofApplies} — there is no edit to lose. Otherwise the
+ * recorded-ownership verdict decides:
+ * `recorded-modified` preserves, and `recorded-unchanged` writes.
  *
  * The `unknown` arm is the one worth stating out loud. No recorded digest
  * means no divergence to measure — a tree with no manifest, a global anchor
@@ -118,6 +137,8 @@ export function decideDeployWrite(inputs) {
         return 'write';
     if (inputs.force)
         return 'write';
+    if (inputs.loggedWrite === true && logProofApplies(inputs))
+        return 'write';
     const ownership = classifyOwnership(inputs.recordedSha256, inputs.onDiskSha256);
     if (ownership === 'recorded-modified')
         return 'preserve';

package/dist/install/txlog.js

@@ -6,14 +6,18 @@
  * nothing is un-written automatically. No PID lockfile (per Phase-A4
  * decision 8).
  *
- * WHAT ACTUALLY WRITES THIS FILE, as of 2026-09-15: two call sites.
- * `src/server/routes/install.ts`'s recovery-dismiss handler appends a
- * `rollback` marker with an empty path and a null hash; `src/scripts/install.ts`
- * — the surviving headless writer, per-file, through `_log_tx_entry` — appends
- * a `write` or `skip` entry per copied/skipped path during
- * `_copy_dir_dereferencing_symlinks`. Both call `appendTxLog` directly, so the
+ * WHAT ACTUALLY WRITES THIS FILE: `src/server/routes/install.ts`'s
+ * recovery-dismiss handler appends a `rollback` marker with an empty path and a
+ * null hash; `src/scripts/install.ts`, through `_log_tx_entry`, appends a
+ * `write` or `skip` entry per path it copies, preserves or stages a sidecar
+ * for, and a `write` entry per deployed Claude rule the host-form rewrite and
+ * the thinning pass rewrite after the copy. All call `appendTxLog`, so the
  * entry shape is identical by construction rather than by convention.
  *
+ * WHAT READS IT: recovery (the active log only) and `./loggedWrites.ts`, which
+ * reads every `write` digest in the active log AND its rotated siblings as
+ * proof that bytes on disk are the installer's own output.
+ *
  * Rotation: 10 MB OR 30 days, whichever first. Rotated copies move to
  * `install-log.<ISO>.jsonl.gz` siblings; recovery never scans them.
  *

package/dist/mcp/registry-manifest.json

@@ -1,15 +1,15 @@
 {
   "discovery": {
-    "artefact_count": 636,
+    "artefact_count": 637,
     "scanner_version": "de0a22b4ac4c"
   },
-  "generated_at": "2026-10-22",
+  "generated_at": "2026-10-23",
   "package": {
     "description": "Governed skills, rules and commands for AI coding tools (Claude Code, Cursor, Windsurf, Copilot) \u2014 every claim machine-checked, including the artifact counts in these badges.",
     "homepage": "https://event4u-app.github.io/agent-config",
     "name": "@event4u/agent-config",
     "repository": "https://github.com/event4u-app/agent-config",
-    "version": "17.0.0"
+    "version": "17.2.0"
   },
   "registries": [
     {

package/dist/mcp/server.json

@@ -9,12 +9,12 @@
       "transport": {
         "type": "stdio"
       },
-      "version": "17.0.0"
+      "version": "17.2.0"
     }
   ],
   "repository": {
     "source": "github",
     "url": "https://github.com/event4u-app/agent-config"
   },
-  "version": "17.0.0"
+  "version": "17.2.0"
 }