@izagood/avcs 0.31.2 → 0.32.0

package/dist/reducer/reducer.d.ts

@@ -29,6 +29,22 @@ export interface AutoDecision {
     rejectedOps: string[];
     reason: string;
     policyVersion: string;
+    /** Set when the decision settled one contended REGION of a file rather than a whole op
+     *  (docs/22 §3.3): the base line range `[baseStart, baseEnd)` the winner took. Together
+     *  with `key` and `chosenOp` this is the decision's idempotent identity — the same region
+     *  never mints a second record on a re-reduce. */
+    region?: {
+        baseStart: number;
+        baseEnd: number;
+    };
+    /** Per-option score breakdown, in option order: which option each op represented, the
+     *  score that represented it, and whether it was out of candidacy. Answers "why did my
+     *  change lose this region". Free — `evaluateOp` already computed all of it. */
+    optionScores?: {
+        opOid: string;
+        score: number;
+        excluded: boolean;
+    }[];
 }
 export interface ReductionResult {
     /** path → blobOid */
@@ -89,6 +105,10 @@ export interface FileConflict {
     file: string;
     ops: string[];
     regions: ConflictRegion[];
+    /** Binary/non-line-mergeable content: the whole file is ONE opaque contest and the
+     *  region's `sides` index distinct contents, not `ops`. Never arbitrated (docs/22 §3.1)
+     *  — side → op is not recoverable, so only a human can settle it. */
+    atomic?: boolean;
 }
 /**
  * Detect line-level merge conflicts among CONCURRENT accepted edit_file ops on the same
@@ -107,6 +127,29 @@ export interface FileConflict {
  * resolution is the identity and the buckets are exactly the declared paths, as before.
  */
 export declare function detectFileConflicts(ops: Operation[], result: ReductionResult, blobContent: Map<string, Buffer>): FileConflict[];
+/** The authoritative conflict set after region arbitration (docs/22 §3.4). */
+export interface FileConflictArbitration {
+    /** Files that still hold at least one region policy could not decide. A file whose every
+     *  region was decided drops out entirely — there is nothing left to ask. */
+    remaining: FileConflict[];
+    /** One {@link AutoDecision} per decided region (docs/22 §3.3). */
+    decisions: AutoDecision[];
+}
+/**
+ * Arbitrate the regions {@link detectFileConflicts} found — the authoritative pass, and the
+ * one place where side → op is exact: `FileConflict.ops` is the file's concurrent frontier in
+ * canonical order and `region.options[].sides` index straight into it.
+ *
+ * A decided region leaves the conflict set (policy decided it, so it is no longer a question
+ * for a human) and is recorded as an `AutoDecision` — an automatic decision without an audit
+ * trail is not allowed (docs/00 principle 4, at region granularity). An undecided region
+ * stays exactly as it was: the tree holds the deterministic fallback content and the conflict
+ * still reaches the release gate.
+ *
+ * Scores are lazy and memoized per op, so only the ops of a file that actually contended are
+ * ever evaluated (docs/22 R-c).
+ */
+export declare function arbitrateFileConflicts(fileConflicts: FileConflict[], input: ReduceInput): FileConflictArbitration;
 /** A single group's locally-decided statuses + the conflicts/autoDecisions it emitted. */
 export interface PerKeyDecision {
     local: Map<string, OperationStatus>;
@@ -164,4 +207,22 @@ export declare class NonIncrementalError extends Error {
 export declare function reduceIncremental(snap: ReduceSnapshot, next: ReduceInput): ReduceSnapshot;
 export declare function serializeSnapshot(snap: ReduceSnapshot): unknown;
 export declare function deserializeSnapshot(raw: unknown): ReduceSnapshot;
+/** One op's policy verdict, as region arbitration needs it (docs/22 §3.2). */
+export interface OpScore {
+    score: number;
+    /** Out of candidacy: a failed evidence gate, or a rule that reserves the call for a
+     *  human. An excluded op's content must never take a region — that exclusion is the
+     *  real effect of this whole track (docs/22 §3.2-3). */
+    excluded: boolean;
+}
+/** opOid → verdict. `undefined` for an op the scorer does not know, which makes
+ *  arbitration abstain rather than guess. */
+export type OpScorer = (opOid: string) => OpScore | undefined;
+/**
+ * Build an {@link OpScorer} from a bare `ReduceInput`, for a caller outside `reduce` — the
+ * authoritative post-reduce pass (`detectFileConflicts` → {@link arbitrateFileConflicts}).
+ * Evaluation is lazy and memoized per op, so only the ops of a file that actually contended
+ * are ever scored.
+ */
+export declare function buildOpScorer(input: ReduceInput): OpScorer;
 //# sourceMappingURL=reducer.d.ts.map

package/dist/reducer/reducer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/reducer/reducer.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"reducer.d.ts","sourceRoot":"","sources":["../../src/reducer/reducer.ts"],"names":[],"mappings":"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"}

package/dist/reducer/reducer.js

@@ -12,7 +12,7 @@
 import { sha256hex, canonicalize } from "../core/canonical.js";
 import { evaluateOp } from "./policy.js";
 import { buildAliasMap, resolvePath } from "./aliases.js";
-import { merge3 } from "../merge/merge3.js";
+import { merge3, diffHunks } from "../merge/merge3.js";
 import { ownersFor } from "../policy/owners.js";
 import { isBinary } from "../core/bytes.js";
 import { Buffer } from "node:buffer";
@@ -179,7 +179,7 @@ export function detectFileConflicts(ops, result, blobContent) {
                     options: distinct.map((text, i) => ({ sides: [i], text })),
                 },
             ];
-            out.push({ file, ops: ordered.map((o) => o.oid), regions });
+            out.push({ file, ops: ordered.map((o) => o.oid), regions, atomic: true });
             continue;
         }
         const base = baseBuf.toString("utf8");
@@ -190,6 +190,64 @@ export function detectFileConflicts(ops, result, blobContent) {
     }
     return out;
 }
+/**
+ * Arbitrate the regions {@link detectFileConflicts} found — the authoritative pass, and the
+ * one place where side → op is exact: `FileConflict.ops` is the file's concurrent frontier in
+ * canonical order and `region.options[].sides` index straight into it.
+ *
+ * A decided region leaves the conflict set (policy decided it, so it is no longer a question
+ * for a human) and is recorded as an `AutoDecision` — an automatic decision without an audit
+ * trail is not allowed (docs/00 principle 4, at region granularity). An undecided region
+ * stays exactly as it was: the tree holds the deterministic fallback content and the conflict
+ * still reaches the release gate.
+ *
+ * Scores are lazy and memoized per op, so only the ops of a file that actually contended are
+ * ever evaluated (docs/22 R-c).
+ */
+export function arbitrateFileConflicts(fileConflicts, input) {
+    if (fileConflicts.length === 0)
+        return { remaining: [], decisions: [] };
+    const scoreOf = buildOpScorer(input);
+    const remaining = [];
+    const decisions = [];
+    const seen = new Set(); // idempotent identity: key + region bounds + winner (R-d)
+    for (const fc of fileConflicts) {
+        if (fc.atomic) {
+            remaining.push(fc);
+            continue;
+        }
+        const key = `file:${fc.file}`;
+        const open = [];
+        for (const region of fc.regions) {
+            const sideOps = (side) => {
+                const oid = fc.ops[side];
+                return oid === undefined ? [] : [oid];
+            };
+            const v = judgeRegion(region, sideOps, scoreOf);
+            if (!v) {
+                open.push(region);
+                continue;
+            }
+            const idem = `${key}|${region.baseStart}|${region.baseEnd}|${v.chosen}`;
+            if (seen.has(idem))
+                continue;
+            seen.add(idem);
+            decisions.push({
+                key,
+                conflictId: conflictIdFor(key),
+                chosenOp: v.chosen,
+                rejectedOps: v.rejected,
+                reason: "region-arbitration",
+                policyVersion: input.policy.version,
+                region: { baseStart: region.baseStart, baseEnd: region.baseEnd },
+                optionScores: v.optionScores,
+            });
+        }
+        if (open.length)
+            remaining.push({ ...fc, regions: open });
+    }
+    return { remaining, decisions };
+}
 export function reduce(input) {
     return snapshotReduce(input).result;
 }
@@ -275,14 +333,15 @@ function frontier(ops, statuses, anc) {
                 covered.add(a);
     return [...acceptedIds].filter((id) => !covered.has(id));
 }
-function materializeProjection(ops, statuses, anc, materializeStatuses, blobContent) {
+function materializeProjection(ops, statuses, anc, materializeStatuses, blobContent, scoreOf) {
     const projected = ops.filter((o) => materializeStatuses.has(statuses.get(o.oid)));
     const ordered = kahnOrder(projected, anc);
     const alias = aliasCtxFor(projected, anc);
     const tree = new Map();
     const synthBlobs = new Map();
+    const arb = scoreOf ? { scoreOf, prov: new Map() } : undefined;
     for (const op of ordered)
-        applyOp(tree, op, blobContent, synthBlobs, alias);
+        applyOp(tree, op, blobContent, synthBlobs, alias, arb);
     return { tree, treeHash: treeHashOf(tree), headOps: frontier(ops, statuses, anc), synthBlobs: pruneSynth(tree, synthBlobs) };
 }
 /**
@@ -295,7 +354,7 @@ function materializeProjection(ops, statuses, anc, materializeStatuses, blobCont
  * Replayed ops only ever read/write dirty paths, so a fresh replay tree + clean base
  * entries reconstructs the full tree exactly. Equivalence is enforced by the A0 harness.
  */
-function materializeIncremental(ops, statuses, anc, materializeStatuses, blobContent, base, dirtyPaths) {
+function materializeIncremental(ops, statuses, anc, materializeStatuses, blobContent, base, dirtyPaths, scoreOf) {
     const projected = ops.filter((o) => materializeStatuses.has(statuses.get(o.oid)));
     const ordered = kahnOrder(projected, anc);
     // The alias map is a function of the WHOLE projected rename set, never of the dirty
@@ -309,9 +368,10 @@ function materializeIncremental(ops, statuses, anc, materializeStatuses, blobCon
     // dropped as dirty. `AVCS_VERIFY_INCREMENTAL=1` and the C22 cases gate it.
     const replayTree = new Map();
     const replaySynth = new Map();
+    const arb = scoreOf ? { scoreOf, prov: new Map() } : undefined;
     for (const op of ordered) {
         if (pathsOf(op).some((p) => dirtyPaths.has(p)))
-            applyOp(replayTree, op, blobContent, replaySynth, alias);
+            applyOp(replayTree, op, blobContent, replaySynth, alias, arb);
     }
     // Final tree = clean base paths (not dirty) + replayed dirty paths.
     const tree = new Map();
@@ -380,7 +440,7 @@ export function snapshotReduce(input) {
     for (const o of ops)
         if (keysOf(o).length === 0 && statuses.get(o.oid) === "proposed")
             statuses.set(o.oid, "accepted");
-    const { tree, treeHash, headOps, synthBlobs } = materializeProjection(ops, statuses, anc, materializeStatuses, input.blobContent ?? new Map());
+    const { tree, treeHash, headOps, synthBlobs } = materializeProjection(ops, statuses, anc, materializeStatuses, input.blobContent ?? new Map(), scorerFrom(ops, evalOf));
     const result = { tree, treeHash, statuses, conflicts, autoDecisions, fileConflicts: [], headOps, synthBlobs, blockedReasons, untrustedEvidence: 0 };
     const stats = { groupsTotal: groups.size, groupsRecomputed: groups.size, groupsReused: 0, dirtyKeys: groups.size };
     return { input, result, perKey, groupOrder, groupMembers, stats };
@@ -597,6 +657,18 @@ export function reduceIncremental(snap, next) {
                 return true; // a delta op became this op's ancestor
         return false;
     };
+    // A contended region's winner is a function of the SCORES of the ops writing that path
+    // (docs/22 §4.2), so a change to a score INPUT dirties the path even when the projection is
+    // untouched: new evidence for an op, or a reliability shift for its actor, can flip which
+    // option takes the region. Without this the warm path would keep a region the cold path
+    // re-decides, and warm/cold would disagree on the tree — the one thing incremental reduce
+    // may never do. Group dirtiness already covers both signals; this carries them to PATHS.
+    const newEvidenceFor = new Set();
+    for (const e of evidence)
+        if (!prevEvIds.has(e.oid))
+            for (const oid of e.forOps)
+                newEvidenceFor.add(oid);
+    const scoreChanged = (o) => newEvidenceFor.has(o.oid) || changedActors.has(o.actor.id);
     const dirtyPaths = new Set();
     for (const o of ops) {
         const oid = o.oid;
@@ -619,8 +691,12 @@ export function reduceIncremental(snap, next) {
         else if (projectedNow(oid) && isCrossPath(o))
             for (const p of pathsOf(o))
                 dirtyPaths.add(p);
+        // Score-input change (docs/22): the op still projects, but what it is WORTH changed.
+        else if (projectedNow(oid) && scoreChanged(o))
+            for (const p of pathsOf(o))
+                dirtyPaths.add(p);
     }
-    const { tree, treeHash, headOps, synthBlobs } = materializeIncremental(ops, statuses, anc, materializeStatuses, next.blobContent ?? new Map(), snap.result, dirtyPaths);
+    const { tree, treeHash, headOps, synthBlobs } = materializeIncremental(ops, statuses, anc, materializeStatuses, next.blobContent ?? new Map(), snap.result, dirtyPaths, scorerFrom(ops, evalOf));
     const result = { tree, treeHash, statuses, conflicts, autoDecisions, fileConflicts: [], headOps, synthBlobs, blockedReasons, untrustedEvidence: 0 };
     const stats = { groupsTotal: groups.size, groupsRecomputed: recomputed, groupsReused: reused, dirtyKeys: dirty.size };
     return { input: next, result, perKey, groupOrder, groupMembers, stats };
@@ -918,6 +994,125 @@ function kahnOrder(ops, anc) {
     }
     return order;
 }
+/**
+ * The arbitration rule (docs/22 §3.2) — the one place it is written down.
+ *
+ * `opsForSide` maps a variant index back to the op(s) that produced it. The caller owns
+ * that mapping because it differs between the pairwise merge inside `applyOp` and the
+ * authoritative N-way merge in `detectFileConflicts`.
+ *
+ *   - An option several ops agree on is represented by its HIGHEST-scoring op. An average
+ *     would let a low-trust actor dilute an option merely by co-signing it.
+ *   - Any excluded op excludes its whole option: conservative on blocking, generous on
+ *     score. An option that cannot be auto-accepted cannot win a region either.
+ *   - A tie is never broken by recency. It returns `null`, the region stays a conflict and
+ *     a human decides. docs/00 principle 6 allows recency as a last tie-break for op
+ *     PROMOTION; region content is where meaning diverges, so deciding it quietly is worse
+ *     than raising it.
+ */
+function judgeRegion(region, opsForSide, scoreOf) {
+    const cands = [];
+    for (const [i, opt] of region.options.entries()) {
+        const oids = [...new Set(opt.sides.flatMap(opsForSide))];
+        if (oids.length === 0)
+            return null; // no op behind an option ⇒ nothing to weigh
+        let excluded = false;
+        let rep;
+        for (const oid of oids) {
+            const v = scoreOf(oid);
+            if (!v)
+                return null; // an op the policy cannot speak about ⇒ abstain, never guess
+            if (v.excluded)
+                excluded = true;
+            if (!rep || v.score > rep.score || (v.score === rep.score && oid < rep.opOid))
+                rep = { opOid: oid, score: v.score };
+        }
+        cands.push({ i, excluded, opOid: rep.opOid, score: rep.score });
+    }
+    const live = cands.filter((c) => !c.excluded);
+    if (live.length === 0)
+        return null; // every option blocked ⇒ a human, and no unverified
+    const topScore = Math.max(...live.map((c) => c.score)); //     content takes the region
+    const top = live.filter((c) => c.score === topScore);
+    if (top.length !== 1)
+        return null; // tie ⇒ a human
+    const win = top[0];
+    return {
+        option: win.i,
+        chosen: win.opOid,
+        rejected: cands.filter((c) => c.i !== win.i).map((c) => c.opOid),
+        optionScores: cands.map((c) => ({ opOid: c.opOid, score: c.score, excluded: c.excluded })),
+    };
+}
+/**
+ * side → op for `applyOp`'s PAIRWISE merge, which is not the clean mapping docs/22 §3.2
+ * assumed. Side 1 is the op being applied, but side 0 is the ACCUMULATED tree content —
+ * the composition of every content op already applied at that path.
+ *
+ * So the incumbent side is attributed per REGION: only the contributors whose own change
+ * (measured against this merge's base, so the coordinates match the region's) touches the
+ * contested span may speak for it, and among those the strongest represents the option —
+ * the same rule agreement uses. Without the span filter, a high-trust edit to an unrelated
+ * part of the file would defend a low-trust edit's region, and the tree would disagree with
+ * the authoritative N-way pass, which sees every op separately.
+ *
+ * The per-contributor diff is lazy and memoized per merge, so a file with no contended
+ * region pays nothing at all and a contended one pays at most one line-diff per contributor
+ * that a region actually asks about (docs/22 R-c). The trail only ever holds the ops still
+ * projected at that path — a sequential edit chain is superseded before it gets here — so it
+ * is the concurrent frontier's size, not the file's history, that bounds this.
+ */
+function pairwiseArbiter(baseText, incumbents, self, contentOf, scoreOf) {
+    const baseLines = baseText.split("\n");
+    const spans = new Map();
+    const spansOf = (op) => {
+        const oid = op.oid;
+        let s = spans.get(oid);
+        if (!s) {
+            s = diffHunks(baseLines, contentOf(op).split("\n"));
+            spans.set(oid, s);
+        }
+        return s;
+    };
+    const touches = (op, start, end) => spansOf(op).some((h) => (h.start === h.end ? h.start >= start && h.start <= end : h.start < end && h.end > start));
+    const selfOid = self.oid;
+    return (region) => {
+        const opsForSide = (side) => {
+            if (side !== 0)
+                return [selfOid];
+            const hit = incumbents.filter((o) => touches(o, region.baseStart, region.baseEnd));
+            // No contributor claims the span (a composition whose hunks shifted): fall back to
+            // the whole trail rather than inventing an attribution.
+            return (hit.length ? hit : incumbents).map((o) => o.oid);
+        };
+        return judgeRegion(region, opsForSide, scoreOf)?.option ?? null;
+    };
+}
+/** Wrap a reduce's memoized `evalOf` as an {@link OpScorer}. Arbitration REUSES the scores
+ *  the group decision already computed — never a recomputation per region (docs/22 R-c). A
+ *  contended region IS a conflict, so ops are evaluated with `inConflict = true`, the same
+ *  flag their contended group used. */
+function scorerFrom(ops, evalOf) {
+    const byId = new Map(ops.map((o) => [o.oid, o]));
+    return (oid) => {
+        const op = byId.get(oid);
+        if (!op)
+            return undefined;
+        const ev = evalOf(op, true);
+        return { score: ev.score, excluded: ev.blocked || ev.requiresHuman };
+    };
+}
+/**
+ * Build an {@link OpScorer} from a bare `ReduceInput`, for a caller outside `reduce` — the
+ * authoritative post-reduce pass (`detectFileConflicts` → {@link arbitrateFileConflicts}).
+ * Evaluation is lazy and memoized per op, so only the ops of a file that actually contended
+ * are ever scored.
+ */
+export function buildOpScorer(input) {
+    const evidence = [...input.evidence].sort((a, b) => cmp(a.createdAt, b.createdAt) || cmp(a.oid, b.oid));
+    const evalOf = makeEvalOf(input.policy, input.intents, buildEvByOp(evidence), input.reliability ?? new Map());
+    return scorerFrom(input.ops, evalOf);
+}
 /**
  * Apply one projected op to the tree.
  *
@@ -927,14 +1122,16 @@ function kahnOrder(ops, anc) {
  * order put first. With no renames in the op set the alias map is empty, resolution is
  * the identity, and this function behaves exactly as it did before.
  */
-function applyOp(tree, op, blobContent, synthBlobs, alias) {
+function applyOp(tree, op, blobContent, synthBlobs, alias, arb) {
     const b = op.body;
     const resolve = (oid) => synthBlobs.get(oid) ?? blobContent.get(oid) ?? Buffer.alloc(0);
     const at = (declared) => resolvedPath(op, declared, alias);
     switch (b.kind) {
         case "put_file":
-            if (b.path && b.blobOid)
+            if (b.path && b.blobOid) {
                 tree.set(at(b.path), b.blobOid);
+                arb?.prov.set(at(b.path), [op]); // a whole-content write restarts the trail
+            }
             break;
         case "edit_file": {
             if (!b.path || !b.blobOid)
@@ -953,21 +1150,32 @@ function applyOp(tree, op, blobContent, synthBlobs, alias) {
                 const synthOid = `blob_${sha256hex(opNew).slice(0, 32)}`;
                 synthBlobs.set(synthOid, opNew);
                 tree.set(path, synthOid);
+                arb?.prov.set(path, [op]);
                 break;
             }
             // Apply this op's patch (opBase→opNew) onto the accumulated content. Disjoint
             // line changes compose (order-independent); an overlap with a prior concurrent op
             // keeps `current` (deterministic incumbent) — the overlap is reported separately
             // by detectFileConflicts over the full op set. Language-neutral: pure text.
-            const m = merge3(opBase.toString("utf8"), [current.toString("utf8"), opNew.toString("utf8")], { onConflict: "first" });
+            // An overlap is no longer settled by which op got here first: the injected arbiter
+            // asks the policy which option wins the region (docs/22 §3.2). It abstains — leaving
+            // the incumbent and the conflict — whenever policy cannot separate the options.
+            const incumbents = arb?.prov.get(path) ?? [];
+            const arbitrate = arb && incumbents.length
+                ? pairwiseArbiter(opBase.toString("utf8"), incumbents, op, (o) => resolve(o.body.blobOid ?? "").toString("utf8"), arb.scoreOf)
+                : undefined;
+            const m = merge3(opBase.toString("utf8"), [current.toString("utf8"), opNew.toString("utf8")], { onConflict: "first", arbitrate });
             const mergedBuf = Buffer.from(m.merged, "utf8");
             const synthOid = `blob_${sha256hex(mergedBuf).slice(0, 32)}`;
             synthBlobs.set(synthOid, mergedBuf);
             tree.set(path, synthOid);
+            if (arb)
+                arb.prov.set(path, [...incumbents, op]);
             break;
         }
         case "delete_file":
             tree.delete(at(b.path ?? op.target.entityId));
+            arb?.prov.delete(at(b.path ?? op.target.entityId));
             break;
         case "rename_file": {
             if (!b.fromPath || !b.path)
@@ -987,6 +1195,12 @@ function applyOp(tree, op, blobContent, synthBlobs, alias) {
             if (blob !== undefined) {
                 tree.delete(b.fromPath);
                 tree.set(b.path, blob);
+                if (arb) {
+                    const trail = arb.prov.get(b.fromPath);
+                    arb.prov.delete(b.fromPath);
+                    if (trail)
+                        arb.prov.set(b.path, trail); // the content moved, and so does its trail
+                }
             }
             break;
         }