daftari 3.6.0 → 3.8.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.
Files changed (289) hide show
  1. package/CHANGELOG.md +34 -0
  2. package/README.md +4 -0
  3. package/dist/access/rbac.d.ts +1 -0
  4. package/dist/access/rbac.d.ts.map +1 -1
  5. package/dist/access/rbac.js +8 -0
  6. package/dist/access/rbac.js.map +1 -1
  7. package/dist/attest/bundle.d.ts +53 -0
  8. package/dist/attest/bundle.d.ts.map +1 -0
  9. package/dist/attest/bundle.js +141 -0
  10. package/dist/attest/bundle.js.map +1 -0
  11. package/dist/attest/index.d.ts +2 -0
  12. package/dist/attest/index.d.ts.map +1 -0
  13. package/dist/attest/index.js +139 -0
  14. package/dist/attest/index.js.map +1 -0
  15. package/dist/attest/sign.d.ts +16 -0
  16. package/dist/attest/sign.d.ts.map +1 -0
  17. package/dist/attest/sign.js +75 -0
  18. package/dist/attest/sign.js.map +1 -0
  19. package/dist/attest/verify.d.ts +21 -0
  20. package/dist/attest/verify.d.ts.map +1 -0
  21. package/dist/attest/verify.js +148 -0
  22. package/dist/attest/verify.js.map +1 -0
  23. package/dist/board/board.d.ts +37 -0
  24. package/dist/board/board.d.ts.map +1 -0
  25. package/dist/board/board.js +233 -0
  26. package/dist/board/board.js.map +1 -0
  27. package/dist/board/board.test.d.ts +2 -0
  28. package/dist/board/board.test.d.ts.map +1 -0
  29. package/dist/board/board.test.js +753 -0
  30. package/dist/board/board.test.js.map +1 -0
  31. package/dist/board/dormancy.test.d.ts +2 -0
  32. package/dist/board/dormancy.test.d.ts.map +1 -0
  33. package/dist/board/dormancy.test.js +79 -0
  34. package/dist/board/dormancy.test.js.map +1 -0
  35. package/dist/board/identity.d.ts +5 -0
  36. package/dist/board/identity.d.ts.map +1 -0
  37. package/dist/board/identity.js +146 -0
  38. package/dist/board/identity.js.map +1 -0
  39. package/dist/board/identity.test.d.ts +2 -0
  40. package/dist/board/identity.test.d.ts.map +1 -0
  41. package/dist/board/identity.test.js +291 -0
  42. package/dist/board/identity.test.js.map +1 -0
  43. package/dist/board/ledger.d.ts +41 -0
  44. package/dist/board/ledger.d.ts.map +1 -0
  45. package/dist/board/ledger.js +197 -0
  46. package/dist/board/ledger.js.map +1 -0
  47. package/dist/board/ledger.test.d.ts +2 -0
  48. package/dist/board/ledger.test.d.ts.map +1 -0
  49. package/dist/board/ledger.test.js +873 -0
  50. package/dist/board/ledger.test.js.map +1 -0
  51. package/dist/board/principals.d.ts +4 -0
  52. package/dist/board/principals.d.ts.map +1 -0
  53. package/dist/board/principals.js +37 -0
  54. package/dist/board/principals.js.map +1 -0
  55. package/dist/board/principals.test.d.ts +2 -0
  56. package/dist/board/principals.test.d.ts.map +1 -0
  57. package/dist/board/principals.test.js +296 -0
  58. package/dist/board/principals.test.js.map +1 -0
  59. package/dist/board/reconcile.d.ts +12 -0
  60. package/dist/board/reconcile.d.ts.map +1 -0
  61. package/dist/board/reconcile.js +293 -0
  62. package/dist/board/reconcile.js.map +1 -0
  63. package/dist/board/reconcile.test.d.ts +2 -0
  64. package/dist/board/reconcile.test.d.ts.map +1 -0
  65. package/dist/board/reconcile.test.js +788 -0
  66. package/dist/board/reconcile.test.js.map +1 -0
  67. package/dist/board/sources/index.d.ts +24 -0
  68. package/dist/board/sources/index.d.ts.map +1 -0
  69. package/dist/board/sources/index.js +64 -0
  70. package/dist/board/sources/index.js.map +1 -0
  71. package/dist/board/sources/lint.d.ts +3 -0
  72. package/dist/board/sources/lint.d.ts.map +1 -0
  73. package/dist/board/sources/lint.js +218 -0
  74. package/dist/board/sources/lint.js.map +1 -0
  75. package/dist/board/sources/lint.test.d.ts +2 -0
  76. package/dist/board/sources/lint.test.d.ts.map +1 -0
  77. package/dist/board/sources/lint.test.js +616 -0
  78. package/dist/board/sources/lint.test.js.map +1 -0
  79. package/dist/board/sources/staged.d.ts +3 -0
  80. package/dist/board/sources/staged.d.ts.map +1 -0
  81. package/dist/board/sources/staged.js +116 -0
  82. package/dist/board/sources/staged.js.map +1 -0
  83. package/dist/board/sources/staged.test.d.ts +2 -0
  84. package/dist/board/sources/staged.test.d.ts.map +1 -0
  85. package/dist/board/sources/staged.test.js +418 -0
  86. package/dist/board/sources/staged.test.js.map +1 -0
  87. package/dist/board/sources/staleness.d.ts +43 -0
  88. package/dist/board/sources/staleness.d.ts.map +1 -0
  89. package/dist/board/sources/staleness.js +346 -0
  90. package/dist/board/sources/staleness.js.map +1 -0
  91. package/dist/board/sources/staleness.test.d.ts +2 -0
  92. package/dist/board/sources/staleness.test.d.ts.map +1 -0
  93. package/dist/board/sources/staleness.test.js +923 -0
  94. package/dist/board/sources/staleness.test.js.map +1 -0
  95. package/dist/board/sources/tension.d.ts +3 -0
  96. package/dist/board/sources/tension.d.ts.map +1 -0
  97. package/dist/board/sources/tension.js +152 -0
  98. package/dist/board/sources/tension.js.map +1 -0
  99. package/dist/board/sources/tension.test.d.ts +2 -0
  100. package/dist/board/sources/tension.test.d.ts.map +1 -0
  101. package/dist/board/sources/tension.test.js +440 -0
  102. package/dist/board/sources/tension.test.js.map +1 -0
  103. package/dist/board/sources/tier2.d.ts +17 -0
  104. package/dist/board/sources/tier2.d.ts.map +1 -0
  105. package/dist/board/sources/tier2.js +233 -0
  106. package/dist/board/sources/tier2.js.map +1 -0
  107. package/dist/board/sources/tier2.test.d.ts +2 -0
  108. package/dist/board/sources/tier2.test.d.ts.map +1 -0
  109. package/dist/board/sources/tier2.test.js +480 -0
  110. package/dist/board/sources/tier2.test.js.map +1 -0
  111. package/dist/board/types.d.ts +161 -0
  112. package/dist/board/types.d.ts.map +1 -0
  113. package/dist/board/types.js +37 -0
  114. package/dist/board/types.js.map +1 -0
  115. package/dist/canon/index.d.ts +3 -1
  116. package/dist/canon/index.d.ts.map +1 -1
  117. package/dist/canon/index.js +35 -8
  118. package/dist/canon/index.js.map +1 -1
  119. package/dist/canon/types.d.ts +3 -0
  120. package/dist/canon/types.d.ts.map +1 -1
  121. package/dist/cli.d.ts.map +1 -1
  122. package/dist/cli.js +15 -0
  123. package/dist/cli.js.map +1 -1
  124. package/dist/consolidate/birth.d.ts +1 -1
  125. package/dist/consolidate/birth.d.ts.map +1 -1
  126. package/dist/consolidate/birth.js +22 -0
  127. package/dist/consolidate/birth.js.map +1 -1
  128. package/dist/consolidate/edge-write.d.ts +11 -0
  129. package/dist/consolidate/edge-write.d.ts.map +1 -1
  130. package/dist/consolidate/edge-write.js +41 -0
  131. package/dist/consolidate/edge-write.js.map +1 -1
  132. package/dist/consolidate/index.js +5 -2
  133. package/dist/consolidate/index.js.map +1 -1
  134. package/dist/consolidate/revision.d.ts +4 -2
  135. package/dist/consolidate/revision.d.ts.map +1 -1
  136. package/dist/consolidate/revision.js +23 -0
  137. package/dist/consolidate/revision.js.map +1 -1
  138. package/dist/curation/edge-staleness.d.ts +4 -2
  139. package/dist/curation/edge-staleness.d.ts.map +1 -1
  140. package/dist/curation/edge-staleness.js +36 -3
  141. package/dist/curation/edge-staleness.js.map +1 -1
  142. package/dist/curation/edges.d.ts +7 -0
  143. package/dist/curation/edges.d.ts.map +1 -1
  144. package/dist/curation/edges.js +13 -7
  145. package/dist/curation/edges.js.map +1 -1
  146. package/dist/curation/staged-actions.d.ts +2 -0
  147. package/dist/curation/staged-actions.d.ts.map +1 -1
  148. package/dist/curation/staged-actions.js +5 -0
  149. package/dist/curation/staged-actions.js.map +1 -1
  150. package/dist/curation/tension-access.d.ts +1 -0
  151. package/dist/curation/tension-access.d.ts.map +1 -1
  152. package/dist/curation/tension-access.js +18 -1
  153. package/dist/curation/tension-access.js.map +1 -1
  154. package/dist/curation/tension.d.ts +3 -0
  155. package/dist/curation/tension.d.ts.map +1 -1
  156. package/dist/curation/tension.js +36 -0
  157. package/dist/curation/tension.js.map +1 -1
  158. package/dist/curation/vault-docs.d.ts +1 -0
  159. package/dist/curation/vault-docs.d.ts.map +1 -1
  160. package/dist/curation/vault-docs.js +1 -0
  161. package/dist/curation/vault-docs.js.map +1 -1
  162. package/dist/distill/adapters/claude-session.d.ts +6 -0
  163. package/dist/distill/adapters/claude-session.d.ts.map +1 -0
  164. package/dist/distill/adapters/claude-session.js +71 -0
  165. package/dist/distill/adapters/claude-session.js.map +1 -0
  166. package/dist/distill/cli.d.ts.map +1 -1
  167. package/dist/distill/cli.js +119 -9
  168. package/dist/distill/cli.js.map +1 -1
  169. package/dist/distill/cost.d.ts +6 -0
  170. package/dist/distill/cost.d.ts.map +1 -1
  171. package/dist/distill/cost.js +2 -3
  172. package/dist/distill/cost.js.map +1 -1
  173. package/dist/distill/extract.d.ts +52 -0
  174. package/dist/distill/extract.d.ts.map +1 -1
  175. package/dist/distill/extract.js +24 -2
  176. package/dist/distill/extract.js.map +1 -1
  177. package/dist/distill/index.d.ts +1 -0
  178. package/dist/distill/index.d.ts.map +1 -1
  179. package/dist/distill/index.js +3 -0
  180. package/dist/distill/index.js.map +1 -1
  181. package/dist/distill/propose.d.ts +67 -6
  182. package/dist/distill/propose.d.ts.map +1 -1
  183. package/dist/distill/propose.js +142 -32
  184. package/dist/distill/propose.js.map +1 -1
  185. package/dist/distill/reader-fingerprint.d.ts +69 -0
  186. package/dist/distill/reader-fingerprint.d.ts.map +1 -0
  187. package/dist/distill/reader-fingerprint.js +145 -0
  188. package/dist/distill/reader-fingerprint.js.map +1 -0
  189. package/dist/distill/receipt-store.d.ts +5 -0
  190. package/dist/distill/receipt-store.d.ts.map +1 -0
  191. package/dist/distill/receipt-store.js +24 -0
  192. package/dist/distill/receipt-store.js.map +1 -0
  193. package/dist/eval/llm-openrouter.d.ts.map +1 -1
  194. package/dist/eval/llm-openrouter.js +4 -0
  195. package/dist/eval/llm-openrouter.js.map +1 -1
  196. package/dist/eval/llm.d.ts +22 -0
  197. package/dist/eval/llm.d.ts.map +1 -1
  198. package/dist/eval/llm.js +94 -24
  199. package/dist/eval/llm.js.map +1 -1
  200. package/dist/federation/classification.d.ts.map +1 -1
  201. package/dist/federation/classification.js +3 -0
  202. package/dist/federation/classification.js.map +1 -1
  203. package/dist/index.d.ts.map +1 -1
  204. package/dist/index.js +31 -0
  205. package/dist/index.js.map +1 -1
  206. package/dist/search/coverage.d.ts +5 -1
  207. package/dist/search/coverage.d.ts.map +1 -1
  208. package/dist/search/coverage.js +47 -15
  209. package/dist/search/coverage.js.map +1 -1
  210. package/dist/search/hybrid.d.ts +7 -1
  211. package/dist/search/hybrid.d.ts.map +1 -1
  212. package/dist/search/hybrid.js +31 -8
  213. package/dist/search/hybrid.js.map +1 -1
  214. package/dist/search/retrieval-metrics.d.ts +5 -0
  215. package/dist/search/retrieval-metrics.d.ts.map +1 -0
  216. package/dist/search/retrieval-metrics.js +60 -0
  217. package/dist/search/retrieval-metrics.js.map +1 -0
  218. package/dist/search/suppression.d.ts +9 -0
  219. package/dist/search/suppression.d.ts.map +1 -0
  220. package/dist/search/suppression.js +107 -0
  221. package/dist/search/suppression.js.map +1 -0
  222. package/dist/serve/index.d.ts.map +1 -1
  223. package/dist/serve/index.js +286 -4
  224. package/dist/serve/index.js.map +1 -1
  225. package/dist/server.d.ts.map +1 -1
  226. package/dist/server.js +4 -6
  227. package/dist/server.js.map +1 -1
  228. package/dist/storage/index-db.d.ts +1 -0
  229. package/dist/storage/index-db.d.ts.map +1 -1
  230. package/dist/storage/index-db.js.map +1 -1
  231. package/dist/tools/board.d.ts +32 -0
  232. package/dist/tools/board.d.ts.map +1 -0
  233. package/dist/tools/board.js +615 -0
  234. package/dist/tools/board.js.map +1 -0
  235. package/dist/tools/board.test.d.ts +2 -0
  236. package/dist/tools/board.test.d.ts.map +1 -0
  237. package/dist/tools/board.test.js +964 -0
  238. package/dist/tools/board.test.js.map +1 -0
  239. package/dist/tools/edge-staleness.d.ts.map +1 -1
  240. package/dist/tools/edge-staleness.js +18 -4
  241. package/dist/tools/edge-staleness.js.map +1 -1
  242. package/dist/tools/positions.d.ts.map +1 -1
  243. package/dist/tools/positions.js +6 -0
  244. package/dist/tools/positions.js.map +1 -1
  245. package/dist/tools/read.d.ts +2 -0
  246. package/dist/tools/read.d.ts.map +1 -1
  247. package/dist/tools/read.js +43 -13
  248. package/dist/tools/read.js.map +1 -1
  249. package/dist/tools/receipt.d.ts +6 -0
  250. package/dist/tools/receipt.d.ts.map +1 -1
  251. package/dist/tools/receipt.js +47 -1
  252. package/dist/tools/receipt.js.map +1 -1
  253. package/dist/tools/search.d.ts.map +1 -1
  254. package/dist/tools/search.js +79 -17
  255. package/dist/tools/search.js.map +1 -1
  256. package/dist/tools/staged-actions.d.ts.map +1 -1
  257. package/dist/tools/staged-actions.js +26 -2
  258. package/dist/tools/staged-actions.js.map +1 -1
  259. package/dist/tools/write.d.ts +1 -0
  260. package/dist/tools/write.d.ts.map +1 -1
  261. package/dist/tools/write.js +475 -227
  262. package/dist/tools/write.js.map +1 -1
  263. package/dist/utils/config.d.ts +21 -0
  264. package/dist/utils/config.d.ts.map +1 -1
  265. package/dist/utils/config.js +104 -1
  266. package/dist/utils/config.js.map +1 -1
  267. package/dist/utils/git.d.ts +18 -2
  268. package/dist/utils/git.d.ts.map +1 -1
  269. package/dist/utils/git.js +116 -13
  270. package/dist/utils/git.js.map +1 -1
  271. package/dist/version.d.ts +2 -0
  272. package/dist/version.d.ts.map +1 -0
  273. package/dist/version.js +8 -0
  274. package/dist/version.js.map +1 -0
  275. package/dist/view/board-page.d.ts +4 -0
  276. package/dist/view/board-page.d.ts.map +1 -0
  277. package/dist/view/board-page.js +278 -0
  278. package/dist/view/board-page.js.map +1 -0
  279. package/dist/view/board-page.test.d.ts +2 -0
  280. package/dist/view/board-page.test.d.ts.map +1 -0
  281. package/dist/view/board-page.test.js +548 -0
  282. package/dist/view/board-page.test.js.map +1 -0
  283. package/dist/view/pages.d.ts.map +1 -1
  284. package/dist/view/pages.js +13 -2
  285. package/dist/view/pages.js.map +1 -1
  286. package/dist/view/render.d.ts.map +1 -1
  287. package/dist/view/render.js +2 -1
  288. package/dist/view/render.js.map +1 -1
  289. 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