daftari 3.7.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.
- package/CHANGELOG.md +34 -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.map +1 -1
- package/dist/serve/index.js +273 -4
- package/dist/serve/index.js.map +1 -1
- 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 +13 -0
- package/dist/utils/config.d.ts.map +1 -1
- package/dist/utils/config.js +88 -0
- 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 +278 -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,873 @@
|
|
|
1
|
+
// ledger.test.ts — TDD test suite for U3: Disposition ledger.
|
|
2
|
+
//
|
|
3
|
+
// All scenarios from the plan are covered below. Tests use real file I/O via a
|
|
4
|
+
// temp directory so the full round-trip (write → new load call → identical
|
|
5
|
+
// state) is exercised, proving restart survival.
|
|
6
|
+
//
|
|
7
|
+
// Run with:
|
|
8
|
+
// npx vitest run src/board/ledger.test.ts
|
|
9
|
+
import { mkdtempSync, rmSync } from "node:fs";
|
|
10
|
+
import { tmpdir } from "node:os";
|
|
11
|
+
import { join } from "node:path";
|
|
12
|
+
import { afterEach, beforeEach, describe, expect, it } from "vitest";
|
|
13
|
+
import { IDENTITY_SCHEME_VERSION } from "./identity.js";
|
|
14
|
+
import { appendEvent, boardDispositionsPath, currentDisposition, eventTimestamps, loadLedger, } from "./ledger.js";
|
|
15
|
+
// ---------------------------------------------------------------------------
|
|
16
|
+
// Helpers
|
|
17
|
+
// ---------------------------------------------------------------------------
|
|
18
|
+
function makeEvent(overrides) {
|
|
19
|
+
return {
|
|
20
|
+
finding_id: overrides.finding_id,
|
|
21
|
+
event: overrides.event,
|
|
22
|
+
by: overrides.by ?? "human:alice",
|
|
23
|
+
principal_type: overrides.principal_type ?? "human",
|
|
24
|
+
at: overrides.at ?? new Date().toISOString(),
|
|
25
|
+
against_fingerprint: overrides.against_fingerprint ?? "fp-abc123",
|
|
26
|
+
...(overrides.rationale !== undefined ? { rationale: overrides.rationale } : {}),
|
|
27
|
+
...(overrides.expiry !== undefined ? { expiry: overrides.expiry } : {}),
|
|
28
|
+
...(overrides.owner !== undefined ? { owner: overrides.owner } : {}),
|
|
29
|
+
};
|
|
30
|
+
}
|
|
31
|
+
// ---------------------------------------------------------------------------
|
|
32
|
+
// Fixture setup
|
|
33
|
+
// ---------------------------------------------------------------------------
|
|
34
|
+
let vaultRoot;
|
|
35
|
+
beforeEach(() => {
|
|
36
|
+
vaultRoot = mkdtempSync(join(tmpdir(), "daftari-ledger-"));
|
|
37
|
+
});
|
|
38
|
+
afterEach(() => {
|
|
39
|
+
rmSync(vaultRoot, { recursive: true, force: true });
|
|
40
|
+
});
|
|
41
|
+
// ---------------------------------------------------------------------------
|
|
42
|
+
// 1. boardDispositionsPath — path helper
|
|
43
|
+
// ---------------------------------------------------------------------------
|
|
44
|
+
describe("boardDispositionsPath", () => {
|
|
45
|
+
it("returns .daftari/board-dispositions.jsonl under vaultRoot", () => {
|
|
46
|
+
expect(boardDispositionsPath("/vault")).toBe("/vault/.daftari/board-dispositions.jsonl");
|
|
47
|
+
});
|
|
48
|
+
});
|
|
49
|
+
// ---------------------------------------------------------------------------
|
|
50
|
+
// 2. appendEvent — stamps identity_scheme_version; round-trips through disk
|
|
51
|
+
// ---------------------------------------------------------------------------
|
|
52
|
+
describe("appendEvent + loadLedger — basic round-trip", () => {
|
|
53
|
+
it("appends one event; loadLedger returns it with identity_scheme_version stamped", async () => {
|
|
54
|
+
const input = makeEvent({ finding_id: "finding-001", event: "new" });
|
|
55
|
+
const result = await appendEvent(vaultRoot, input);
|
|
56
|
+
expect(result.ok).toBe(true);
|
|
57
|
+
if (!result.ok)
|
|
58
|
+
return;
|
|
59
|
+
expect(result.value.identity_scheme_version).toBe(IDENTITY_SCHEME_VERSION);
|
|
60
|
+
expect(result.value.finding_id).toBe("finding-001");
|
|
61
|
+
expect(result.value.event).toBe("new");
|
|
62
|
+
// Reload from disk — simulates process restart
|
|
63
|
+
const loaded = await loadLedger(vaultRoot);
|
|
64
|
+
expect(loaded.ok).toBe(true);
|
|
65
|
+
if (!loaded.ok)
|
|
66
|
+
return;
|
|
67
|
+
const events = loaded.value.byFinding.get("finding-001");
|
|
68
|
+
expect(events).toBeDefined();
|
|
69
|
+
expect(events).toHaveLength(1);
|
|
70
|
+
const evt = events[0];
|
|
71
|
+
expect(evt.identity_scheme_version).toBe(IDENTITY_SCHEME_VERSION);
|
|
72
|
+
expect(evt.event).toBe("new");
|
|
73
|
+
expect(evt.against_fingerprint).toBe("fp-abc123");
|
|
74
|
+
});
|
|
75
|
+
it("appends multiple events for one finding; order is preserved", async () => {
|
|
76
|
+
const e1 = makeEvent({ finding_id: "f-1", event: "new", at: "2024-01-01T00:00:00Z" });
|
|
77
|
+
const e2 = makeEvent({ finding_id: "f-1", event: "accept", at: "2024-01-02T00:00:00Z" });
|
|
78
|
+
const e3 = makeEvent({ finding_id: "f-1", event: "dismiss", at: "2024-01-03T00:00:00Z" });
|
|
79
|
+
await appendEvent(vaultRoot, e1);
|
|
80
|
+
await appendEvent(vaultRoot, e2);
|
|
81
|
+
await appendEvent(vaultRoot, e3);
|
|
82
|
+
const loaded = await loadLedger(vaultRoot);
|
|
83
|
+
expect(loaded.ok).toBe(true);
|
|
84
|
+
if (!loaded.ok)
|
|
85
|
+
return;
|
|
86
|
+
const events = loaded.value.byFinding.get("f-1");
|
|
87
|
+
expect(events).toHaveLength(3);
|
|
88
|
+
expect(events?.map((e) => e.event)).toEqual(["new", "accept", "dismiss"]);
|
|
89
|
+
});
|
|
90
|
+
it("appends events for multiple findings; each finding's list is independent", async () => {
|
|
91
|
+
await appendEvent(vaultRoot, makeEvent({ finding_id: "f-A", event: "new" }));
|
|
92
|
+
await appendEvent(vaultRoot, makeEvent({ finding_id: "f-B", event: "new" }));
|
|
93
|
+
await appendEvent(vaultRoot, makeEvent({ finding_id: "f-A", event: "accept" }));
|
|
94
|
+
const loaded = await loadLedger(vaultRoot);
|
|
95
|
+
expect(loaded.ok).toBe(true);
|
|
96
|
+
if (!loaded.ok)
|
|
97
|
+
return;
|
|
98
|
+
expect(loaded.value.byFinding.get("f-A")).toHaveLength(2);
|
|
99
|
+
expect(loaded.value.byFinding.get("f-B")).toHaveLength(1);
|
|
100
|
+
});
|
|
101
|
+
it("missing log file is not an error — returns empty map", async () => {
|
|
102
|
+
const loaded = await loadLedger(vaultRoot);
|
|
103
|
+
expect(loaded.ok).toBe(true);
|
|
104
|
+
if (!loaded.ok)
|
|
105
|
+
return;
|
|
106
|
+
expect(loaded.value.byFinding.size).toBe(0);
|
|
107
|
+
expect(loaded.value.flat).toHaveLength(0);
|
|
108
|
+
});
|
|
109
|
+
it("flat list in loadLedger contains all events in append order", async () => {
|
|
110
|
+
await appendEvent(vaultRoot, makeEvent({ finding_id: "f-A", event: "new" }));
|
|
111
|
+
await appendEvent(vaultRoot, makeEvent({ finding_id: "f-B", event: "new" }));
|
|
112
|
+
await appendEvent(vaultRoot, makeEvent({ finding_id: "f-A", event: "accept" }));
|
|
113
|
+
const loaded = await loadLedger(vaultRoot);
|
|
114
|
+
expect(loaded.ok).toBe(true);
|
|
115
|
+
if (!loaded.ok)
|
|
116
|
+
return;
|
|
117
|
+
expect(loaded.value.flat).toHaveLength(3);
|
|
118
|
+
expect(loaded.value.flat.map((e) => e.finding_id)).toEqual(["f-A", "f-B", "f-A"]);
|
|
119
|
+
});
|
|
120
|
+
});
|
|
121
|
+
// ---------------------------------------------------------------------------
|
|
122
|
+
// 3. Restart survival — write then load in a fresh call (R30)
|
|
123
|
+
// ---------------------------------------------------------------------------
|
|
124
|
+
describe("restart survival (R30)", () => {
|
|
125
|
+
it("reload from disk after write yields identical state", async () => {
|
|
126
|
+
const events = [
|
|
127
|
+
makeEvent({
|
|
128
|
+
finding_id: "r30",
|
|
129
|
+
event: "new",
|
|
130
|
+
at: "2024-06-01T10:00:00Z",
|
|
131
|
+
against_fingerprint: "fp-v1",
|
|
132
|
+
}),
|
|
133
|
+
makeEvent({
|
|
134
|
+
finding_id: "r30",
|
|
135
|
+
event: "accept",
|
|
136
|
+
at: "2024-06-01T11:00:00Z",
|
|
137
|
+
against_fingerprint: "fp-v1",
|
|
138
|
+
rationale: "looks good",
|
|
139
|
+
}),
|
|
140
|
+
makeEvent({
|
|
141
|
+
finding_id: "r30",
|
|
142
|
+
event: "defer",
|
|
143
|
+
at: "2024-06-01T12:00:00Z",
|
|
144
|
+
against_fingerprint: "fp-v1",
|
|
145
|
+
expiry: "2024-07-01T00:00:00Z",
|
|
146
|
+
}),
|
|
147
|
+
];
|
|
148
|
+
for (const e of events) {
|
|
149
|
+
await appendEvent(vaultRoot, e);
|
|
150
|
+
}
|
|
151
|
+
// First load
|
|
152
|
+
const load1 = await loadLedger(vaultRoot);
|
|
153
|
+
expect(load1.ok).toBe(true);
|
|
154
|
+
if (!load1.ok)
|
|
155
|
+
return;
|
|
156
|
+
const firstEvents = load1.value.byFinding.get("r30");
|
|
157
|
+
// Second load — simulates process restart
|
|
158
|
+
const load2 = await loadLedger(vaultRoot);
|
|
159
|
+
expect(load2.ok).toBe(true);
|
|
160
|
+
if (!load2.ok)
|
|
161
|
+
return;
|
|
162
|
+
const secondEvents = load2.value.byFinding.get("r30");
|
|
163
|
+
expect(JSON.stringify(secondEvents)).toBe(JSON.stringify(firstEvents));
|
|
164
|
+
});
|
|
165
|
+
});
|
|
166
|
+
// ---------------------------------------------------------------------------
|
|
167
|
+
// 4. currentDisposition — fold history to latest state
|
|
168
|
+
// ---------------------------------------------------------------------------
|
|
169
|
+
describe("currentDisposition — accept → defer → dismiss folds to dismissed (R30)", () => {
|
|
170
|
+
it("returns dismissed after accept → defer → dismiss sequence", async () => {
|
|
171
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
172
|
+
finding_id: "f-seq",
|
|
173
|
+
event: "new",
|
|
174
|
+
at: "2024-01-01T00:00:00Z",
|
|
175
|
+
against_fingerprint: "fp-1",
|
|
176
|
+
}));
|
|
177
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
178
|
+
finding_id: "f-seq",
|
|
179
|
+
event: "accept",
|
|
180
|
+
at: "2024-01-02T00:00:00Z",
|
|
181
|
+
against_fingerprint: "fp-1",
|
|
182
|
+
}));
|
|
183
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
184
|
+
finding_id: "f-seq",
|
|
185
|
+
event: "defer",
|
|
186
|
+
at: "2024-01-03T00:00:00Z",
|
|
187
|
+
against_fingerprint: "fp-1",
|
|
188
|
+
expiry: "2024-06-01T00:00:00Z",
|
|
189
|
+
}));
|
|
190
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
191
|
+
finding_id: "f-seq",
|
|
192
|
+
event: "dismiss",
|
|
193
|
+
at: "2024-01-04T00:00:00Z",
|
|
194
|
+
against_fingerprint: "fp-2",
|
|
195
|
+
}));
|
|
196
|
+
const loaded = await loadLedger(vaultRoot);
|
|
197
|
+
expect(loaded.ok).toBe(true);
|
|
198
|
+
if (!loaded.ok)
|
|
199
|
+
return;
|
|
200
|
+
const events = loaded.value.byFinding.get("f-seq");
|
|
201
|
+
const disp = currentDisposition(events);
|
|
202
|
+
expect(disp.event).toBe("dismiss");
|
|
203
|
+
expect(disp.against_fingerprint).toBe("fp-2");
|
|
204
|
+
// A plain dismiss (no expiry field) establishes a new disposition with no timer:
|
|
205
|
+
// it REPLACES the prior defer's standing expiry — permanent dismissal carries no timer.
|
|
206
|
+
expect(disp.expiry).toBeUndefined();
|
|
207
|
+
});
|
|
208
|
+
it("full ordered history is preserved — same state survives reload (R30)", async () => {
|
|
209
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
210
|
+
finding_id: "f-reload",
|
|
211
|
+
event: "new",
|
|
212
|
+
at: "2024-01-01T00:00:00Z",
|
|
213
|
+
against_fingerprint: "fp-0",
|
|
214
|
+
}));
|
|
215
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
216
|
+
finding_id: "f-reload",
|
|
217
|
+
event: "accept",
|
|
218
|
+
at: "2024-01-02T00:00:00Z",
|
|
219
|
+
against_fingerprint: "fp-0",
|
|
220
|
+
}));
|
|
221
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
222
|
+
finding_id: "f-reload",
|
|
223
|
+
event: "dismiss",
|
|
224
|
+
at: "2024-01-03T00:00:00Z",
|
|
225
|
+
against_fingerprint: "fp-0",
|
|
226
|
+
}));
|
|
227
|
+
// Reload (restart simulation) and fold again
|
|
228
|
+
const loaded = await loadLedger(vaultRoot);
|
|
229
|
+
expect(loaded.ok).toBe(true);
|
|
230
|
+
if (!loaded.ok)
|
|
231
|
+
return;
|
|
232
|
+
const events = loaded.value.byFinding.get("f-reload");
|
|
233
|
+
expect(events).toHaveLength(3);
|
|
234
|
+
const disp = currentDisposition(events);
|
|
235
|
+
expect(disp.event).toBe("dismiss");
|
|
236
|
+
});
|
|
237
|
+
});
|
|
238
|
+
describe("currentDisposition — against_fingerprint comes from latest event (R10)", () => {
|
|
239
|
+
it("carries the fingerprint from the most recent disposition event", async () => {
|
|
240
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
241
|
+
finding_id: "f-fp",
|
|
242
|
+
event: "new",
|
|
243
|
+
against_fingerprint: "fp-v1",
|
|
244
|
+
at: "2024-01-01T00:00:00Z",
|
|
245
|
+
}));
|
|
246
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
247
|
+
finding_id: "f-fp",
|
|
248
|
+
event: "accept",
|
|
249
|
+
against_fingerprint: "fp-v2",
|
|
250
|
+
at: "2024-01-02T00:00:00Z",
|
|
251
|
+
}));
|
|
252
|
+
const loaded = await loadLedger(vaultRoot);
|
|
253
|
+
expect(loaded.ok).toBe(true);
|
|
254
|
+
if (!loaded.ok)
|
|
255
|
+
return;
|
|
256
|
+
const events = loaded.value.byFinding.get("f-fp");
|
|
257
|
+
const disp = currentDisposition(events);
|
|
258
|
+
expect(disp.against_fingerprint).toBe("fp-v2");
|
|
259
|
+
});
|
|
260
|
+
});
|
|
261
|
+
describe("currentDisposition — expiry exposure", () => {
|
|
262
|
+
it("expiry from defer is exposed on currentDisposition", async () => {
|
|
263
|
+
const expiry = "2025-12-31T23:59:59Z";
|
|
264
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
265
|
+
finding_id: "f-exp",
|
|
266
|
+
event: "new",
|
|
267
|
+
at: "2024-01-01T00:00:00Z",
|
|
268
|
+
against_fingerprint: "fp-1",
|
|
269
|
+
}));
|
|
270
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
271
|
+
finding_id: "f-exp",
|
|
272
|
+
event: "defer",
|
|
273
|
+
at: "2024-01-02T00:00:00Z",
|
|
274
|
+
against_fingerprint: "fp-1",
|
|
275
|
+
expiry,
|
|
276
|
+
}));
|
|
277
|
+
const loaded = await loadLedger(vaultRoot);
|
|
278
|
+
expect(loaded.ok).toBe(true);
|
|
279
|
+
if (!loaded.ok)
|
|
280
|
+
return;
|
|
281
|
+
const events = loaded.value.byFinding.get("f-exp");
|
|
282
|
+
const disp = currentDisposition(events);
|
|
283
|
+
expect(disp.event).toBe("defer");
|
|
284
|
+
expect(disp.expiry).toBe(expiry);
|
|
285
|
+
});
|
|
286
|
+
it("dismiss with past-dated expiry: expired flag is true (R9 feed)", async () => {
|
|
287
|
+
const pastExpiry = "2020-01-01T00:00:00Z";
|
|
288
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
289
|
+
finding_id: "f-past",
|
|
290
|
+
event: "dismiss",
|
|
291
|
+
at: "2019-01-01T00:00:00Z",
|
|
292
|
+
against_fingerprint: "fp-1",
|
|
293
|
+
expiry: pastExpiry,
|
|
294
|
+
}));
|
|
295
|
+
const loaded = await loadLedger(vaultRoot);
|
|
296
|
+
expect(loaded.ok).toBe(true);
|
|
297
|
+
if (!loaded.ok)
|
|
298
|
+
return;
|
|
299
|
+
const events = loaded.value.byFinding.get("f-past");
|
|
300
|
+
const now = new Date("2024-06-01T00:00:00Z");
|
|
301
|
+
const disp = currentDisposition(events, now);
|
|
302
|
+
expect(disp.expiry).toBe(pastExpiry);
|
|
303
|
+
expect(disp.expired).toBe(true);
|
|
304
|
+
});
|
|
305
|
+
it("defer with future expiry: expired flag is false", async () => {
|
|
306
|
+
const futureExpiry = "2099-01-01T00:00:00Z";
|
|
307
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
308
|
+
finding_id: "f-future",
|
|
309
|
+
event: "defer",
|
|
310
|
+
at: "2024-01-01T00:00:00Z",
|
|
311
|
+
against_fingerprint: "fp-1",
|
|
312
|
+
expiry: futureExpiry,
|
|
313
|
+
}));
|
|
314
|
+
const loaded = await loadLedger(vaultRoot);
|
|
315
|
+
expect(loaded.ok).toBe(true);
|
|
316
|
+
if (!loaded.ok)
|
|
317
|
+
return;
|
|
318
|
+
const events = loaded.value.byFinding.get("f-future");
|
|
319
|
+
const now = new Date("2024-06-01T00:00:00Z");
|
|
320
|
+
const disp = currentDisposition(events, now);
|
|
321
|
+
expect(disp.expired).toBe(false);
|
|
322
|
+
});
|
|
323
|
+
it("no expiry on event: expired is false", async () => {
|
|
324
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
325
|
+
finding_id: "f-noexp",
|
|
326
|
+
event: "accept",
|
|
327
|
+
at: "2024-01-01T00:00:00Z",
|
|
328
|
+
against_fingerprint: "fp-1",
|
|
329
|
+
}));
|
|
330
|
+
const loaded = await loadLedger(vaultRoot);
|
|
331
|
+
expect(loaded.ok).toBe(true);
|
|
332
|
+
if (!loaded.ok)
|
|
333
|
+
return;
|
|
334
|
+
const events = loaded.value.byFinding.get("f-noexp");
|
|
335
|
+
const disp = currentDisposition(events, new Date());
|
|
336
|
+
expect(disp.expired).toBe(false);
|
|
337
|
+
});
|
|
338
|
+
});
|
|
339
|
+
describe("currentDisposition — owner tracking", () => {
|
|
340
|
+
it("carries owner from latest reassign event", async () => {
|
|
341
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
342
|
+
finding_id: "f-own",
|
|
343
|
+
event: "new",
|
|
344
|
+
at: "2024-01-01T00:00:00Z",
|
|
345
|
+
against_fingerprint: "fp-1",
|
|
346
|
+
}));
|
|
347
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
348
|
+
finding_id: "f-own",
|
|
349
|
+
event: "reassign",
|
|
350
|
+
at: "2024-01-02T00:00:00Z",
|
|
351
|
+
against_fingerprint: "fp-1",
|
|
352
|
+
owner: "bob",
|
|
353
|
+
}));
|
|
354
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
355
|
+
finding_id: "f-own",
|
|
356
|
+
event: "reassign",
|
|
357
|
+
at: "2024-01-03T00:00:00Z",
|
|
358
|
+
against_fingerprint: "fp-1",
|
|
359
|
+
owner: "carol",
|
|
360
|
+
}));
|
|
361
|
+
const loaded = await loadLedger(vaultRoot);
|
|
362
|
+
expect(loaded.ok).toBe(true);
|
|
363
|
+
if (!loaded.ok)
|
|
364
|
+
return;
|
|
365
|
+
const events = loaded.value.byFinding.get("f-own");
|
|
366
|
+
const disp = currentDisposition(events);
|
|
367
|
+
expect(disp.owner).toBe("carol");
|
|
368
|
+
});
|
|
369
|
+
it("no reassign event: owner is undefined", async () => {
|
|
370
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
371
|
+
finding_id: "f-noown",
|
|
372
|
+
event: "new",
|
|
373
|
+
at: "2024-01-01T00:00:00Z",
|
|
374
|
+
against_fingerprint: "fp-1",
|
|
375
|
+
}));
|
|
376
|
+
const loaded = await loadLedger(vaultRoot);
|
|
377
|
+
expect(loaded.ok).toBe(true);
|
|
378
|
+
if (!loaded.ok)
|
|
379
|
+
return;
|
|
380
|
+
const events = loaded.value.byFinding.get("f-noown");
|
|
381
|
+
const disp = currentDisposition(events);
|
|
382
|
+
expect(disp.owner).toBeUndefined();
|
|
383
|
+
});
|
|
384
|
+
});
|
|
385
|
+
// ---------------------------------------------------------------------------
|
|
386
|
+
// 5. Corrupt line isolation — other events still load
|
|
387
|
+
// ---------------------------------------------------------------------------
|
|
388
|
+
describe("corrupt line isolation", () => {
|
|
389
|
+
it("one malformed JSONL line → other events still load correctly", async () => {
|
|
390
|
+
// Write two valid events, then inject a corrupt line, then a third valid event
|
|
391
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
392
|
+
finding_id: "f-good1",
|
|
393
|
+
event: "new",
|
|
394
|
+
at: "2024-01-01T00:00:00Z",
|
|
395
|
+
against_fingerprint: "fp-1",
|
|
396
|
+
}));
|
|
397
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
398
|
+
finding_id: "f-good2",
|
|
399
|
+
event: "new",
|
|
400
|
+
at: "2024-01-02T00:00:00Z",
|
|
401
|
+
against_fingerprint: "fp-2",
|
|
402
|
+
}));
|
|
403
|
+
// Directly append a corrupt line to the file
|
|
404
|
+
const { appendFileSync } = await import("node:fs");
|
|
405
|
+
const filePath = boardDispositionsPath(vaultRoot);
|
|
406
|
+
appendFileSync(filePath, "THIS IS NOT JSON\n");
|
|
407
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
408
|
+
finding_id: "f-good3",
|
|
409
|
+
event: "accept",
|
|
410
|
+
at: "2024-01-03T00:00:00Z",
|
|
411
|
+
against_fingerprint: "fp-3",
|
|
412
|
+
}));
|
|
413
|
+
const loaded = await loadLedger(vaultRoot);
|
|
414
|
+
expect(loaded.ok).toBe(true);
|
|
415
|
+
if (!loaded.ok)
|
|
416
|
+
return;
|
|
417
|
+
// All three valid findings should be present; corrupt line is silently skipped
|
|
418
|
+
expect(loaded.value.byFinding.has("f-good1")).toBe(true);
|
|
419
|
+
expect(loaded.value.byFinding.has("f-good2")).toBe(true);
|
|
420
|
+
expect(loaded.value.byFinding.has("f-good3")).toBe(true);
|
|
421
|
+
// Flat list has exactly 3 events (corrupt line dropped)
|
|
422
|
+
expect(loaded.value.flat).toHaveLength(3);
|
|
423
|
+
});
|
|
424
|
+
});
|
|
425
|
+
// ---------------------------------------------------------------------------
|
|
426
|
+
// 6. eventTimestamps — first_seen / last_seen derivable from events (R12)
|
|
427
|
+
// ---------------------------------------------------------------------------
|
|
428
|
+
describe("eventTimestamps — first_seen and last_seen (R12)", () => {
|
|
429
|
+
it("returns min/max timestamps from a finding's events", async () => {
|
|
430
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
431
|
+
finding_id: "f-ts",
|
|
432
|
+
event: "new",
|
|
433
|
+
at: "2024-03-01T00:00:00Z",
|
|
434
|
+
against_fingerprint: "fp-1",
|
|
435
|
+
}));
|
|
436
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
437
|
+
finding_id: "f-ts",
|
|
438
|
+
event: "accept",
|
|
439
|
+
at: "2024-04-01T00:00:00Z",
|
|
440
|
+
against_fingerprint: "fp-1",
|
|
441
|
+
}));
|
|
442
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
443
|
+
finding_id: "f-ts",
|
|
444
|
+
event: "dismiss",
|
|
445
|
+
at: "2024-05-01T00:00:00Z",
|
|
446
|
+
against_fingerprint: "fp-1",
|
|
447
|
+
}));
|
|
448
|
+
const loaded = await loadLedger(vaultRoot);
|
|
449
|
+
expect(loaded.ok).toBe(true);
|
|
450
|
+
if (!loaded.ok)
|
|
451
|
+
return;
|
|
452
|
+
const events = loaded.value.byFinding.get("f-ts");
|
|
453
|
+
const ts = eventTimestamps(events);
|
|
454
|
+
expect(ts.first_seen).toBe("2024-03-01T00:00:00Z");
|
|
455
|
+
expect(ts.last_seen).toBe("2024-05-01T00:00:00Z");
|
|
456
|
+
});
|
|
457
|
+
it("single event: first_seen === last_seen", async () => {
|
|
458
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
459
|
+
finding_id: "f-one",
|
|
460
|
+
event: "new",
|
|
461
|
+
at: "2024-06-15T12:00:00Z",
|
|
462
|
+
against_fingerprint: "fp-1",
|
|
463
|
+
}));
|
|
464
|
+
const loaded = await loadLedger(vaultRoot);
|
|
465
|
+
expect(loaded.ok).toBe(true);
|
|
466
|
+
if (!loaded.ok)
|
|
467
|
+
return;
|
|
468
|
+
const events = loaded.value.byFinding.get("f-one");
|
|
469
|
+
const ts = eventTimestamps(events);
|
|
470
|
+
expect(ts.first_seen).toBe("2024-06-15T12:00:00Z");
|
|
471
|
+
expect(ts.last_seen).toBe("2024-06-15T12:00:00Z");
|
|
472
|
+
});
|
|
473
|
+
});
|
|
474
|
+
// ---------------------------------------------------------------------------
|
|
475
|
+
// 7. appendEvent — .daftari dir is created if absent
|
|
476
|
+
// ---------------------------------------------------------------------------
|
|
477
|
+
describe("appendEvent — creates .daftari dir idempotently", () => {
|
|
478
|
+
it("succeeds even if .daftari does not exist yet", async () => {
|
|
479
|
+
// vaultRoot is fresh — no .daftari subdir
|
|
480
|
+
const result = await appendEvent(vaultRoot, makeEvent({ finding_id: "f-dir", event: "new", against_fingerprint: "fp-1" }));
|
|
481
|
+
expect(result.ok).toBe(true);
|
|
482
|
+
});
|
|
483
|
+
it("append is idempotent wrt dir creation — second append also succeeds", async () => {
|
|
484
|
+
await appendEvent(vaultRoot, makeEvent({ finding_id: "f-dir2", event: "new", against_fingerprint: "fp-1" }));
|
|
485
|
+
const r2 = await appendEvent(vaultRoot, makeEvent({ finding_id: "f-dir2", event: "accept", against_fingerprint: "fp-1" }));
|
|
486
|
+
expect(r2.ok).toBe(true);
|
|
487
|
+
});
|
|
488
|
+
});
|
|
489
|
+
// ---------------------------------------------------------------------------
|
|
490
|
+
// 8. appendEvent — preserves optional fields faithfully
|
|
491
|
+
// ---------------------------------------------------------------------------
|
|
492
|
+
describe("appendEvent — optional field preservation", () => {
|
|
493
|
+
it("rationale and expiry round-trip through the file", async () => {
|
|
494
|
+
const input = makeEvent({
|
|
495
|
+
finding_id: "f-opts",
|
|
496
|
+
event: "defer",
|
|
497
|
+
rationale: "waiting on upstream fix",
|
|
498
|
+
expiry: "2025-03-01T00:00:00Z",
|
|
499
|
+
against_fingerprint: "fp-x",
|
|
500
|
+
});
|
|
501
|
+
await appendEvent(vaultRoot, input);
|
|
502
|
+
const loaded = await loadLedger(vaultRoot);
|
|
503
|
+
expect(loaded.ok).toBe(true);
|
|
504
|
+
if (!loaded.ok)
|
|
505
|
+
return;
|
|
506
|
+
const events = loaded.value.byFinding.get("f-opts");
|
|
507
|
+
expect(events[0]?.rationale).toBe("waiting on upstream fix");
|
|
508
|
+
expect(events[0]?.expiry).toBe("2025-03-01T00:00:00Z");
|
|
509
|
+
});
|
|
510
|
+
});
|
|
511
|
+
// ---------------------------------------------------------------------------
|
|
512
|
+
// 9. loadLedger — structural guard: lines missing against_fingerprint or at
|
|
513
|
+
// are skipped; other valid events in the same file still load.
|
|
514
|
+
// ---------------------------------------------------------------------------
|
|
515
|
+
describe("loadLedger — structural guard for against_fingerprint and at", () => {
|
|
516
|
+
it("a valid-JSON line missing against_fingerprint is skipped; other events load", async () => {
|
|
517
|
+
const { appendFileSync, mkdirSync: mkdirSyncFs } = await import("node:fs");
|
|
518
|
+
const { join: joinPath } = await import("node:path");
|
|
519
|
+
const filePath = boardDispositionsPath(vaultRoot);
|
|
520
|
+
// Manually ensure .daftari dir exists
|
|
521
|
+
mkdirSyncFs(joinPath(vaultRoot, ".daftari"), { recursive: true });
|
|
522
|
+
// Write a valid event first via appendEvent
|
|
523
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
524
|
+
finding_id: "f-guard-good1",
|
|
525
|
+
event: "new",
|
|
526
|
+
at: "2024-01-01T00:00:00Z",
|
|
527
|
+
against_fingerprint: "fp-ok",
|
|
528
|
+
}));
|
|
529
|
+
// Inject a JSON line that parses but has no against_fingerprint
|
|
530
|
+
appendFileSync(filePath, `${JSON.stringify({
|
|
531
|
+
finding_id: "f-guard-bad1",
|
|
532
|
+
event: "new",
|
|
533
|
+
by: "human:alice",
|
|
534
|
+
principal_type: "human",
|
|
535
|
+
at: "2024-01-02T00:00:00Z",
|
|
536
|
+
// against_fingerprint intentionally omitted
|
|
537
|
+
identity_scheme_version: "v1",
|
|
538
|
+
})}\n`);
|
|
539
|
+
// Write another valid event after the bad line
|
|
540
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
541
|
+
finding_id: "f-guard-good2",
|
|
542
|
+
event: "accept",
|
|
543
|
+
at: "2024-01-03T00:00:00Z",
|
|
544
|
+
against_fingerprint: "fp-ok2",
|
|
545
|
+
}));
|
|
546
|
+
const loaded = await loadLedger(vaultRoot);
|
|
547
|
+
expect(loaded.ok).toBe(true);
|
|
548
|
+
if (!loaded.ok)
|
|
549
|
+
return;
|
|
550
|
+
// The line missing against_fingerprint must be skipped
|
|
551
|
+
expect(loaded.value.byFinding.has("f-guard-bad1")).toBe(false);
|
|
552
|
+
// Valid events still present
|
|
553
|
+
expect(loaded.value.byFinding.has("f-guard-good1")).toBe(true);
|
|
554
|
+
expect(loaded.value.byFinding.has("f-guard-good2")).toBe(true);
|
|
555
|
+
// Flat list has exactly 2 events (bad line dropped)
|
|
556
|
+
expect(loaded.value.flat).toHaveLength(2);
|
|
557
|
+
});
|
|
558
|
+
it("a valid-JSON line missing at is skipped; other events load", async () => {
|
|
559
|
+
const { appendFileSync } = await import("node:fs");
|
|
560
|
+
const filePath = boardDispositionsPath(vaultRoot);
|
|
561
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
562
|
+
finding_id: "f-guard-at-good",
|
|
563
|
+
event: "new",
|
|
564
|
+
at: "2024-01-01T00:00:00Z",
|
|
565
|
+
against_fingerprint: "fp-ok",
|
|
566
|
+
}));
|
|
567
|
+
// Inject a JSON line that parses but has no at field
|
|
568
|
+
appendFileSync(filePath, `${JSON.stringify({
|
|
569
|
+
finding_id: "f-guard-at-bad",
|
|
570
|
+
event: "new",
|
|
571
|
+
by: "human:alice",
|
|
572
|
+
principal_type: "human",
|
|
573
|
+
// at intentionally omitted
|
|
574
|
+
against_fingerprint: "fp-missing-at",
|
|
575
|
+
identity_scheme_version: "v1",
|
|
576
|
+
})}\n`);
|
|
577
|
+
const loaded = await loadLedger(vaultRoot);
|
|
578
|
+
expect(loaded.ok).toBe(true);
|
|
579
|
+
if (!loaded.ok)
|
|
580
|
+
return;
|
|
581
|
+
expect(loaded.value.byFinding.has("f-guard-at-bad")).toBe(false);
|
|
582
|
+
expect(loaded.value.byFinding.has("f-guard-at-good")).toBe(true);
|
|
583
|
+
expect(loaded.value.flat).toHaveLength(1);
|
|
584
|
+
});
|
|
585
|
+
});
|
|
586
|
+
// ---------------------------------------------------------------------------
|
|
587
|
+
// 10. currentDisposition — standing-expiry fold semantics
|
|
588
|
+
//
|
|
589
|
+
// Definitive rules (U3 correction, #455):
|
|
590
|
+
// - defer or dismiss UNCONDITIONALLY sets the standing expiry to that event's
|
|
591
|
+
// expiry field (present → that value; absent → undefined / cleared).
|
|
592
|
+
// A new defer/dismiss is a fresh disposition; it owns its own timer.
|
|
593
|
+
// - accept or resolved CLEARS the standing expiry.
|
|
594
|
+
// - reassign, reopened, and new do NOT change the standing expiry.
|
|
595
|
+
// ---------------------------------------------------------------------------
|
|
596
|
+
describe("currentDisposition — standing-expiry fold semantics", () => {
|
|
597
|
+
it("defer(expiry) → reassign: expiry survives (reassign does not un-defer)", async () => {
|
|
598
|
+
const expiry = "2099-06-01T00:00:00Z";
|
|
599
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
600
|
+
finding_id: "f-stand-a",
|
|
601
|
+
event: "new",
|
|
602
|
+
at: "2024-01-01T00:00:00Z",
|
|
603
|
+
against_fingerprint: "fp-1",
|
|
604
|
+
}));
|
|
605
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
606
|
+
finding_id: "f-stand-a",
|
|
607
|
+
event: "defer",
|
|
608
|
+
at: "2024-01-02T00:00:00Z",
|
|
609
|
+
against_fingerprint: "fp-1",
|
|
610
|
+
expiry,
|
|
611
|
+
}));
|
|
612
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
613
|
+
finding_id: "f-stand-a",
|
|
614
|
+
event: "reassign",
|
|
615
|
+
at: "2024-01-03T00:00:00Z",
|
|
616
|
+
against_fingerprint: "fp-1",
|
|
617
|
+
owner: "bob",
|
|
618
|
+
}));
|
|
619
|
+
const loaded = await loadLedger(vaultRoot);
|
|
620
|
+
expect(loaded.ok).toBe(true);
|
|
621
|
+
if (!loaded.ok)
|
|
622
|
+
return;
|
|
623
|
+
const events = loaded.value.byFinding.get("f-stand-a");
|
|
624
|
+
const disp = currentDisposition(events);
|
|
625
|
+
// Expiry set by defer must survive the subsequent reassign
|
|
626
|
+
expect(disp.expiry).toBe(expiry);
|
|
627
|
+
});
|
|
628
|
+
it("defer(expiry) → accept: expiry is cleared", async () => {
|
|
629
|
+
const expiry = "2099-06-01T00:00:00Z";
|
|
630
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
631
|
+
finding_id: "f-stand-b",
|
|
632
|
+
event: "defer",
|
|
633
|
+
at: "2024-01-01T00:00:00Z",
|
|
634
|
+
against_fingerprint: "fp-1",
|
|
635
|
+
expiry,
|
|
636
|
+
}));
|
|
637
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
638
|
+
finding_id: "f-stand-b",
|
|
639
|
+
event: "accept",
|
|
640
|
+
at: "2024-01-02T00:00:00Z",
|
|
641
|
+
against_fingerprint: "fp-1",
|
|
642
|
+
}));
|
|
643
|
+
const loaded = await loadLedger(vaultRoot);
|
|
644
|
+
expect(loaded.ok).toBe(true);
|
|
645
|
+
if (!loaded.ok)
|
|
646
|
+
return;
|
|
647
|
+
const events = loaded.value.byFinding.get("f-stand-b");
|
|
648
|
+
const disp = currentDisposition(events);
|
|
649
|
+
// accept must clear the expiry from the prior defer
|
|
650
|
+
expect(disp.expiry).toBeUndefined();
|
|
651
|
+
});
|
|
652
|
+
it("dismiss(expiry) → reopened: expiry survives (reopened does not clear)", async () => {
|
|
653
|
+
const expiry = "2099-12-31T00:00:00Z";
|
|
654
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
655
|
+
finding_id: "f-stand-c",
|
|
656
|
+
event: "dismiss",
|
|
657
|
+
at: "2024-01-01T00:00:00Z",
|
|
658
|
+
against_fingerprint: "fp-1",
|
|
659
|
+
expiry,
|
|
660
|
+
}));
|
|
661
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
662
|
+
finding_id: "f-stand-c",
|
|
663
|
+
event: "reopened",
|
|
664
|
+
at: "2024-01-02T00:00:00Z",
|
|
665
|
+
against_fingerprint: "fp-1",
|
|
666
|
+
}));
|
|
667
|
+
const loaded = await loadLedger(vaultRoot);
|
|
668
|
+
expect(loaded.ok).toBe(true);
|
|
669
|
+
if (!loaded.ok)
|
|
670
|
+
return;
|
|
671
|
+
const events = loaded.value.byFinding.get("f-stand-c");
|
|
672
|
+
const disp = currentDisposition(events);
|
|
673
|
+
// reopened must NOT clear the standing expiry from dismiss
|
|
674
|
+
expect(disp.expiry).toBe(expiry);
|
|
675
|
+
});
|
|
676
|
+
it("defer(expiry) → resolved: expiry is cleared", async () => {
|
|
677
|
+
const expiry = "2099-06-01T00:00:00Z";
|
|
678
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
679
|
+
finding_id: "f-stand-d",
|
|
680
|
+
event: "defer",
|
|
681
|
+
at: "2024-01-01T00:00:00Z",
|
|
682
|
+
against_fingerprint: "fp-1",
|
|
683
|
+
expiry,
|
|
684
|
+
}));
|
|
685
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
686
|
+
finding_id: "f-stand-d",
|
|
687
|
+
event: "resolved",
|
|
688
|
+
at: "2024-01-02T00:00:00Z",
|
|
689
|
+
against_fingerprint: "fp-1",
|
|
690
|
+
}));
|
|
691
|
+
const loaded = await loadLedger(vaultRoot);
|
|
692
|
+
expect(loaded.ok).toBe(true);
|
|
693
|
+
if (!loaded.ok)
|
|
694
|
+
return;
|
|
695
|
+
const events = loaded.value.byFinding.get("f-stand-d");
|
|
696
|
+
const disp = currentDisposition(events);
|
|
697
|
+
// resolved must clear the standing expiry
|
|
698
|
+
expect(disp.expiry).toBeUndefined();
|
|
699
|
+
});
|
|
700
|
+
// --- New tests for the #455 unconditional-replace rule ---
|
|
701
|
+
it("defer(expiry) → dismiss(NO expiry): standing expiry is undefined — permanent dismiss (R9)", async () => {
|
|
702
|
+
// A plain dismiss with no expiry field must REPLACE (clear) the prior defer's expiry.
|
|
703
|
+
// This is the key R9 invariant: a permanent dismissal must not inherit a prior defer timer.
|
|
704
|
+
const deferExpiry = "2099-06-01T00:00:00Z";
|
|
705
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
706
|
+
finding_id: "f-stand-e",
|
|
707
|
+
event: "defer",
|
|
708
|
+
at: "2024-01-01T00:00:00Z",
|
|
709
|
+
against_fingerprint: "fp-1",
|
|
710
|
+
expiry: deferExpiry,
|
|
711
|
+
}));
|
|
712
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
713
|
+
finding_id: "f-stand-e",
|
|
714
|
+
event: "dismiss",
|
|
715
|
+
at: "2024-01-02T00:00:00Z",
|
|
716
|
+
against_fingerprint: "fp-1",
|
|
717
|
+
// No expiry field — permanent dismissal
|
|
718
|
+
}));
|
|
719
|
+
const loaded = await loadLedger(vaultRoot);
|
|
720
|
+
expect(loaded.ok).toBe(true);
|
|
721
|
+
if (!loaded.ok)
|
|
722
|
+
return;
|
|
723
|
+
const events = loaded.value.byFinding.get("f-stand-e");
|
|
724
|
+
const disp = currentDisposition(events, new Date("2099-07-01T00:00:00Z"));
|
|
725
|
+
// dismiss with no expiry must unconditionally replace — standing expiry is now undefined
|
|
726
|
+
expect(disp.expiry).toBeUndefined();
|
|
727
|
+
// and therefore not expired (no timer to expire)
|
|
728
|
+
expect(disp.expired).toBe(false);
|
|
729
|
+
});
|
|
730
|
+
it("defer(expiry1) → dismiss(expiry2): standing expiry is expiry2", async () => {
|
|
731
|
+
const expiry1 = "2099-06-01T00:00:00Z";
|
|
732
|
+
const expiry2 = "2099-12-31T00:00:00Z";
|
|
733
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
734
|
+
finding_id: "f-stand-f",
|
|
735
|
+
event: "defer",
|
|
736
|
+
at: "2024-01-01T00:00:00Z",
|
|
737
|
+
against_fingerprint: "fp-1",
|
|
738
|
+
expiry: expiry1,
|
|
739
|
+
}));
|
|
740
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
741
|
+
finding_id: "f-stand-f",
|
|
742
|
+
event: "dismiss",
|
|
743
|
+
at: "2024-01-02T00:00:00Z",
|
|
744
|
+
against_fingerprint: "fp-1",
|
|
745
|
+
expiry: expiry2,
|
|
746
|
+
}));
|
|
747
|
+
const loaded = await loadLedger(vaultRoot);
|
|
748
|
+
expect(loaded.ok).toBe(true);
|
|
749
|
+
if (!loaded.ok)
|
|
750
|
+
return;
|
|
751
|
+
const events = loaded.value.byFinding.get("f-stand-f");
|
|
752
|
+
const disp = currentDisposition(events);
|
|
753
|
+
// dismiss's expiry must replace the defer's expiry
|
|
754
|
+
expect(disp.expiry).toBe(expiry2);
|
|
755
|
+
});
|
|
756
|
+
it("defer(expiry) → reassign: expiry survives (reassign does not touch the timer)", async () => {
|
|
757
|
+
// Already covered in f-stand-a above, but explicit here for the new rule suite.
|
|
758
|
+
const expiry = "2099-06-01T00:00:00Z";
|
|
759
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
760
|
+
finding_id: "f-stand-g",
|
|
761
|
+
event: "defer",
|
|
762
|
+
at: "2024-01-01T00:00:00Z",
|
|
763
|
+
against_fingerprint: "fp-1",
|
|
764
|
+
expiry,
|
|
765
|
+
}));
|
|
766
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
767
|
+
finding_id: "f-stand-g",
|
|
768
|
+
event: "reassign",
|
|
769
|
+
at: "2024-01-02T00:00:00Z",
|
|
770
|
+
against_fingerprint: "fp-1",
|
|
771
|
+
owner: "dave",
|
|
772
|
+
}));
|
|
773
|
+
const loaded = await loadLedger(vaultRoot);
|
|
774
|
+
expect(loaded.ok).toBe(true);
|
|
775
|
+
if (!loaded.ok)
|
|
776
|
+
return;
|
|
777
|
+
const events = loaded.value.byFinding.get("f-stand-g");
|
|
778
|
+
const disp = currentDisposition(events);
|
|
779
|
+
expect(disp.expiry).toBe(expiry);
|
|
780
|
+
});
|
|
781
|
+
it("defer(expiry) → accept: expiry is cleared (accept closes the disposition)", async () => {
|
|
782
|
+
// Mirror of f-stand-b above; kept here so the new rule suite is self-contained.
|
|
783
|
+
const expiry = "2099-06-01T00:00:00Z";
|
|
784
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
785
|
+
finding_id: "f-stand-h",
|
|
786
|
+
event: "defer",
|
|
787
|
+
at: "2024-01-01T00:00:00Z",
|
|
788
|
+
against_fingerprint: "fp-1",
|
|
789
|
+
expiry,
|
|
790
|
+
}));
|
|
791
|
+
await appendEvent(vaultRoot, makeEvent({
|
|
792
|
+
finding_id: "f-stand-h",
|
|
793
|
+
event: "accept",
|
|
794
|
+
at: "2024-01-02T00:00:00Z",
|
|
795
|
+
against_fingerprint: "fp-1",
|
|
796
|
+
}));
|
|
797
|
+
const loaded = await loadLedger(vaultRoot);
|
|
798
|
+
expect(loaded.ok).toBe(true);
|
|
799
|
+
if (!loaded.ok)
|
|
800
|
+
return;
|
|
801
|
+
const events = loaded.value.byFinding.get("f-stand-h");
|
|
802
|
+
const disp = currentDisposition(events);
|
|
803
|
+
expect(disp.expiry).toBeUndefined();
|
|
804
|
+
});
|
|
805
|
+
});
|
|
806
|
+
// ---------------------------------------------------------------------------
|
|
807
|
+
// U3 descriptor round-trip — FindingDescriptor (incl. rbacPaths) survives
|
|
808
|
+
// the appendEvent → loadLedger cycle intact.
|
|
809
|
+
// Protects the ledger.ts descriptor spread from regression.
|
|
810
|
+
// ---------------------------------------------------------------------------
|
|
811
|
+
describe("appendEvent — descriptor (incl. rbacPaths) round-trip", () => {
|
|
812
|
+
it("descriptor with rbacPaths is preserved exactly through appendEvent + loadLedger", async () => {
|
|
813
|
+
const descriptor = {
|
|
814
|
+
source: "tension",
|
|
815
|
+
check: "unresolved-tension",
|
|
816
|
+
target: { kind: "tension", tensionId: "t-abc-123" },
|
|
817
|
+
label: "Tension between notes/a.md and decisions/b.md",
|
|
818
|
+
rbacPaths: ["notes/a.md", "decisions/b.md"],
|
|
819
|
+
};
|
|
820
|
+
await appendEvent(vaultRoot, {
|
|
821
|
+
finding_id: "f-desc-rt",
|
|
822
|
+
event: "accept",
|
|
823
|
+
by: "human:alice",
|
|
824
|
+
principal_type: "human",
|
|
825
|
+
at: "2024-06-01T10:00:00Z",
|
|
826
|
+
against_fingerprint: "fp-rt",
|
|
827
|
+
descriptor,
|
|
828
|
+
});
|
|
829
|
+
const loaded = await loadLedger(vaultRoot);
|
|
830
|
+
expect(loaded.ok).toBe(true);
|
|
831
|
+
if (!loaded.ok)
|
|
832
|
+
return;
|
|
833
|
+
const events = loaded.value.byFinding.get("f-desc-rt");
|
|
834
|
+
expect(events).toBeDefined();
|
|
835
|
+
expect(events).toHaveLength(1);
|
|
836
|
+
const evt = events[0];
|
|
837
|
+
expect(evt.descriptor).toBeDefined();
|
|
838
|
+
expect(evt.descriptor?.source).toBe("tension");
|
|
839
|
+
expect(evt.descriptor?.check).toBe("unresolved-tension");
|
|
840
|
+
expect(evt.descriptor?.target).toEqual({ kind: "tension", tensionId: "t-abc-123" });
|
|
841
|
+
expect(evt.descriptor?.label).toBe("Tension between notes/a.md and decisions/b.md");
|
|
842
|
+
expect(evt.descriptor?.rbacPaths).toEqual(["notes/a.md", "decisions/b.md"]);
|
|
843
|
+
});
|
|
844
|
+
it("descriptor without rbacPaths (legacy) round-trips with rbacPaths absent (not null, not [])", async () => {
|
|
845
|
+
const descriptor = {
|
|
846
|
+
source: "lint",
|
|
847
|
+
check: "orphanFiles",
|
|
848
|
+
target: { kind: "lint", path: "notes/orphan.md" },
|
|
849
|
+
label: "Orphan doc",
|
|
850
|
+
// rbacPaths intentionally absent
|
|
851
|
+
};
|
|
852
|
+
await appendEvent(vaultRoot, {
|
|
853
|
+
finding_id: "f-desc-legacy",
|
|
854
|
+
event: "accept",
|
|
855
|
+
by: "human:alice",
|
|
856
|
+
principal_type: "human",
|
|
857
|
+
at: "2024-06-01T10:00:00Z",
|
|
858
|
+
against_fingerprint: "fp-legacy",
|
|
859
|
+
descriptor,
|
|
860
|
+
});
|
|
861
|
+
const loaded = await loadLedger(vaultRoot);
|
|
862
|
+
expect(loaded.ok).toBe(true);
|
|
863
|
+
if (!loaded.ok)
|
|
864
|
+
return;
|
|
865
|
+
const events = loaded.value.byFinding.get("f-desc-legacy");
|
|
866
|
+
expect(events).toBeDefined();
|
|
867
|
+
const evt = events[0];
|
|
868
|
+
expect(evt.descriptor).toBeDefined();
|
|
869
|
+
// rbacPaths must be absent (undefined), not null or empty array
|
|
870
|
+
expect(evt.descriptor?.rbacPaths).toBeUndefined();
|
|
871
|
+
});
|
|
872
|
+
});
|
|
873
|
+
//# sourceMappingURL=ledger.test.js.map
|