@event4u/agent-config 16.5.0 → 17.1.0

package/dist/hooks/egress_engine.chunk.cjs.sha256

@@ -0,0 +1 @@
+0c82cec5dc2b455a8a7cac5d119d84b800cfd1df56c6e50fa3fb692c69a70312  egress_engine.chunk.cjs

package/dist/hooks/svg_rules.chunk.cjs

@@ -1,3 +1,4 @@
+const __acChunkMetaUrl = require('node:url').pathToFileURL(__filename).href; const __acChunkMeta = { url: __acChunkMetaUrl, dirname: __dirname, filename: __filename };
 "use strict";
 var __defProp = Object.defineProperty;
 var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
@@ -223,55 +224,6 @@ function parseDocument(content) {
   return { roots, elements, errors };
 }
 
-// src/scripts/_lib/svg_urls.ts
-function svgPrefixes(content) {
-  const out = /* @__PURE__ */ new Set();
-  const re = /xmlns:([\w.-]+)\s*=\s*["']http:\/\/www\.w3\.org\/2000\/svg["']/gi;
-  let m;
-  while ((m = re.exec(content)) !== null) out.add((m[1] ?? "").toLowerCase());
-  return out;
-}
-function localName(name, prefixes) {
-  const colon = name.indexOf(":");
-  return colon !== -1 && prefixes.has(name.slice(0, colon)) ? name.slice(colon + 1) : name;
-}
-function rawAttrs(raw) {
-  const out = {};
-  const re = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>"'`=]+))/g;
-  let m;
-  while ((m = re.exec(raw)) !== null) out[(m[1] ?? "").toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? "";
-  return out;
-}
-var URL_ATTRS = /* @__PURE__ */ new Set(["href", "xlink:href", "src"]);
-var isActiveUrl = (raw) => /^(javascript:|data:text\/html)/i.test(resolvedUrl(raw));
-var NAMED_URL_ENTITIES = {
-  colon: ":",
-  sol: "/",
-  tab: "	",
-  newline: "\n",
-  period: ".",
-  lpar: "(",
-  rpar: ")",
-  amp: "&"
-};
-function resolvedUrl(raw) {
-  const decoded = raw.replace(/&(?:#x([0-9a-f]+)|#(\d+)|([a-z]+));?/gi, (m, hex, dec, name) => {
-    const cp = hex ? parseInt(hex, 16) : dec ? parseInt(dec, 10) : NaN;
-    if (!Number.isNaN(cp)) return cp <= 1114111 ? String.fromCodePoint(cp) : m;
-    return NAMED_URL_ENTITIES[name.toLowerCase()] ?? m;
-  });
-  return decoded.replace(/^[\u0000- ]+|[\u0000- ]+$/g, "").replace(/[\t\n\r]/g, "");
-}
-function cssUnescape(raw) {
-  return raw.replace(/\\([0-9a-f]{1,6})\s?|\\(.)/gi, (m, hex, ch) => {
-    if (hex) {
-      const cp = parseInt(hex, 16);
-      return cp <= 1114111 ? String.fromCodePoint(cp) : m;
-    }
-    return ch;
-  });
-}
-
 // src/scripts/_lib/svg_geometry.ts
 function staticBox(el) {
   if (el.attrs["transform"] || el.attrs["style"]?.includes("transform")) return null;
@@ -604,6 +556,285 @@ function pathDataError(d) {
   return null;
 }
 
+// src/scripts/_lib/svg_filled_counter.ts
+var CURVE_STEPS = 12;
+var MAX_SUBPATHS = 400;
+function styleProp(el, prop) {
+  const direct = el.attrs[prop];
+  if (direct !== void 0) return direct.trim();
+  const m = new RegExp(`(?:^|;)\\s*${prop}\\s*:\\s*([^;]+)`, "i").exec(el.attrs["style"] ?? "");
+  return m?.[1]?.trim();
+}
+function arcPoints(from, args) {
+  const [rxIn, ryIn, rotDeg, large, sweep, x, y] = args;
+  const [x1, y1] = from;
+  let rx = Math.abs(rxIn);
+  let ry = Math.abs(ryIn);
+  if (rx === 0 || ry === 0 || x1 === x && y1 === y) return [[x, y]];
+  const phi = rotDeg * Math.PI / 180;
+  const cos = Math.cos(phi);
+  const sin = Math.sin(phi);
+  const dx = (x1 - x) / 2;
+  const dy = (y1 - y) / 2;
+  const xp = cos * dx + sin * dy;
+  const yp = -sin * dx + cos * dy;
+  const lambda = xp * xp / (rx * rx) + yp * yp / (ry * ry);
+  if (lambda > 1) {
+    rx *= Math.sqrt(lambda);
+    ry *= Math.sqrt(lambda);
+  }
+  const num = rx * rx * ry * ry - rx * rx * yp * yp - ry * ry * xp * xp;
+  const den = rx * rx * yp * yp + ry * ry * xp * xp;
+  const coef = (large === sweep ? -1 : 1) * Math.sqrt(Math.max(0, num / den));
+  const cxp = coef * rx * yp / ry;
+  const cyp = -coef * ry * xp / rx;
+  const cx = cos * cxp - sin * cyp + (x1 + x) / 2;
+  const cy = sin * cxp + cos * cyp + (y1 + y) / 2;
+  const angle = (ux, uy, vx, vy) => {
+    const a = Math.atan2(ux * vy - uy * vx, ux * vx + uy * vy);
+    return a;
+  };
+  const t1 = angle(1, 0, (xp - cxp) / rx, (yp - cyp) / ry);
+  let dt = angle((xp - cxp) / rx, (yp - cyp) / ry, (-xp - cxp) / rx, (-yp - cyp) / ry);
+  if (!sweep && dt > 0) dt -= 2 * Math.PI;
+  if (sweep && dt < 0) dt += 2 * Math.PI;
+  const out = [];
+  for (let k = 1; k <= CURVE_STEPS; k++) {
+    const t = t1 + dt * k / CURVE_STEPS;
+    const ex = rx * Math.cos(t);
+    const ey = ry * Math.sin(t);
+    out.push([cos * ex - sin * ey + cx, sin * ex + cos * ey + cy]);
+  }
+  return out;
+}
+function bezier(p0, p1, p2, p3) {
+  const out = [];
+  for (let k = 1; k <= CURVE_STEPS; k++) {
+    const t = k / CURVE_STEPS;
+    const u = 1 - t;
+    out.push([
+      u * u * u * p0[0] + 3 * u * u * t * p1[0] + 3 * u * t * t * p2[0] + t * t * t * p3[0],
+      u * u * u * p0[1] + 3 * u * u * t * p1[1] + 3 * u * t * t * p2[1] + t * t * t * p3[1]
+    ]);
+  }
+  return out;
+}
+function subpathPolygons(d) {
+  const tokens = tokenisePath(d);
+  if (tokens === null) return null;
+  const ARGS = { m: 2, l: 2, t: 2, h: 1, v: 1, c: 6, s: 4, q: 4, a: 7, z: 0 };
+  const polys = [];
+  let poly = [];
+  let cur = [0, 0];
+  let start = [0, 0];
+  let lastCtrl = null;
+  let lastQuad = null;
+  let i = 0;
+  let cmd = "";
+  const flush = () => {
+    if (poly.length >= 3) polys.push(poly);
+    poly = [];
+  };
+  while (i < tokens.length) {
+    const tok = tokens[i];
+    if (/^[a-zA-Z]$/.test(tok)) {
+      cmd = tok;
+      i += 1;
+      if (cmd.toLowerCase() === "z") {
+        cur = start;
+        lastCtrl = lastQuad = null;
+        flush();
+        continue;
+      }
+      if (i >= tokens.length) break;
+      continue;
+    }
+    const lower = cmd.toLowerCase();
+    const n = ARGS[lower];
+    if (n === void 0 || n === 0) return null;
+    const a = tokens.slice(i, i + n).map(Number);
+    if (a.length < n || a.some((v) => !Number.isFinite(v))) return null;
+    i += n;
+    const rel = cmd !== cmd.toUpperCase();
+    const ox = rel ? cur[0] : 0;
+    const oy = rel ? cur[1] : 0;
+    const at = (k) => [a[k] + ox, a[k + 1] + oy];
+    let next = cur;
+    let pts = [];
+    let ctrl = null;
+    let quad = null;
+    switch (lower) {
+      case "m":
+        flush();
+        next = at(0);
+        start = next;
+        pts = [next];
+        cmd = rel ? "l" : "L";
+        break;
+      case "l":
+        next = at(0);
+        pts = [next];
+        break;
+      case "h":
+        next = [a[0] + ox, cur[1]];
+        pts = [next];
+        break;
+      case "v":
+        next = [cur[0], a[0] + oy];
+        pts = [next];
+        break;
+      case "c":
+        ctrl = at(2);
+        next = at(4);
+        pts = bezier(cur, at(0), ctrl, next);
+        break;
+      case "s": {
+        const c1 = lastCtrl ? [2 * cur[0] - lastCtrl[0], 2 * cur[1] - lastCtrl[1]] : cur;
+        ctrl = at(0);
+        next = at(2);
+        pts = bezier(cur, c1, ctrl, next);
+        break;
+      }
+      case "q":
+      case "t": {
+        const q = lower === "q" ? at(0) : lastQuad ? [2 * cur[0] - lastQuad[0], 2 * cur[1] - lastQuad[1]] : cur;
+        next = lower === "q" ? at(2) : at(0);
+        quad = q;
+        const c1 = [cur[0] + 2 / 3 * (q[0] - cur[0]), cur[1] + 2 / 3 * (q[1] - cur[1])];
+        const c2 = [next[0] + 2 / 3 * (q[0] - next[0]), next[1] + 2 / 3 * (q[1] - next[1])];
+        pts = bezier(cur, c1, c2, next);
+        break;
+      }
+      case "a":
+        next = [a[5] + ox, a[6] + oy];
+        pts = arcPoints(cur, [a[0], a[1], a[2], a[3], a[4], next[0], next[1]]);
+        break;
+    }
+    poly.push(...pts);
+    cur = next;
+    lastCtrl = ctrl;
+    lastQuad = quad;
+    if (polys.length > MAX_SUBPATHS) return polys;
+  }
+  flush();
+  return polys;
+}
+function signedArea(poly) {
+  let s = 0;
+  for (let k = 0; k < poly.length; k++) {
+    const [x1, y1] = poly[k];
+    const [x2, y2] = poly[(k + 1) % poly.length];
+    s += x1 * y2 - x2 * y1;
+  }
+  return s / 2;
+}
+function inside(pt, poly) {
+  let hit = false;
+  for (let k = 0, j = poly.length - 1; k < poly.length; j = k++) {
+    const [xi, yi] = poly[k];
+    const [xj, yj] = poly[j];
+    if (yi > pt[1] !== yj > pt[1] && pt[0] < (xj - xi) * (pt[1] - yi) / (yj - yi) + xi) hit = !hit;
+  }
+  return hit;
+}
+function filledCounters(elements) {
+  const out = [];
+  const stack = [];
+  for (const el of elements) {
+    if (el.closing) {
+      const at = stack.map((s) => s.name).lastIndexOf(el.name);
+      if (at >= 0) stack.length = at;
+      continue;
+    }
+    const parent = stack[stack.length - 1];
+    const rule = styleProp(el, "fill-rule") ?? parent?.rule;
+    const fill = styleProp(el, "fill") ?? parent?.fill;
+    if (!el.selfClosing) stack.push({ name: el.name, rule, fill });
+    if (el.name !== "path") continue;
+    if ((rule ?? "nonzero").toLowerCase() === "evenodd" || (fill ?? "").toLowerCase() === "none") continue;
+    const polys = subpathPolygons(el.attrs["d"] ?? "");
+    if (polys === null || polys.length < 2 || polys.length > MAX_SUBPATHS) continue;
+    const areas = polys.map(signedArea);
+    for (let inner = 0; inner < polys.length; inner++) {
+      const ia = areas[inner];
+      if (Math.abs(ia) < 1e-9) continue;
+      let around = 0;
+      let nearest = -1;
+      for (let outer = 0; outer < polys.length; outer++) {
+        if (outer === inner) continue;
+        const oa = areas[outer];
+        if (Math.abs(oa) <= Math.abs(ia)) continue;
+        const op = polys[outer];
+        if (!polys[inner].every((p) => inside(p, op))) continue;
+        around += Math.sign(oa);
+        if (nearest < 0 || Math.abs(oa) < Math.abs(areas[nearest])) nearest = outer;
+      }
+      if (around !== 0 && Math.sign(around) === Math.sign(ia)) {
+        out.push({ element: el, inner: inner + 1, outer: nearest + 1 });
+      }
+    }
+  }
+  return out;
+}
+function ruleFilledCounter(elements, file) {
+  return filledCounters(elements).map((c) => ({
+    rule: "svg-structure-filled-counter",
+    file,
+    line: c.element.line,
+    snippet: `<path> subpath ${c.inner} sits inside subpath ${c.outer} with the same winding under nonzero, so the counter paints \u2014 wind the inner contour the other way, or declare fill-rule="evenodd"`,
+    severity: "warning"
+  }));
+}
+
+// src/scripts/_lib/svg_urls.ts
+function svgPrefixes(content) {
+  const out = /* @__PURE__ */ new Set();
+  const re = /xmlns:([\w.-]+)\s*=\s*["']http:\/\/www\.w3\.org\/2000\/svg["']/gi;
+  let m;
+  while ((m = re.exec(content)) !== null) out.add((m[1] ?? "").toLowerCase());
+  return out;
+}
+function localName(name, prefixes) {
+  const colon = name.indexOf(":");
+  return colon !== -1 && prefixes.has(name.slice(0, colon)) ? name.slice(colon + 1) : name;
+}
+function rawAttrs(raw) {
+  const out = {};
+  const re = /([\w:.-]+)\s*=\s*(?:"([^"]*)"|'([^']*)'|([^\s>"'`=]+))/g;
+  let m;
+  while ((m = re.exec(raw)) !== null) out[(m[1] ?? "").toLowerCase()] = m[2] ?? m[3] ?? m[4] ?? "";
+  return out;
+}
+var URL_ATTRS = /* @__PURE__ */ new Set(["href", "xlink:href", "src"]);
+var isActiveUrl = (raw) => /^(javascript:|data:text\/html)/i.test(resolvedUrl(raw));
+var NAMED_URL_ENTITIES = {
+  colon: ":",
+  sol: "/",
+  tab: "	",
+  newline: "\n",
+  period: ".",
+  lpar: "(",
+  rpar: ")",
+  amp: "&"
+};
+function resolvedUrl(raw) {
+  const decoded = raw.replace(/&(?:#x([0-9a-f]+)|#(\d+)|([a-z]+));?/gi, (m, hex, dec, name) => {
+    const cp = hex ? parseInt(hex, 16) : dec ? parseInt(dec, 10) : NaN;
+    if (!Number.isNaN(cp)) return cp <= 1114111 ? String.fromCodePoint(cp) : m;
+    return NAMED_URL_ENTITIES[name.toLowerCase()] ?? m;
+  });
+  return decoded.replace(/^[\u0000- ]+|[\u0000- ]+$/g, "").replace(/[\t\n\r]/g, "");
+}
+function cssUnescape(raw) {
+  return raw.replace(/\\([0-9a-f]{1,6})\s?|\\(.)/gi, (m, hex, ch) => {
+    if (hex) {
+      const cp = parseInt(hex, 16);
+      return cp <= 1114111 ? String.fromCodePoint(cp) : m;
+    }
+    return ch;
+  });
+}
+
 // src/scripts/_lib/svg_motion.ts
 var SMIL_TAGS = /* @__PURE__ */ new Set([
   "animate",
@@ -1462,6 +1693,7 @@ function scanSvg(content, relPath, opts = {}) {
     ...ruleMissingXmlns(elements, relPath),
     ...ruleOutsideViewBox(elements, relPath),
     ...ruleUnparseablePath(elements, relPath),
+    ...ruleFilledCounter(elements, relPath),
     ...ruleUnusedDefs(text, elements, relPath),
     ...ruleDanglingReference(text, elements, relPath),
     ...ruleActiveContent(text, elements, relPath, mode),

package/dist/hooks/svg_rules.chunk.cjs.sha256

@@ -1 +1 @@
-6c7684dad7cebd6cd6c0301dbd3786451f5697f78be16bcc4223f2596689cb74  svg_rules.chunk.cjs
+4f7974e0505d035deb48babbf569362d8d3b09abede59f4e18f16ac8ced6ab40  svg_rules.chunk.cjs

package/dist/install/claudeRuleRewrite.js

@@ -46,6 +46,9 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
 import { _claude_paths_plan } from './claudePathsPlan.js';
+// Re-exported for `install.ts`, which sits past the source-size ceiling and so
+// reaches it through the namespace it already imports instead of a new line.
+export { onlyDeployed } from './loggedWrites.js';
 import { parseFrontmatter } from './ruleInScope.js';
 /**
  * Frontmatter keys the rewrite must carry across, and why each one.
@@ -109,8 +112,8 @@ export function _withPreservedKeys(rendered, original) {
  * extraction and never up through a baseline raise. So the caller gets one call
  * and a list of strings.
  */
-export function rewriteAndReport(rulesDir, quiet, info, warn, wrappers, preserved = new Set()) {
-    const result = rewriteClaudeRules(rulesDir, preserved);
+export function rewriteAndReport(rulesDir, quiet, info, warn, wrappers, preserved = new Set(), onWrite) {
+    const result = rewriteClaudeRules(rulesDir, preserved, onWrite);
     // The flat-command wrapper report rides along rather than sitting at the
     // call site: `install.ts` is thousands of lines past
     // `check_source_size_budget`'s ceiling, and this module is the one place
@@ -205,8 +208,11 @@ export function renderClaudeRule(sourceText) {
  * disappearing from the frontmatter.
  *
  * Returns counts rather than printing. The caller owns the reporting surface.
+ * `onWrite` receives each rewritten path, so the installer can log it: the
+ * transaction log is read back as proof the bytes on disk are ours, and a
+ * write it never saw would leave every rewritten rule unprovable.
  */
-export function rewriteClaudeRules(rulesDir, preserved = new Set()) {
+export function rewriteClaudeRules(rulesDir, preserved = new Set(), onWrite) {
     const result = { rewritten: 0, scoped: [], dropped: [], failed: [] };
     let entries;
     try {
@@ -258,6 +264,7 @@ export function rewriteClaudeRules(rulesDir, preserved = new Set()) {
                 });
                 continue;
             }
+            onWrite?.(full);
             result.rewritten += 1;
         }
         const stem = name.slice(0, -3);

package/dist/install/conflict.js

@@ -2,7 +2,7 @@
  * Conflict resolution — Phase A5 (simplified, three modes).
  *
  * Three decisions only, replacing the legacy `prompt → write / skip /
- * abort` triple from `scripts/install.py:_resolve_file_conflict`:
+ * abort` triple from `_resolve_file_conflict` in the retired Python installer:
  *
  * - `write`   — target either does not exist OR policy authorises overwrite.
  * - `skip`    — target exists, known path, not forced: leave it alone.
@@ -16,7 +16,9 @@
  */
 import { existsSync } from 'node:fs';
 import { sha256File } from './plan.js';
-import { classifyOwnership, recordedHashesForRoot, } from './recordedOwnership.js';
+import { loggedWriteDigests, wroteTheseBytes } from './loggedWrites.js';
+import { isLedgerMigration, logProofApplies, sidecarPathFor } from './preserve.js';
+import { classifyOwnership, ledgerListedPaths, recordedHashesWithLedger, } from './recordedOwnership.js';
 /**
  * Decide what to do with a single planned target.
  *
@@ -67,7 +69,7 @@ export function resolveFileConflict(inputs) {
 /**
  * Recursive object merge — overlay wins, nested dicts merged, arrays replaced.
  *
- * Mirrors `scripts/install.py:deep_merge`. Arrays do **not** concatenate;
+ * Mirrors `deep_merge` in the retired Python installer. Arrays do **not** concatenate;
  * Claude / Cursor / Cline hook configs rely on whole-array replacement to
  * stay idempotent across re-runs.
  *
@@ -159,15 +161,26 @@ export const CONFLICT_BATCH_THRESHOLD = 5;
  *   modified rows above and loses the unchanged ones below.
  *
  * `recorded` is injectable for tests; by default it is read from the
- * manifest at `plan.root`.
+ * manifest at `plan.root`, with the user-scoped ownership ledger laid over it.
+ * `logged` likewise; by default it is the install transaction log, opened only
+ * for an entry `logProofApplies` to.
  */
-export function computeConflicts(plan, recordedOverride) {
+export function computeConflicts(plan, recordedOverride, loggedOverride) {
     // Force returns before the manifest is read. As a default parameter the
     // map was built at call entry and discarded on the next line, so every
     // force-mode plan paid a read and a YAML parse for nothing.
     if (plan.policy.force)
         return [];
-    const recorded = recordedOverride ?? recordedHashesForRoot(plan.root);
+    const recorded = recordedOverride ?? recordedHashesWithLedger(plan.root);
+    // Read lazily and once: a pass over a tree whose ledger paths all carry
+    // digests never reaches the branch that needs this, and an unconditional
+    // read would charge every plan for an answer most of them discard.
+    let ledgerFiles = null;
+    let logged;
+    const ledgerLists = (p) => {
+        ledgerFiles ??= ledgerListedPaths();
+        return ledgerFiles.has(p);
+    };
     const out = [];
     for (const entries of Object.values(plan.filesByTool)) {
         for (const entry of entries) {
@@ -188,9 +201,47 @@ export function computeConflicts(plan, recordedOverride) {
             const ownership = classifyOwnership(recorded.get(entry.path), onDisk);
             if (ownership === 'recorded-unchanged')
                 continue;
+            // The writer's transaction-log proof, under the writer's own
+            // condition (`logProofApplies`): where it holds and the log records
+            // these bytes, the writer replaces the file, so the preview must
+            // not name it.
+            const recordedSha = recorded.get(entry.path);
+            const unproven = {
+                exists: true,
+                recordedSha256: recordedSha,
+                onDiskSha256: onDisk,
+                force: false,
+                ledgerListed: ledgerLists(entry.path),
+                recordedIsStaged: typeof recordedSha === 'string' && recordedSha === recorded.get(sidecarPathFor(entry.path)),
+            };
+            if (logProofApplies(unproven)) {
+                logged ??= loggedOverride ?? loggedWriteDigests();
+                if (wroteTheseBytes(entry.path, onDisk, logged))
+                    continue;
+            }
             if (ownership === 'unknown' && plan.policy.knownPaths.has(entry.path))
                 continue;
-            if (onDisk === entry.sha256)
+            // CANDIDACY, not the verdict, and it is computed BEFORE the
+            // equality short-circuit below rather than after. The migration
+            // branch preserves when the bytes differ from what the run WOULD
+            // write — source plus the install-time tag — while `entry.sha256`
+            // is the digest of the UNTAGGED source. The two comparisons are
+            // not the same for any tagged `.md`, which is most of the deployed
+            // tree, so a file that matches the untagged source can still be
+            // preserved by the writer. Short-circuiting first would make the
+            // preview silent about exactly those, and silence is the one
+            // answer a preview must not give about a file the install is
+            // going to keep. Only the writer can tag before hashing, so only
+            // the writer decides; this reports which entries take that path.
+            const migration = ownership === 'unknown' &&
+                isLedgerMigration({
+                    exists: true,
+                    recordedSha256: recorded.get(entry.path),
+                    onDiskSha256: onDisk,
+                    force: false,
+                    ledgerListed: ledgerLists(entry.path),
+                });
+            if (onDisk === entry.sha256 && !migration)
                 continue;
             out.push({
                 path: entry.path,
@@ -199,6 +250,7 @@ export function computeConflicts(plan, recordedOverride) {
                 existingSha256: onDisk,
                 mergeable: isJsonTarget(entry),
                 ownership,
+                migration,
             });
         }
     }

package/dist/install/conflictTracker.js

@@ -18,10 +18,12 @@
  */
 import * as crypto from 'node:crypto';
 import * as fs from 'node:fs';
+import * as os from 'node:os';
 import * as path from 'node:path';
 import { mkdirp, pathExists, resolvePath, sha256OfFile } from './fsPrimitives.js';
-import { EXIT_COMPLETED_WITH_CONFLICTS, conflictSummaryMessage, decideDeployWrite, foreignSidecarMessage, preservedFileMessage, sidecarPathFor, } from './preserve.js';
-import { recordedHashesForRoot } from './recordedOwnership.js';
+import { EXIT_COMPLETED_WITH_CONFLICTS, conflictSummaryMessage, decideDeployWrite, foreignSidecarMessage, isLedgerMigration, logProofApplies, migrationPreservedMessage, preservedFileMessage, sidecarPathFor, } from './preserve.js';
+import { loggedWriteDigests, wroteTheseBytes } from './loggedWrites.js';
+import { ledgerListedPaths, recordedHashesWithLedger } from './recordedOwnership.js';
 /**
  * Build a tracker bound to one installer's reporting surface.
  *
@@ -35,7 +37,10 @@ export function createConflictTracker(host) {
     const conflictState = {
         root: null,
         recorded: null,
+        ledgerFiles: null,
+        logged: null,
         preserved: [],
+        migrated: new Set(),
         staged: new Map(),
     };
     /**
@@ -56,13 +61,67 @@ export function createConflictTracker(host) {
     function recordedHashFor(target) {
         if (conflictState.root === null)
             return undefined;
-        conflictState.recorded ??= recordedHashesForRoot(conflictState.root);
+        conflictState.recorded ??= recordedHashesWithLedger(conflictState.root);
         const plain = path.resolve(target);
         if (conflictState.recorded.has(plain))
             return conflictState.recorded.get(plain);
         const real = resolvePath(target);
         return real === plain ? undefined : conflictState.recorded.get(real);
     }
+    /**
+     * Does the ownership ledger list this path, under either spelling?
+     *
+     * Both keys are tried for the reason `recordedHashFor` documents: on macOS
+     * the temp and home trees sit behind a realpath symlink that rewrites a
+     * `/var` prefix onto its private twin, so a single spelling misses every
+     * entry on the platform this is developed on.
+     */
+    function ledgerLists(target) {
+        conflictState.ledgerFiles ??= ledgerListedPaths();
+        const files = conflictState.ledgerFiles;
+        return files.has(path.resolve(target)) || files.has(resolvePath(target));
+    }
+    /**
+     * The digest of the bytes this run would write to `target`.
+     *
+     * Built into a temp file rather than hashed off the package source,
+     * because a deployed file is the package bytes PLUS the install-time tag
+     * and the two differ — comparing against the untagged source would call
+     * every up-to-date file divergent. The temp name carries the TARGET's
+     * extension because `tagDeployed` keys on it, the same constraint
+     * `stageInto` works around.
+     *
+     * `null` on any failure, which preserves: this is consulted only where
+     * nothing can be proven, and failing toward the recoverable direction is
+     * the whole point of the branch that calls it.
+     */
+    function wouldWriteDigest(target, would) {
+        // Under the OS temp dir, never beside the target: a host rule directory
+        // loads every `.md` in it, and a process killed before the unlink below
+        // would leave this file there to be loaded as a rule.
+        const tmp = path.join(os.tmpdir(), `agent-config-would.${process.pid}.${crypto.randomBytes(6).toString('hex')}${path.extname(target)}`);
+        try {
+            if ('content' in would) {
+                fs.writeFileSync(tmp, would.content, 'utf-8');
+            }
+            else {
+                fs.copyFileSync(would.from, tmp);
+                host.tagDeployed(tmp, would.from, would.packageRoot);
+            }
+            return sha256OfFile(tmp);
+        }
+        catch {
+            return null;
+        }
+        finally {
+            try {
+                fs.unlinkSync(tmp);
+            }
+            catch {
+                /* swallow — best-effort cleanup of our own temp file */
+            }
+        }
+    }
     /**
      * Produce the bytes this run would have written, then reconcile them with
      * whatever already sits at the sidecar path.
@@ -142,14 +201,20 @@ export function createConflictTracker(host) {
         if (conflictState.preserved.includes(target))
             return;
         conflictState.preserved.push(target);
-        host.warn(preservedFileMessage(target, sidecar));
+        host.warn(conflictState.migrated.has(path.resolve(target))
+            ? migrationPreservedMessage(target, sidecar)
+            : preservedFileMessage(target, sidecar));
     }
     return {
         conflictState,
+        recordedDigest: recordedHashFor,
         begin(root) {
             conflictState.root = root;
             conflictState.recorded = null;
+            conflictState.ledgerFiles = null;
+            conflictState.logged = null;
             conflictState.preserved = [];
+            conflictState.migrated = new Set();
             conflictState.staged = new Map();
         },
         /**
@@ -158,14 +223,34 @@ export function createConflictTracker(host) {
          * so a file edited between planning and writing is still classified
          * from the bytes that are actually about to be destroyed.
          */
-        resolve(target, force) {
+        resolve(target, force, would) {
             const exists = pathExists(target);
-            return decideDeployWrite({
+            const recordedSha256 = exists ? recordedHashFor(target) : undefined;
+            const unproven = {
                 exists,
-                recordedSha256: exists ? recordedHashFor(target) : undefined,
+                recordedSha256,
                 onDiskSha256: exists ? sha256OfFile(target) : null,
                 force,
-            });
+                ledgerListed: exists && ledgerLists(target),
+                recordedIsStaged: typeof recordedSha256 === 'string' && recordedSha256 === recordedHashFor(sidecarPathFor(target)),
+            };
+            // The log is opened only where the record alone would preserve
+            // without cause, and read once per run: this run's own appends
+            // cannot prove a file it has not reached yet.
+            const loggedWrite = logProofApplies(unproven) &&
+                wroteTheseBytes(target, unproven.onDiskSha256, (conflictState.logged ??= loggedWriteDigests()));
+            const base = { ...unproven, loggedWrite };
+            // The packaged digest costs a temp write and a tag, so it is
+            // computed only for the targets that can consume it. On a tree
+            // where every ledger-listed path carries a digest — which is every
+            // tree the ledger itself has written — this is false throughout
+            // and the run pays nothing.
+            const migrating = isLedgerMigration(base);
+            const decision = decideDeployWrite(migrating ? { ...base, packagedSha256: wouldWriteDigest(target, would) } : base);
+            if (decision === 'preserve' && migrating) {
+                conflictState.migrated.add(path.resolve(target));
+            }
+            return decision;
         },
         /**
          * Stage the package content beside a preserved target.