daftari 3.7.0 → 3.9.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/CHANGELOG.md +40 -0
- package/README.md +4 -0
- package/dist/access/rbac.d.ts +1 -0
- package/dist/access/rbac.d.ts.map +1 -1
- package/dist/access/rbac.js +8 -0
- package/dist/access/rbac.js.map +1 -1
- package/dist/board/board.d.ts +37 -0
- package/dist/board/board.d.ts.map +1 -0
- package/dist/board/board.js +233 -0
- package/dist/board/board.js.map +1 -0
- package/dist/board/board.test.d.ts +2 -0
- package/dist/board/board.test.d.ts.map +1 -0
- package/dist/board/board.test.js +753 -0
- package/dist/board/board.test.js.map +1 -0
- package/dist/board/dormancy.test.d.ts +2 -0
- package/dist/board/dormancy.test.d.ts.map +1 -0
- package/dist/board/dormancy.test.js +79 -0
- package/dist/board/dormancy.test.js.map +1 -0
- package/dist/board/identity.d.ts +5 -0
- package/dist/board/identity.d.ts.map +1 -0
- package/dist/board/identity.js +146 -0
- package/dist/board/identity.js.map +1 -0
- package/dist/board/identity.test.d.ts +2 -0
- package/dist/board/identity.test.d.ts.map +1 -0
- package/dist/board/identity.test.js +291 -0
- package/dist/board/identity.test.js.map +1 -0
- package/dist/board/ledger.d.ts +41 -0
- package/dist/board/ledger.d.ts.map +1 -0
- package/dist/board/ledger.js +197 -0
- package/dist/board/ledger.js.map +1 -0
- package/dist/board/ledger.test.d.ts +2 -0
- package/dist/board/ledger.test.d.ts.map +1 -0
- package/dist/board/ledger.test.js +873 -0
- package/dist/board/ledger.test.js.map +1 -0
- package/dist/board/principals.d.ts +4 -0
- package/dist/board/principals.d.ts.map +1 -0
- package/dist/board/principals.js +37 -0
- package/dist/board/principals.js.map +1 -0
- package/dist/board/principals.test.d.ts +2 -0
- package/dist/board/principals.test.d.ts.map +1 -0
- package/dist/board/principals.test.js +296 -0
- package/dist/board/principals.test.js.map +1 -0
- package/dist/board/reconcile.d.ts +12 -0
- package/dist/board/reconcile.d.ts.map +1 -0
- package/dist/board/reconcile.js +293 -0
- package/dist/board/reconcile.js.map +1 -0
- package/dist/board/reconcile.test.d.ts +2 -0
- package/dist/board/reconcile.test.d.ts.map +1 -0
- package/dist/board/reconcile.test.js +788 -0
- package/dist/board/reconcile.test.js.map +1 -0
- package/dist/board/sources/index.d.ts +24 -0
- package/dist/board/sources/index.d.ts.map +1 -0
- package/dist/board/sources/index.js +64 -0
- package/dist/board/sources/index.js.map +1 -0
- package/dist/board/sources/lint.d.ts +3 -0
- package/dist/board/sources/lint.d.ts.map +1 -0
- package/dist/board/sources/lint.js +218 -0
- package/dist/board/sources/lint.js.map +1 -0
- package/dist/board/sources/lint.test.d.ts +2 -0
- package/dist/board/sources/lint.test.d.ts.map +1 -0
- package/dist/board/sources/lint.test.js +616 -0
- package/dist/board/sources/lint.test.js.map +1 -0
- package/dist/board/sources/staged.d.ts +3 -0
- package/dist/board/sources/staged.d.ts.map +1 -0
- package/dist/board/sources/staged.js +116 -0
- package/dist/board/sources/staged.js.map +1 -0
- package/dist/board/sources/staged.test.d.ts +2 -0
- package/dist/board/sources/staged.test.d.ts.map +1 -0
- package/dist/board/sources/staged.test.js +418 -0
- package/dist/board/sources/staged.test.js.map +1 -0
- package/dist/board/sources/staleness.d.ts +43 -0
- package/dist/board/sources/staleness.d.ts.map +1 -0
- package/dist/board/sources/staleness.js +346 -0
- package/dist/board/sources/staleness.js.map +1 -0
- package/dist/board/sources/staleness.test.d.ts +2 -0
- package/dist/board/sources/staleness.test.d.ts.map +1 -0
- package/dist/board/sources/staleness.test.js +923 -0
- package/dist/board/sources/staleness.test.js.map +1 -0
- package/dist/board/sources/tension.d.ts +3 -0
- package/dist/board/sources/tension.d.ts.map +1 -0
- package/dist/board/sources/tension.js +152 -0
- package/dist/board/sources/tension.js.map +1 -0
- package/dist/board/sources/tension.test.d.ts +2 -0
- package/dist/board/sources/tension.test.d.ts.map +1 -0
- package/dist/board/sources/tension.test.js +440 -0
- package/dist/board/sources/tension.test.js.map +1 -0
- package/dist/board/sources/tier2.d.ts +17 -0
- package/dist/board/sources/tier2.d.ts.map +1 -0
- package/dist/board/sources/tier2.js +233 -0
- package/dist/board/sources/tier2.js.map +1 -0
- package/dist/board/sources/tier2.test.d.ts +2 -0
- package/dist/board/sources/tier2.test.d.ts.map +1 -0
- package/dist/board/sources/tier2.test.js +480 -0
- package/dist/board/sources/tier2.test.js.map +1 -0
- package/dist/board/types.d.ts +161 -0
- package/dist/board/types.d.ts.map +1 -0
- package/dist/board/types.js +37 -0
- package/dist/board/types.js.map +1 -0
- package/dist/canon/index.d.ts +3 -1
- package/dist/canon/index.d.ts.map +1 -1
- package/dist/canon/index.js +35 -8
- package/dist/canon/index.js.map +1 -1
- package/dist/canon/types.d.ts +3 -0
- package/dist/canon/types.d.ts.map +1 -1
- package/dist/cli.d.ts.map +1 -1
- package/dist/cli.js +9 -0
- package/dist/cli.js.map +1 -1
- package/dist/consolidate/birth.d.ts +1 -1
- package/dist/consolidate/birth.d.ts.map +1 -1
- package/dist/consolidate/birth.js +22 -0
- package/dist/consolidate/birth.js.map +1 -1
- package/dist/consolidate/edge-write.d.ts +11 -0
- package/dist/consolidate/edge-write.d.ts.map +1 -1
- package/dist/consolidate/edge-write.js +41 -0
- package/dist/consolidate/edge-write.js.map +1 -1
- package/dist/consolidate/index.js +5 -2
- package/dist/consolidate/index.js.map +1 -1
- package/dist/consolidate/revision.d.ts +4 -2
- package/dist/consolidate/revision.d.ts.map +1 -1
- package/dist/consolidate/revision.js +23 -0
- package/dist/consolidate/revision.js.map +1 -1
- package/dist/curation/edge-staleness.d.ts +4 -2
- package/dist/curation/edge-staleness.d.ts.map +1 -1
- package/dist/curation/edge-staleness.js +36 -3
- package/dist/curation/edge-staleness.js.map +1 -1
- package/dist/curation/edges.d.ts +7 -0
- package/dist/curation/edges.d.ts.map +1 -1
- package/dist/curation/edges.js +13 -7
- package/dist/curation/edges.js.map +1 -1
- package/dist/curation/tension-access.d.ts +1 -0
- package/dist/curation/tension-access.d.ts.map +1 -1
- package/dist/curation/tension-access.js +18 -1
- package/dist/curation/tension-access.js.map +1 -1
- package/dist/curation/tension.d.ts +3 -0
- package/dist/curation/tension.d.ts.map +1 -1
- package/dist/curation/tension.js +36 -0
- package/dist/curation/tension.js.map +1 -1
- package/dist/curation/vault-docs.d.ts +1 -0
- package/dist/curation/vault-docs.d.ts.map +1 -1
- package/dist/curation/vault-docs.js +1 -0
- package/dist/curation/vault-docs.js.map +1 -1
- package/dist/distill/cli.d.ts.map +1 -1
- package/dist/distill/cli.js +6 -0
- package/dist/distill/cli.js.map +1 -1
- package/dist/distill/cost.d.ts +6 -0
- package/dist/distill/cost.d.ts.map +1 -1
- package/dist/distill/cost.js +2 -3
- package/dist/distill/cost.js.map +1 -1
- package/dist/distill/extract.d.ts +52 -0
- package/dist/distill/extract.d.ts.map +1 -1
- package/dist/distill/extract.js +24 -2
- package/dist/distill/extract.js.map +1 -1
- package/dist/distill/propose.d.ts +44 -1
- package/dist/distill/propose.d.ts.map +1 -1
- package/dist/distill/propose.js +84 -2
- package/dist/distill/propose.js.map +1 -1
- package/dist/distill/reader-fingerprint.d.ts +69 -0
- package/dist/distill/reader-fingerprint.d.ts.map +1 -0
- package/dist/distill/reader-fingerprint.js +145 -0
- package/dist/distill/reader-fingerprint.js.map +1 -0
- package/dist/distill/receipt-store.d.ts +5 -0
- package/dist/distill/receipt-store.d.ts.map +1 -0
- package/dist/distill/receipt-store.js +24 -0
- package/dist/distill/receipt-store.js.map +1 -0
- package/dist/eval/llm-openrouter.d.ts.map +1 -1
- package/dist/eval/llm-openrouter.js +4 -0
- package/dist/eval/llm-openrouter.js.map +1 -1
- package/dist/eval/llm.d.ts +22 -0
- package/dist/eval/llm.d.ts.map +1 -1
- package/dist/eval/llm.js +94 -24
- package/dist/eval/llm.js.map +1 -1
- package/dist/federation/classification.d.ts.map +1 -1
- package/dist/federation/classification.js +3 -0
- package/dist/federation/classification.js.map +1 -1
- package/dist/index.d.ts.map +1 -1
- package/dist/index.js +31 -0
- package/dist/index.js.map +1 -1
- package/dist/search/coverage.d.ts +5 -1
- package/dist/search/coverage.d.ts.map +1 -1
- package/dist/search/coverage.js +47 -15
- package/dist/search/coverage.js.map +1 -1
- package/dist/search/hybrid.d.ts +7 -1
- package/dist/search/hybrid.d.ts.map +1 -1
- package/dist/search/hybrid.js +31 -8
- package/dist/search/hybrid.js.map +1 -1
- package/dist/search/retrieval-metrics.d.ts +5 -0
- package/dist/search/retrieval-metrics.d.ts.map +1 -0
- package/dist/search/retrieval-metrics.js +60 -0
- package/dist/search/retrieval-metrics.js.map +1 -0
- package/dist/search/suppression.d.ts +9 -0
- package/dist/search/suppression.d.ts.map +1 -0
- package/dist/search/suppression.js +107 -0
- package/dist/search/suppression.js.map +1 -0
- package/dist/serve/index.d.ts +11 -0
- package/dist/serve/index.d.ts.map +1 -1
- package/dist/serve/index.js +547 -8
- package/dist/serve/index.js.map +1 -1
- package/dist/serve/session.d.ts +9 -0
- package/dist/serve/session.d.ts.map +1 -0
- package/dist/serve/session.js +65 -0
- package/dist/serve/session.js.map +1 -0
- package/dist/server.d.ts.map +1 -1
- package/dist/server.js +4 -6
- package/dist/server.js.map +1 -1
- package/dist/tools/board.d.ts +32 -0
- package/dist/tools/board.d.ts.map +1 -0
- package/dist/tools/board.js +615 -0
- package/dist/tools/board.js.map +1 -0
- package/dist/tools/board.test.d.ts +2 -0
- package/dist/tools/board.test.d.ts.map +1 -0
- package/dist/tools/board.test.js +964 -0
- package/dist/tools/board.test.js.map +1 -0
- package/dist/tools/edge-staleness.d.ts.map +1 -1
- package/dist/tools/edge-staleness.js +18 -4
- package/dist/tools/edge-staleness.js.map +1 -1
- package/dist/tools/read.d.ts +2 -0
- package/dist/tools/read.d.ts.map +1 -1
- package/dist/tools/read.js +43 -13
- package/dist/tools/read.js.map +1 -1
- package/dist/tools/search.d.ts.map +1 -1
- package/dist/tools/search.js +79 -17
- package/dist/tools/search.js.map +1 -1
- package/dist/tools/write.d.ts.map +1 -1
- package/dist/tools/write.js +172 -2
- package/dist/tools/write.js.map +1 -1
- package/dist/utils/config.d.ts +24 -0
- package/dist/utils/config.d.ts.map +1 -1
- package/dist/utils/config.js +151 -1
- package/dist/utils/config.js.map +1 -1
- package/dist/version.d.ts +2 -0
- package/dist/version.d.ts.map +1 -0
- package/dist/version.js +8 -0
- package/dist/version.js.map +1 -0
- package/dist/view/board-page.d.ts +4 -0
- package/dist/view/board-page.d.ts.map +1 -0
- package/dist/view/board-page.js +339 -0
- package/dist/view/board-page.js.map +1 -0
- package/dist/view/board-page.test.d.ts +2 -0
- package/dist/view/board-page.test.d.ts.map +1 -0
- package/dist/view/board-page.test.js +548 -0
- package/dist/view/board-page.test.js.map +1 -0
- package/dist/view/pages.d.ts.map +1 -1
- package/dist/view/pages.js +13 -2
- package/dist/view/pages.js.map +1 -1
- package/dist/view/render.d.ts.map +1 -1
- package/dist/view/render.js +2 -1
- package/dist/view/render.js.map +1 -1
- package/package.json +2 -2
|
@@ -0,0 +1,788 @@
|
|
|
1
|
+
// reconcile.test.ts — TDD test suite for U4: Reconciliation engine.
|
|
2
|
+
//
|
|
3
|
+
// Tests are pure: all fixtures are constructed in-memory (Finding[] and
|
|
4
|
+
// Map<string, LedgerEvent[]>). No file I/O occurs here. This mirrors the
|
|
5
|
+
// pure-engine pattern from tension-triage.ts.
|
|
6
|
+
//
|
|
7
|
+
// Run with:
|
|
8
|
+
// npx vitest run src/board/reconcile.test.ts
|
|
9
|
+
import { describe, expect, it } from "vitest";
|
|
10
|
+
import { IDENTITY_SCHEME_VERSION } from "./identity.js";
|
|
11
|
+
import { reconcile } from "./reconcile.js";
|
|
12
|
+
// ---------------------------------------------------------------------------
|
|
13
|
+
// Fixture factories
|
|
14
|
+
// ---------------------------------------------------------------------------
|
|
15
|
+
let _findingSeq = 0;
|
|
16
|
+
/**
|
|
17
|
+
* Build a minimal Finding with sensible defaults. Callers override only what
|
|
18
|
+
* matters for the scenario under test.
|
|
19
|
+
*/
|
|
20
|
+
function makeFinding(overrides = {}) {
|
|
21
|
+
const id = overrides.identity_key ?? `finding-${++_findingSeq}`;
|
|
22
|
+
return {
|
|
23
|
+
identity_key: id,
|
|
24
|
+
source: "lint",
|
|
25
|
+
check: "staleFiles",
|
|
26
|
+
target: { kind: "lint", path: `path/to/file-${id}.md` },
|
|
27
|
+
fingerprint: overrides.fingerprint ?? "fp-default",
|
|
28
|
+
certainty: "medium",
|
|
29
|
+
evidence: {},
|
|
30
|
+
suggested_action: "review the file",
|
|
31
|
+
verify_predicate: "re-run lint",
|
|
32
|
+
owner: "alice",
|
|
33
|
+
first_seen: "2024-01-01T00:00:00Z",
|
|
34
|
+
last_seen: "2024-01-01T00:00:00Z",
|
|
35
|
+
disposition: "new", // will be overwritten by reconcile
|
|
36
|
+
history: [],
|
|
37
|
+
...overrides,
|
|
38
|
+
};
|
|
39
|
+
}
|
|
40
|
+
/**
|
|
41
|
+
* Build a fully-formed LedgerEvent. `identity_scheme_version` is always
|
|
42
|
+
* stamped to IDENTITY_SCHEME_VERSION so tests reflect the real contract.
|
|
43
|
+
*/
|
|
44
|
+
function makeEvent(overrides) {
|
|
45
|
+
return {
|
|
46
|
+
finding_id: overrides.finding_id,
|
|
47
|
+
event: overrides.event,
|
|
48
|
+
by: overrides.by ?? "human:alice",
|
|
49
|
+
principal_type: overrides.principal_type ?? "human",
|
|
50
|
+
at: overrides.at ?? "2024-01-01T00:00:00Z",
|
|
51
|
+
against_fingerprint: overrides.against_fingerprint ?? "fp-default",
|
|
52
|
+
identity_scheme_version: IDENTITY_SCHEME_VERSION,
|
|
53
|
+
...(overrides.rationale !== undefined ? { rationale: overrides.rationale } : {}),
|
|
54
|
+
...(overrides.expiry !== undefined ? { expiry: overrides.expiry } : {}),
|
|
55
|
+
...(overrides.owner !== undefined ? { owner: overrides.owner } : {}),
|
|
56
|
+
...(overrides.descriptor !== undefined ? { descriptor: overrides.descriptor } : {}),
|
|
57
|
+
};
|
|
58
|
+
}
|
|
59
|
+
/**
|
|
60
|
+
* Build a ledger map from an array of events. Groups by finding_id preserving
|
|
61
|
+
* append order, exactly as loadLedger does.
|
|
62
|
+
*/
|
|
63
|
+
function buildLedger(events) {
|
|
64
|
+
const map = new Map();
|
|
65
|
+
for (const evt of events) {
|
|
66
|
+
const existing = map.get(evt.finding_id);
|
|
67
|
+
if (existing) {
|
|
68
|
+
existing.push(evt);
|
|
69
|
+
}
|
|
70
|
+
else {
|
|
71
|
+
map.set(evt.finding_id, [evt]);
|
|
72
|
+
}
|
|
73
|
+
}
|
|
74
|
+
return map;
|
|
75
|
+
}
|
|
76
|
+
/** Convenience: apply emitted events back into the ledger map (simulates caller persisting). */
|
|
77
|
+
function applyEmits(ledger, emits) {
|
|
78
|
+
// Clone to avoid mutating the original map between idempotency runs.
|
|
79
|
+
const next = new Map(Array.from(ledger.entries()).map(([k, v]) => [k, [...v]]));
|
|
80
|
+
for (const evt of emits) {
|
|
81
|
+
const existing = next.get(evt.finding_id);
|
|
82
|
+
if (existing) {
|
|
83
|
+
existing.push(evt);
|
|
84
|
+
}
|
|
85
|
+
else {
|
|
86
|
+
next.set(evt.finding_id, [evt]);
|
|
87
|
+
}
|
|
88
|
+
}
|
|
89
|
+
return next;
|
|
90
|
+
}
|
|
91
|
+
const NOW = new Date("2024-06-01T12:00:00Z");
|
|
92
|
+
// ---------------------------------------------------------------------------
|
|
93
|
+
// CASE A — live finding, NO ledger events → column "new", no emit
|
|
94
|
+
// ---------------------------------------------------------------------------
|
|
95
|
+
describe("CASE A — live finding with no ledger events", () => {
|
|
96
|
+
it("produces column 'new', no emitted events", () => {
|
|
97
|
+
const finding = makeFinding({ identity_key: "f-a1", fingerprint: "fp-a1" });
|
|
98
|
+
const ledger = new Map();
|
|
99
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
100
|
+
expect(findings).toHaveLength(1);
|
|
101
|
+
expect(findings[0].disposition).toBe("new");
|
|
102
|
+
expect(findings[0].identity_key).toBe("f-a1");
|
|
103
|
+
expect(emit).toHaveLength(0);
|
|
104
|
+
});
|
|
105
|
+
it("history is empty when no ledger events exist", () => {
|
|
106
|
+
const finding = makeFinding({ identity_key: "f-a2" });
|
|
107
|
+
const { findings } = reconcile([finding], new Map(), NOW);
|
|
108
|
+
expect(findings[0].history).toHaveLength(0);
|
|
109
|
+
});
|
|
110
|
+
it("first_seen and last_seen come from the live finding when ledger is empty", () => {
|
|
111
|
+
const finding = makeFinding({
|
|
112
|
+
identity_key: "f-a3",
|
|
113
|
+
first_seen: "2024-03-01T00:00:00Z",
|
|
114
|
+
last_seen: "2024-03-15T00:00:00Z",
|
|
115
|
+
});
|
|
116
|
+
const { findings } = reconcile([finding], new Map(), NOW);
|
|
117
|
+
expect(findings[0].first_seen).toBe("2024-03-01T00:00:00Z");
|
|
118
|
+
expect(findings[0].last_seen).toBe("2024-03-15T00:00:00Z");
|
|
119
|
+
});
|
|
120
|
+
});
|
|
121
|
+
// ---------------------------------------------------------------------------
|
|
122
|
+
// CASE B — live finding WITH ledger events
|
|
123
|
+
// ---------------------------------------------------------------------------
|
|
124
|
+
describe("CASE B — accept → column 'accepted'", () => {
|
|
125
|
+
it("accepted disposition maps to 'accepted' column", () => {
|
|
126
|
+
const finding = makeFinding({ identity_key: "f-b1", fingerprint: "fp-b1" });
|
|
127
|
+
const ledger = buildLedger([
|
|
128
|
+
makeEvent({ finding_id: "f-b1", event: "new", against_fingerprint: "fp-b1" }),
|
|
129
|
+
makeEvent({ finding_id: "f-b1", event: "accept", against_fingerprint: "fp-b1" }),
|
|
130
|
+
]);
|
|
131
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
132
|
+
expect(findings[0].disposition).toBe("accepted");
|
|
133
|
+
expect(emit).toHaveLength(0);
|
|
134
|
+
});
|
|
135
|
+
it("history is populated from ledger events", () => {
|
|
136
|
+
const finding = makeFinding({ identity_key: "f-b2", fingerprint: "fp-b2" });
|
|
137
|
+
const events = [
|
|
138
|
+
makeEvent({ finding_id: "f-b2", event: "new", against_fingerprint: "fp-b2" }),
|
|
139
|
+
makeEvent({ finding_id: "f-b2", event: "accept", against_fingerprint: "fp-b2" }),
|
|
140
|
+
];
|
|
141
|
+
const ledger = buildLedger(events);
|
|
142
|
+
const { findings } = reconcile([finding], ledger, NOW);
|
|
143
|
+
expect(findings[0].history).toHaveLength(2);
|
|
144
|
+
expect(findings[0].history.map((e) => e.event)).toEqual(["new", "accept"]);
|
|
145
|
+
});
|
|
146
|
+
});
|
|
147
|
+
describe("CASE B — defer → column 'waiting'", () => {
|
|
148
|
+
it("active defer (unexpired) maps to 'waiting' column", () => {
|
|
149
|
+
const finding = makeFinding({ identity_key: "f-b3", fingerprint: "fp-b3" });
|
|
150
|
+
const futureExpiry = "2099-01-01T00:00:00Z";
|
|
151
|
+
const ledger = buildLedger([
|
|
152
|
+
makeEvent({
|
|
153
|
+
finding_id: "f-b3",
|
|
154
|
+
event: "defer",
|
|
155
|
+
against_fingerprint: "fp-b3",
|
|
156
|
+
expiry: futureExpiry,
|
|
157
|
+
}),
|
|
158
|
+
]);
|
|
159
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
160
|
+
expect(findings[0].disposition).toBe("waiting");
|
|
161
|
+
expect(emit).toHaveLength(0);
|
|
162
|
+
});
|
|
163
|
+
it("elapsed defer expiry → re-triage → column 'new' (R25)", () => {
|
|
164
|
+
const finding = makeFinding({ identity_key: "f-b4", fingerprint: "fp-b4" });
|
|
165
|
+
const pastExpiry = "2020-01-01T00:00:00Z"; // well before NOW
|
|
166
|
+
const ledger = buildLedger([
|
|
167
|
+
makeEvent({
|
|
168
|
+
finding_id: "f-b4",
|
|
169
|
+
event: "defer",
|
|
170
|
+
against_fingerprint: "fp-b4",
|
|
171
|
+
expiry: pastExpiry,
|
|
172
|
+
}),
|
|
173
|
+
]);
|
|
174
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
175
|
+
expect(findings[0].disposition).toBe("new");
|
|
176
|
+
expect(emit).toHaveLength(0);
|
|
177
|
+
});
|
|
178
|
+
it("defer with no expiry: active waiting, no expiry to check", () => {
|
|
179
|
+
const finding = makeFinding({ identity_key: "f-b4b", fingerprint: "fp-b4b" });
|
|
180
|
+
const ledger = buildLedger([
|
|
181
|
+
makeEvent({ finding_id: "f-b4b", event: "defer", against_fingerprint: "fp-b4b" }),
|
|
182
|
+
]);
|
|
183
|
+
const { findings } = reconcile([finding], ledger, NOW);
|
|
184
|
+
// No expiry → not expired → stays waiting
|
|
185
|
+
expect(findings[0].disposition).toBe("waiting");
|
|
186
|
+
});
|
|
187
|
+
});
|
|
188
|
+
describe("CASE B — dismiss scenarios", () => {
|
|
189
|
+
it("dismiss with matching fingerprint and no expiry → 'dismissed' column (R10)", () => {
|
|
190
|
+
const finding = makeFinding({ identity_key: "f-b5", fingerprint: "fp-match" });
|
|
191
|
+
const ledger = buildLedger([
|
|
192
|
+
makeEvent({
|
|
193
|
+
finding_id: "f-b5",
|
|
194
|
+
event: "dismiss",
|
|
195
|
+
against_fingerprint: "fp-match", // matches live fingerprint
|
|
196
|
+
}),
|
|
197
|
+
]);
|
|
198
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
199
|
+
expect(findings[0].disposition).toBe("dismissed");
|
|
200
|
+
expect(emit).toHaveLength(0);
|
|
201
|
+
});
|
|
202
|
+
it("dismiss with matching fingerprint and unexpired expiry → 'dismissed' column", () => {
|
|
203
|
+
const finding = makeFinding({ identity_key: "f-b6", fingerprint: "fp-match2" });
|
|
204
|
+
const futureExpiry = "2099-12-31T00:00:00Z";
|
|
205
|
+
const ledger = buildLedger([
|
|
206
|
+
makeEvent({
|
|
207
|
+
finding_id: "f-b6",
|
|
208
|
+
event: "dismiss",
|
|
209
|
+
against_fingerprint: "fp-match2",
|
|
210
|
+
expiry: futureExpiry,
|
|
211
|
+
}),
|
|
212
|
+
]);
|
|
213
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
214
|
+
expect(findings[0].disposition).toBe("dismissed");
|
|
215
|
+
expect(emit).toHaveLength(0);
|
|
216
|
+
});
|
|
217
|
+
it("dismiss with DRIFTED fingerprint → 're-triage' → column 'new', no duplicate card (R10)", () => {
|
|
218
|
+
const finding = makeFinding({ identity_key: "f-b7", fingerprint: "fp-NEW" });
|
|
219
|
+
const ledger = buildLedger([
|
|
220
|
+
makeEvent({
|
|
221
|
+
finding_id: "f-b7",
|
|
222
|
+
event: "dismiss",
|
|
223
|
+
against_fingerprint: "fp-OLD", // different from live fingerprint
|
|
224
|
+
}),
|
|
225
|
+
]);
|
|
226
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
227
|
+
// Re-triage: column is new
|
|
228
|
+
expect(findings[0].disposition).toBe("new");
|
|
229
|
+
// No duplicate card — still exactly one finding
|
|
230
|
+
expect(findings).toHaveLength(1);
|
|
231
|
+
// No system event emitted for fingerprint drift
|
|
232
|
+
expect(emit).toHaveLength(0);
|
|
233
|
+
// History is preserved
|
|
234
|
+
expect(findings[0].history).toHaveLength(1);
|
|
235
|
+
});
|
|
236
|
+
it("dismiss with ELAPSED expiry → column 'new' (R9)", () => {
|
|
237
|
+
const finding = makeFinding({ identity_key: "f-b8", fingerprint: "fp-same" });
|
|
238
|
+
const pastExpiry = "2020-01-01T00:00:00Z";
|
|
239
|
+
const ledger = buildLedger([
|
|
240
|
+
makeEvent({
|
|
241
|
+
finding_id: "f-b8",
|
|
242
|
+
event: "dismiss",
|
|
243
|
+
against_fingerprint: "fp-same", // fingerprint matches
|
|
244
|
+
expiry: pastExpiry, // but expiry has elapsed
|
|
245
|
+
}),
|
|
246
|
+
]);
|
|
247
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
248
|
+
expect(findings[0].disposition).toBe("new");
|
|
249
|
+
expect(emit).toHaveLength(0);
|
|
250
|
+
});
|
|
251
|
+
});
|
|
252
|
+
describe("CASE B — resolved finding reappears in live set → reopened (R8)", () => {
|
|
253
|
+
it("emits exactly one 'reopened' event; column reverts to prior human disposition", () => {
|
|
254
|
+
const finding = makeFinding({ identity_key: "f-b9", fingerprint: "fp-b9" });
|
|
255
|
+
const ledger = buildLedger([
|
|
256
|
+
makeEvent({ finding_id: "f-b9", event: "new", against_fingerprint: "fp-b9" }),
|
|
257
|
+
makeEvent({ finding_id: "f-b9", event: "accept", against_fingerprint: "fp-b9" }),
|
|
258
|
+
makeEvent({
|
|
259
|
+
finding_id: "f-b9",
|
|
260
|
+
event: "resolved",
|
|
261
|
+
against_fingerprint: "fp-b9",
|
|
262
|
+
by: "system",
|
|
263
|
+
principal_type: "system",
|
|
264
|
+
}),
|
|
265
|
+
]);
|
|
266
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
267
|
+
// One reopened emitted
|
|
268
|
+
expect(emit).toHaveLength(1);
|
|
269
|
+
expect(emit[0].event).toBe("reopened");
|
|
270
|
+
expect(emit[0].finding_id).toBe("f-b9");
|
|
271
|
+
expect(emit[0].principal_type).toBe("system");
|
|
272
|
+
expect(emit[0].by).toBe("system");
|
|
273
|
+
expect(emit[0].against_fingerprint).toBe("fp-b9");
|
|
274
|
+
expect(emit[0].identity_scheme_version).toBe(IDENTITY_SCHEME_VERSION);
|
|
275
|
+
expect(emit[0].at).toBe(NOW.toISOString());
|
|
276
|
+
// Column reverts to prior human disposition (accepted was the last human event)
|
|
277
|
+
expect(findings[0].disposition).toBe("accepted");
|
|
278
|
+
// History contains ledger events + the new reopened event
|
|
279
|
+
const eventTypes = findings[0].history.map((e) => e.event);
|
|
280
|
+
expect(eventTypes).toContain("new");
|
|
281
|
+
expect(eventTypes).toContain("accept");
|
|
282
|
+
expect(eventTypes).toContain("resolved");
|
|
283
|
+
// The emitted reopened is NOT yet in history (caller hasn't persisted yet)
|
|
284
|
+
// — this is the pure contract: history reflects ledger as-received.
|
|
285
|
+
});
|
|
286
|
+
it("column reverts to 'new' when there is no prior human disposition before resolved", () => {
|
|
287
|
+
const finding = makeFinding({ identity_key: "f-b10", fingerprint: "fp-b10" });
|
|
288
|
+
const ledger = buildLedger([
|
|
289
|
+
makeEvent({
|
|
290
|
+
finding_id: "f-b10",
|
|
291
|
+
event: "resolved",
|
|
292
|
+
against_fingerprint: "fp-b10",
|
|
293
|
+
by: "system",
|
|
294
|
+
principal_type: "system",
|
|
295
|
+
}),
|
|
296
|
+
]);
|
|
297
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
298
|
+
expect(emit).toHaveLength(1);
|
|
299
|
+
expect(emit[0].event).toBe("reopened");
|
|
300
|
+
// No prior human event → reverts to new
|
|
301
|
+
expect(findings[0].disposition).toBe("new");
|
|
302
|
+
});
|
|
303
|
+
it("already-reopened finding (latest is 'reopened') does NOT re-emit reopened", () => {
|
|
304
|
+
// Scenario: reopened was already appended (second run after first run's emit was applied)
|
|
305
|
+
const finding = makeFinding({ identity_key: "f-b11", fingerprint: "fp-b11" });
|
|
306
|
+
const ledger = buildLedger([
|
|
307
|
+
makeEvent({ finding_id: "f-b11", event: "accept", against_fingerprint: "fp-b11" }),
|
|
308
|
+
makeEvent({
|
|
309
|
+
finding_id: "f-b11",
|
|
310
|
+
event: "resolved",
|
|
311
|
+
against_fingerprint: "fp-b11",
|
|
312
|
+
by: "system",
|
|
313
|
+
principal_type: "system",
|
|
314
|
+
}),
|
|
315
|
+
makeEvent({
|
|
316
|
+
finding_id: "f-b11",
|
|
317
|
+
event: "reopened",
|
|
318
|
+
against_fingerprint: "fp-b11",
|
|
319
|
+
by: "system",
|
|
320
|
+
principal_type: "system",
|
|
321
|
+
}),
|
|
322
|
+
]);
|
|
323
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
324
|
+
// No second reopened
|
|
325
|
+
expect(emit).toHaveLength(0);
|
|
326
|
+
// Column is the disposition before reopened (accept → accepted)
|
|
327
|
+
expect(findings[0].disposition).toBe("accepted");
|
|
328
|
+
});
|
|
329
|
+
});
|
|
330
|
+
// ---------------------------------------------------------------------------
|
|
331
|
+
// CASE C — ledger events exist but finding is ABSENT from live set
|
|
332
|
+
// ---------------------------------------------------------------------------
|
|
333
|
+
describe("CASE C — accepted finding absent from live set → emit resolved", () => {
|
|
334
|
+
it("emits exactly one 'resolved' event for an accepted-but-absent finding", () => {
|
|
335
|
+
// No live findings — the finding disappeared
|
|
336
|
+
const ledger = buildLedger([
|
|
337
|
+
makeEvent({ finding_id: "f-c1", event: "new", against_fingerprint: "fp-c1" }),
|
|
338
|
+
makeEvent({ finding_id: "f-c1", event: "accept", against_fingerprint: "fp-c1-v2" }),
|
|
339
|
+
]);
|
|
340
|
+
const { findings, emit } = reconcile([], ledger, NOW);
|
|
341
|
+
expect(emit).toHaveLength(1);
|
|
342
|
+
expect(emit[0].event).toBe("resolved");
|
|
343
|
+
expect(emit[0].finding_id).toBe("f-c1");
|
|
344
|
+
expect(emit[0].principal_type).toBe("system");
|
|
345
|
+
expect(emit[0].by).toBe("system");
|
|
346
|
+
// against_fingerprint is the last known fingerprint from the ledger
|
|
347
|
+
expect(emit[0].against_fingerprint).toBe("fp-c1-v2");
|
|
348
|
+
expect(emit[0].identity_scheme_version).toBe(IDENTITY_SCHEME_VERSION);
|
|
349
|
+
expect(emit[0].at).toBe(NOW.toISOString());
|
|
350
|
+
// Resolved finding appears in findings with column 'resolved'
|
|
351
|
+
const resolvedFindings = findings.filter((f) => f.disposition === "resolved");
|
|
352
|
+
expect(resolvedFindings).toHaveLength(1);
|
|
353
|
+
expect(resolvedFindings[0].identity_key).toBe("f-c1");
|
|
354
|
+
});
|
|
355
|
+
it("already-resolved and absent finding → no re-emit (idempotent, R6)", () => {
|
|
356
|
+
// Simulates second run after resolved was already appended
|
|
357
|
+
const ledger = buildLedger([
|
|
358
|
+
makeEvent({ finding_id: "f-c2", event: "accept", against_fingerprint: "fp-c2" }),
|
|
359
|
+
makeEvent({
|
|
360
|
+
finding_id: "f-c2",
|
|
361
|
+
event: "resolved",
|
|
362
|
+
against_fingerprint: "fp-c2",
|
|
363
|
+
by: "system",
|
|
364
|
+
principal_type: "system",
|
|
365
|
+
}),
|
|
366
|
+
]);
|
|
367
|
+
const { emit } = reconcile([], ledger, NOW);
|
|
368
|
+
expect(emit).toHaveLength(0);
|
|
369
|
+
});
|
|
370
|
+
it("dismissed-and-absent finding → no resolved emit, finding dropped", () => {
|
|
371
|
+
// A dismissed finding that no longer reproduces is simply gone.
|
|
372
|
+
const ledger = buildLedger([
|
|
373
|
+
makeEvent({ finding_id: "f-c3", event: "dismiss", against_fingerprint: "fp-c3" }),
|
|
374
|
+
]);
|
|
375
|
+
const { findings, emit } = reconcile([], ledger, NOW);
|
|
376
|
+
expect(emit).toHaveLength(0);
|
|
377
|
+
// Not included in findings (dismissed-and-gone is dropped per design decision)
|
|
378
|
+
expect(findings.find((f) => f.identity_key === "f-c3")).toBeUndefined();
|
|
379
|
+
});
|
|
380
|
+
it("deferred-and-absent finding → no resolved emit, finding dropped", () => {
|
|
381
|
+
const ledger = buildLedger([
|
|
382
|
+
makeEvent({
|
|
383
|
+
finding_id: "f-c4",
|
|
384
|
+
event: "defer",
|
|
385
|
+
against_fingerprint: "fp-c4",
|
|
386
|
+
expiry: "2099-01-01T00:00:00Z",
|
|
387
|
+
}),
|
|
388
|
+
]);
|
|
389
|
+
const { findings, emit } = reconcile([], ledger, NOW);
|
|
390
|
+
expect(emit).toHaveLength(0);
|
|
391
|
+
expect(findings.find((f) => f.identity_key === "f-c4")).toBeUndefined();
|
|
392
|
+
});
|
|
393
|
+
});
|
|
394
|
+
// ---------------------------------------------------------------------------
|
|
395
|
+
// Idempotency (R6 / R7) — two runs on unchanged inputs produce identical output
|
|
396
|
+
// ---------------------------------------------------------------------------
|
|
397
|
+
describe("Idempotency (R6 / R7)", () => {
|
|
398
|
+
it("two runs with unchanged inputs produce identical findings and zero second-run emits", () => {
|
|
399
|
+
// Scenario: accepted finding + resolved finding that reappears (reopened on first run)
|
|
400
|
+
const liveFinding = makeFinding({ identity_key: "f-idem1", fingerprint: "fp-idem1" });
|
|
401
|
+
const ledger = buildLedger([
|
|
402
|
+
makeEvent({ finding_id: "f-idem1", event: "accept", against_fingerprint: "fp-idem1" }),
|
|
403
|
+
makeEvent({
|
|
404
|
+
finding_id: "f-idem1",
|
|
405
|
+
event: "resolved",
|
|
406
|
+
against_fingerprint: "fp-idem1",
|
|
407
|
+
by: "system",
|
|
408
|
+
principal_type: "system",
|
|
409
|
+
}),
|
|
410
|
+
]);
|
|
411
|
+
// First run
|
|
412
|
+
const run1 = reconcile([liveFinding], ledger, NOW);
|
|
413
|
+
expect(run1.emit).toHaveLength(1); // reopened emitted
|
|
414
|
+
expect(run1.emit[0].event).toBe("reopened");
|
|
415
|
+
// Apply emits (simulates caller persisting)
|
|
416
|
+
const ledger2 = applyEmits(ledger, run1.emit);
|
|
417
|
+
// Second run — same live findings, ledger now has the reopened event appended
|
|
418
|
+
const run2 = reconcile([liveFinding], ledger2, NOW);
|
|
419
|
+
expect(run2.emit).toHaveLength(0); // ZERO new emits
|
|
420
|
+
expect(run2.findings).toHaveLength(run1.findings.length);
|
|
421
|
+
expect(run2.findings[0].disposition).toBe(run1.findings[0].disposition);
|
|
422
|
+
expect(run2.findings[0].identity_key).toBe(run1.findings[0].identity_key);
|
|
423
|
+
});
|
|
424
|
+
it("accepted-absent → resolve → second run: zero emits, same resolved output", () => {
|
|
425
|
+
const ledger = buildLedger([
|
|
426
|
+
makeEvent({ finding_id: "f-idem2", event: "accept", against_fingerprint: "fp-idem2" }),
|
|
427
|
+
]);
|
|
428
|
+
// First run (no live findings → resolved emitted)
|
|
429
|
+
const run1 = reconcile([], ledger, NOW);
|
|
430
|
+
expect(run1.emit).toHaveLength(1);
|
|
431
|
+
expect(run1.emit[0].event).toBe("resolved");
|
|
432
|
+
const ledger2 = applyEmits(ledger, run1.emit);
|
|
433
|
+
// Second run
|
|
434
|
+
const run2 = reconcile([], ledger2, NOW);
|
|
435
|
+
expect(run2.emit).toHaveLength(0);
|
|
436
|
+
// Resolved finding still shows in findings (column resolved, no new emit)
|
|
437
|
+
const resolvedFindings = run2.findings.filter((f) => f.disposition === "resolved");
|
|
438
|
+
expect(resolvedFindings).toHaveLength(1);
|
|
439
|
+
expect(resolvedFindings[0].identity_key).toBe("f-idem2");
|
|
440
|
+
});
|
|
441
|
+
it("two runs with completely unchanged inputs produce bit-identical findings", () => {
|
|
442
|
+
const finding = makeFinding({ identity_key: "f-idem3", fingerprint: "fp-idem3" });
|
|
443
|
+
const ledger = buildLedger([
|
|
444
|
+
makeEvent({ finding_id: "f-idem3", event: "accept", against_fingerprint: "fp-idem3" }),
|
|
445
|
+
]);
|
|
446
|
+
const run1 = reconcile([finding], ledger, NOW);
|
|
447
|
+
const run2 = reconcile([finding], ledger, NOW);
|
|
448
|
+
expect(JSON.stringify(run1.findings)).toBe(JSON.stringify(run2.findings));
|
|
449
|
+
expect(JSON.stringify(run1.emit)).toBe(JSON.stringify(run2.emit));
|
|
450
|
+
});
|
|
451
|
+
});
|
|
452
|
+
// ---------------------------------------------------------------------------
|
|
453
|
+
// Multiple findings — mix of cases in one call
|
|
454
|
+
// ---------------------------------------------------------------------------
|
|
455
|
+
describe("Multiple findings — mixed cases in one reconcile call", () => {
|
|
456
|
+
it("handles new, accepted, dismissed, and resolved findings simultaneously", () => {
|
|
457
|
+
const fNew = makeFinding({ identity_key: "f-mix-new", fingerprint: "fp-new" });
|
|
458
|
+
const fAccepted = makeFinding({ identity_key: "f-mix-accepted", fingerprint: "fp-accepted" });
|
|
459
|
+
const fDismissed = makeFinding({
|
|
460
|
+
identity_key: "f-mix-dismissed",
|
|
461
|
+
fingerprint: "fp-dismissed",
|
|
462
|
+
});
|
|
463
|
+
// f-mix-absent: accepted but not in live set → should emit resolved
|
|
464
|
+
const ledger = buildLedger([
|
|
465
|
+
makeEvent({
|
|
466
|
+
finding_id: "f-mix-accepted",
|
|
467
|
+
event: "accept",
|
|
468
|
+
against_fingerprint: "fp-accepted",
|
|
469
|
+
}),
|
|
470
|
+
makeEvent({
|
|
471
|
+
finding_id: "f-mix-dismissed",
|
|
472
|
+
event: "dismiss",
|
|
473
|
+
against_fingerprint: "fp-dismissed",
|
|
474
|
+
}),
|
|
475
|
+
makeEvent({
|
|
476
|
+
finding_id: "f-mix-absent",
|
|
477
|
+
event: "accept",
|
|
478
|
+
against_fingerprint: "fp-absent",
|
|
479
|
+
}),
|
|
480
|
+
]);
|
|
481
|
+
const { findings, emit } = reconcile([fNew, fAccepted, fDismissed], ledger, NOW);
|
|
482
|
+
const byKey = new Map(findings.map((f) => [f.identity_key, f]));
|
|
483
|
+
expect(byKey.get("f-mix-new").disposition).toBe("new");
|
|
484
|
+
expect(byKey.get("f-mix-accepted").disposition).toBe("accepted");
|
|
485
|
+
expect(byKey.get("f-mix-dismissed").disposition).toBe("dismissed");
|
|
486
|
+
// Resolved finding (absent from live) shows with column resolved
|
|
487
|
+
expect(byKey.get("f-mix-absent").disposition).toBe("resolved");
|
|
488
|
+
// One resolved event emitted for f-mix-absent
|
|
489
|
+
expect(emit).toHaveLength(1);
|
|
490
|
+
expect(emit[0].event).toBe("resolved");
|
|
491
|
+
expect(emit[0].finding_id).toBe("f-mix-absent");
|
|
492
|
+
});
|
|
493
|
+
});
|
|
494
|
+
// ---------------------------------------------------------------------------
|
|
495
|
+
// priorHumanDisposition — reversion for defer and dismiss prior states
|
|
496
|
+
// ---------------------------------------------------------------------------
|
|
497
|
+
describe("priorHumanDisposition reversion — defer and dismiss prior states", () => {
|
|
498
|
+
it("prior human event is defer → column 'waiting' when resolved finding reappears", () => {
|
|
499
|
+
// Sequence: defer → resolved (system) → finding reappears in live set → reopened
|
|
500
|
+
const finding = makeFinding({ identity_key: "f-phd-defer", fingerprint: "fp-phd-defer" });
|
|
501
|
+
const ledger = buildLedger([
|
|
502
|
+
makeEvent({
|
|
503
|
+
finding_id: "f-phd-defer",
|
|
504
|
+
event: "defer",
|
|
505
|
+
against_fingerprint: "fp-phd-defer",
|
|
506
|
+
expiry: "2099-01-01T00:00:00Z",
|
|
507
|
+
}),
|
|
508
|
+
makeEvent({
|
|
509
|
+
finding_id: "f-phd-defer",
|
|
510
|
+
event: "resolved",
|
|
511
|
+
against_fingerprint: "fp-phd-defer",
|
|
512
|
+
by: "system",
|
|
513
|
+
principal_type: "system",
|
|
514
|
+
}),
|
|
515
|
+
]);
|
|
516
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
517
|
+
// Reopened emitted
|
|
518
|
+
expect(emit).toHaveLength(1);
|
|
519
|
+
expect(emit[0].event).toBe("reopened");
|
|
520
|
+
// Column reverts to 'waiting' (prior human was defer)
|
|
521
|
+
expect(findings[0].disposition).toBe("waiting");
|
|
522
|
+
});
|
|
523
|
+
it("prior human event is dismiss, then resolved, then finding reappears → column 'dismissed'", () => {
|
|
524
|
+
// Sequence: dismiss → resolved (system) → finding reappears → should revert to dismissed
|
|
525
|
+
const finding = makeFinding({ identity_key: "f-phd-dismiss", fingerprint: "fp-phd-dismiss" });
|
|
526
|
+
const ledger = buildLedger([
|
|
527
|
+
makeEvent({
|
|
528
|
+
finding_id: "f-phd-dismiss",
|
|
529
|
+
event: "dismiss",
|
|
530
|
+
against_fingerprint: "fp-phd-dismiss",
|
|
531
|
+
}),
|
|
532
|
+
makeEvent({
|
|
533
|
+
finding_id: "f-phd-dismiss",
|
|
534
|
+
event: "resolved",
|
|
535
|
+
against_fingerprint: "fp-phd-dismiss",
|
|
536
|
+
by: "system",
|
|
537
|
+
principal_type: "system",
|
|
538
|
+
}),
|
|
539
|
+
]);
|
|
540
|
+
const { findings, emit } = reconcile([finding], ledger, NOW);
|
|
541
|
+
// Reopened emitted
|
|
542
|
+
expect(emit).toHaveLength(1);
|
|
543
|
+
expect(emit[0].event).toBe("reopened");
|
|
544
|
+
// Column reverts to 'dismissed' (prior human was dismiss)
|
|
545
|
+
expect(findings[0].disposition).toBe("dismissed");
|
|
546
|
+
});
|
|
547
|
+
});
|
|
548
|
+
// ---------------------------------------------------------------------------
|
|
549
|
+
// CASE C — descriptor-backed resolved findings
|
|
550
|
+
// ---------------------------------------------------------------------------
|
|
551
|
+
describe("CASE C — descriptor-backed resolved findings", () => {
|
|
552
|
+
const realDescriptor = {
|
|
553
|
+
source: "tension",
|
|
554
|
+
check: "unresolvedTension",
|
|
555
|
+
target: { kind: "tension", tensionId: "t-123" },
|
|
556
|
+
label: "Unresolved tension between belief A and belief B",
|
|
557
|
+
};
|
|
558
|
+
it("resolved skeleton uses REAL source/check/target/label when descriptor is present", () => {
|
|
559
|
+
// An accept event carries a descriptor (as U11 will stamp)
|
|
560
|
+
const ledger = buildLedger([
|
|
561
|
+
makeEvent({
|
|
562
|
+
finding_id: "f-desc-c1",
|
|
563
|
+
event: "accept",
|
|
564
|
+
against_fingerprint: "fp-desc-c1",
|
|
565
|
+
descriptor: realDescriptor,
|
|
566
|
+
}),
|
|
567
|
+
]);
|
|
568
|
+
const { findings } = reconcile([], ledger, NOW);
|
|
569
|
+
const resolved = findings.find((f) => f.identity_key === "f-desc-c1");
|
|
570
|
+
expect(resolved).toBeDefined();
|
|
571
|
+
expect(resolved.disposition).toBe("resolved");
|
|
572
|
+
// Real values from descriptor, not placeholders
|
|
573
|
+
expect(resolved.source).toBe("tension");
|
|
574
|
+
expect(resolved.check).toBe("unresolvedTension");
|
|
575
|
+
expect(resolved.target).toEqual({ kind: "tension", tensionId: "t-123" });
|
|
576
|
+
});
|
|
577
|
+
it("skeleton falls back to sentinel source 'staleness' when NO event has a descriptor", () => {
|
|
578
|
+
// Older-style event with no descriptor at all
|
|
579
|
+
const ledger = buildLedger([
|
|
580
|
+
makeEvent({
|
|
581
|
+
finding_id: "f-desc-c2",
|
|
582
|
+
event: "accept",
|
|
583
|
+
against_fingerprint: "fp-desc-c2",
|
|
584
|
+
// No descriptor
|
|
585
|
+
}),
|
|
586
|
+
]);
|
|
587
|
+
const { findings } = reconcile([], ledger, NOW);
|
|
588
|
+
const resolved = findings.find((f) => f.identity_key === "f-desc-c2");
|
|
589
|
+
expect(resolved).toBeDefined();
|
|
590
|
+
expect(resolved.disposition).toBe("resolved");
|
|
591
|
+
// Sentinel, not "lint" (which would be misleading)
|
|
592
|
+
expect(resolved.source).toBe("staleness");
|
|
593
|
+
expect(resolved.check).toBe("unknown");
|
|
594
|
+
});
|
|
595
|
+
it("reconcile picks the LATEST descriptor-bearing event (not just the first)", () => {
|
|
596
|
+
const olderDescriptor = {
|
|
597
|
+
source: "lint",
|
|
598
|
+
check: "orphanFiles",
|
|
599
|
+
target: { kind: "lint", path: "old/path.md" },
|
|
600
|
+
label: "Old label",
|
|
601
|
+
};
|
|
602
|
+
const newerDescriptor = {
|
|
603
|
+
source: "tension",
|
|
604
|
+
check: "unresolvedTension",
|
|
605
|
+
target: { kind: "tension", tensionId: "t-999" },
|
|
606
|
+
label: "Updated label after reassign",
|
|
607
|
+
};
|
|
608
|
+
const _ledger = buildLedger([
|
|
609
|
+
makeEvent({
|
|
610
|
+
finding_id: "f-desc-c3",
|
|
611
|
+
event: "accept",
|
|
612
|
+
against_fingerprint: "fp-desc-c3-v1",
|
|
613
|
+
descriptor: olderDescriptor,
|
|
614
|
+
}),
|
|
615
|
+
makeEvent({
|
|
616
|
+
finding_id: "f-desc-c3",
|
|
617
|
+
event: "defer",
|
|
618
|
+
against_fingerprint: "fp-desc-c3-v2",
|
|
619
|
+
descriptor: newerDescriptor,
|
|
620
|
+
expiry: "2099-01-01T00:00:00Z",
|
|
621
|
+
}),
|
|
622
|
+
]);
|
|
623
|
+
// currentDisposition will return "defer" so finding is absent-and-deferred → dropped.
|
|
624
|
+
// Override: use accept as the latest to trigger resolved path.
|
|
625
|
+
// Instead build a scenario where latest is accept with updated descriptor.
|
|
626
|
+
const ledger2 = buildLedger([
|
|
627
|
+
makeEvent({
|
|
628
|
+
finding_id: "f-desc-c3b",
|
|
629
|
+
event: "new",
|
|
630
|
+
against_fingerprint: "fp-c3b",
|
|
631
|
+
descriptor: olderDescriptor,
|
|
632
|
+
}),
|
|
633
|
+
makeEvent({
|
|
634
|
+
finding_id: "f-desc-c3b",
|
|
635
|
+
event: "accept",
|
|
636
|
+
against_fingerprint: "fp-c3b",
|
|
637
|
+
descriptor: newerDescriptor,
|
|
638
|
+
}),
|
|
639
|
+
]);
|
|
640
|
+
const { findings } = reconcile([], ledger2, NOW);
|
|
641
|
+
const resolved = findings.find((f) => f.identity_key === "f-desc-c3b");
|
|
642
|
+
expect(resolved).toBeDefined();
|
|
643
|
+
// Should use the newest (accept event) descriptor
|
|
644
|
+
expect(resolved.source).toBe("tension");
|
|
645
|
+
expect(resolved.check).toBe("unresolvedTension");
|
|
646
|
+
});
|
|
647
|
+
it("emitted 'resolved' event carries the descriptor forward", () => {
|
|
648
|
+
const ledger = buildLedger([
|
|
649
|
+
makeEvent({
|
|
650
|
+
finding_id: "f-desc-emit",
|
|
651
|
+
event: "accept",
|
|
652
|
+
against_fingerprint: "fp-desc-emit",
|
|
653
|
+
descriptor: realDescriptor,
|
|
654
|
+
}),
|
|
655
|
+
]);
|
|
656
|
+
const { emit } = reconcile([], ledger, NOW);
|
|
657
|
+
expect(emit).toHaveLength(1);
|
|
658
|
+
expect(emit[0].event).toBe("resolved");
|
|
659
|
+
expect(emit[0].descriptor).toBeDefined();
|
|
660
|
+
expect(emit[0].descriptor.source).toBe("tension");
|
|
661
|
+
expect(emit[0].descriptor.check).toBe("unresolvedTension");
|
|
662
|
+
expect(emit[0].descriptor.label).toBe("Unresolved tension between belief A and belief B");
|
|
663
|
+
});
|
|
664
|
+
it("idempotency: second run with descriptor still produces zero emits and same resolved output", () => {
|
|
665
|
+
const ledger = buildLedger([
|
|
666
|
+
makeEvent({
|
|
667
|
+
finding_id: "f-desc-idem",
|
|
668
|
+
event: "accept",
|
|
669
|
+
against_fingerprint: "fp-desc-idem",
|
|
670
|
+
descriptor: realDescriptor,
|
|
671
|
+
}),
|
|
672
|
+
]);
|
|
673
|
+
// First run — emits resolved event
|
|
674
|
+
const run1 = reconcile([], ledger, NOW);
|
|
675
|
+
expect(run1.emit).toHaveLength(1);
|
|
676
|
+
expect(run1.emit[0].event).toBe("resolved");
|
|
677
|
+
const ledger2 = applyEmits(ledger, run1.emit);
|
|
678
|
+
// Second run — resolved event now in ledger, still absent from live → ZERO new emits
|
|
679
|
+
const run2 = reconcile([], ledger2, NOW);
|
|
680
|
+
expect(run2.emit).toHaveLength(0);
|
|
681
|
+
// Resolved finding still present on second run with real descriptor data (not sentinel)
|
|
682
|
+
const resolved1 = run1.findings.find((f) => f.identity_key === "f-desc-idem");
|
|
683
|
+
const resolved2 = run2.findings.find((f) => f.identity_key === "f-desc-idem");
|
|
684
|
+
expect(resolved1).toBeDefined();
|
|
685
|
+
expect(resolved2).toBeDefined();
|
|
686
|
+
expect(resolved2.disposition).toBe("resolved");
|
|
687
|
+
expect(resolved2.source).toBe("tension");
|
|
688
|
+
expect(resolved2.check).toBe("unresolvedTension");
|
|
689
|
+
// Both runs produce the same identity_key, source, check, target (descriptor is deterministic)
|
|
690
|
+
expect(resolved1.identity_key).toBe(resolved2.identity_key);
|
|
691
|
+
expect(resolved1.source).toBe(resolved2.source);
|
|
692
|
+
expect(resolved1.check).toBe(resolved2.check);
|
|
693
|
+
expect(JSON.stringify(resolved1.target)).toBe(JSON.stringify(resolved2.target));
|
|
694
|
+
});
|
|
695
|
+
});
|
|
696
|
+
// ---------------------------------------------------------------------------
|
|
697
|
+
// No duplicate cards on fingerprint drift (R10) — additional guard
|
|
698
|
+
// ---------------------------------------------------------------------------
|
|
699
|
+
describe("No duplicate cards on fingerprint drift (R10)", () => {
|
|
700
|
+
it("drifted fingerprint does not produce a second card — still exactly one finding", () => {
|
|
701
|
+
// Live finding has fingerprint fp-v2; ledger dismiss used fp-v1
|
|
702
|
+
const finding = makeFinding({ identity_key: "f-drift", fingerprint: "fp-v2" });
|
|
703
|
+
const ledger = buildLedger([
|
|
704
|
+
makeEvent({ finding_id: "f-drift", event: "dismiss", against_fingerprint: "fp-v1" }),
|
|
705
|
+
]);
|
|
706
|
+
const { findings } = reconcile([finding], ledger, NOW);
|
|
707
|
+
const driftFindings = findings.filter((f) => f.identity_key === "f-drift");
|
|
708
|
+
expect(driftFindings).toHaveLength(1);
|
|
709
|
+
expect(driftFindings[0].disposition).toBe("new");
|
|
710
|
+
});
|
|
711
|
+
});
|
|
712
|
+
// ---------------------------------------------------------------------------
|
|
713
|
+
// first_seen / last_seen — derived from ledger events when available
|
|
714
|
+
// ---------------------------------------------------------------------------
|
|
715
|
+
describe("first_seen / last_seen derivation", () => {
|
|
716
|
+
it("uses min/max 'at' from ledger events when events exist", () => {
|
|
717
|
+
const finding = makeFinding({ identity_key: "f-ts1", fingerprint: "fp-ts1" });
|
|
718
|
+
const ledger = buildLedger([
|
|
719
|
+
makeEvent({
|
|
720
|
+
finding_id: "f-ts1",
|
|
721
|
+
event: "new",
|
|
722
|
+
at: "2024-02-01T00:00:00Z",
|
|
723
|
+
against_fingerprint: "fp-ts1",
|
|
724
|
+
}),
|
|
725
|
+
makeEvent({
|
|
726
|
+
finding_id: "f-ts1",
|
|
727
|
+
event: "accept",
|
|
728
|
+
at: "2024-04-15T00:00:00Z",
|
|
729
|
+
against_fingerprint: "fp-ts1",
|
|
730
|
+
}),
|
|
731
|
+
]);
|
|
732
|
+
const { findings } = reconcile([finding], ledger, NOW);
|
|
733
|
+
expect(findings[0].first_seen).toBe("2024-02-01T00:00:00Z");
|
|
734
|
+
expect(findings[0].last_seen).toBe("2024-04-15T00:00:00Z");
|
|
735
|
+
});
|
|
736
|
+
});
|
|
737
|
+
// ---------------------------------------------------------------------------
|
|
738
|
+
// Emit event shape — fully-formed LedgerEvents
|
|
739
|
+
// ---------------------------------------------------------------------------
|
|
740
|
+
describe("Emitted event shape", () => {
|
|
741
|
+
it("emitted 'reopened' event has all required LedgerEvent fields", () => {
|
|
742
|
+
const finding = makeFinding({ identity_key: "f-shape-reopen", fingerprint: "fp-sr" });
|
|
743
|
+
const ledger = buildLedger([
|
|
744
|
+
makeEvent({
|
|
745
|
+
finding_id: "f-shape-reopen",
|
|
746
|
+
event: "accept",
|
|
747
|
+
against_fingerprint: "fp-sr",
|
|
748
|
+
}),
|
|
749
|
+
makeEvent({
|
|
750
|
+
finding_id: "f-shape-reopen",
|
|
751
|
+
event: "resolved",
|
|
752
|
+
against_fingerprint: "fp-sr",
|
|
753
|
+
by: "system",
|
|
754
|
+
principal_type: "system",
|
|
755
|
+
}),
|
|
756
|
+
]);
|
|
757
|
+
const { emit } = reconcile([finding], ledger, NOW);
|
|
758
|
+
expect(emit).toHaveLength(1);
|
|
759
|
+
const evt = emit[0];
|
|
760
|
+
expect(evt.finding_id).toBe("f-shape-reopen");
|
|
761
|
+
expect(evt.event).toBe("reopened");
|
|
762
|
+
expect(typeof evt.by).toBe("string");
|
|
763
|
+
expect(evt.principal_type).toBe("system");
|
|
764
|
+
expect(typeof evt.at).toBe("string");
|
|
765
|
+
expect(typeof evt.against_fingerprint).toBe("string");
|
|
766
|
+
expect(evt.identity_scheme_version).toBe(IDENTITY_SCHEME_VERSION);
|
|
767
|
+
});
|
|
768
|
+
it("emitted 'resolved' event has all required LedgerEvent fields", () => {
|
|
769
|
+
const ledger = buildLedger([
|
|
770
|
+
makeEvent({
|
|
771
|
+
finding_id: "f-shape-resolved",
|
|
772
|
+
event: "accept",
|
|
773
|
+
against_fingerprint: "fp-shape",
|
|
774
|
+
}),
|
|
775
|
+
]);
|
|
776
|
+
const { emit } = reconcile([], ledger, NOW);
|
|
777
|
+
expect(emit).toHaveLength(1);
|
|
778
|
+
const evt = emit[0];
|
|
779
|
+
expect(evt.finding_id).toBe("f-shape-resolved");
|
|
780
|
+
expect(evt.event).toBe("resolved");
|
|
781
|
+
expect(evt.principal_type).toBe("system");
|
|
782
|
+
expect(evt.by).toBe("system");
|
|
783
|
+
expect(evt.at).toBe(NOW.toISOString());
|
|
784
|
+
expect(evt.against_fingerprint).toBe("fp-shape");
|
|
785
|
+
expect(evt.identity_scheme_version).toBe(IDENTITY_SCHEME_VERSION);
|
|
786
|
+
});
|
|
787
|
+
});
|
|
788
|
+
//# sourceMappingURL=reconcile.test.js.map
|