@agent-ix/quoin 0.14.0 → 0.17.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/.claude-plugin/plugin.json +1 -1
- package/.codex-plugin/plugin.json +1 -1
- package/default-modules.yaml +4 -4
- package/dist/advisor/advise.d.ts +57 -0
- package/dist/advisor/advise.d.ts.map +1 -0
- package/dist/advisor/index.d.ts +10 -0
- package/dist/advisor/index.d.ts.map +1 -0
- package/dist/advisor/methods.d.ts +60 -0
- package/dist/advisor/methods.d.ts.map +1 -0
- package/dist/advisor-Dhy9S7PS.js +63 -0
- package/dist/audit-CudnEJmh.js +127 -0
- package/dist/auditor/audit.d.ts +63 -0
- package/dist/auditor/audit.d.ts.map +1 -0
- package/dist/auditor/index.d.ts +8 -0
- package/dist/auditor/index.d.ts.map +1 -0
- package/dist/{base-BIELM-Fk.js → base-D_-Jy4cE.js} +2 -2
- package/dist/catalog.d.ts +1 -0
- package/dist/catalog.d.ts.map +1 -1
- package/dist/cli.js +1 -1
- package/dist/commands/advise.d.ts +16 -0
- package/dist/commands/advise.d.ts.map +1 -0
- package/dist/commands/advise.js +161 -0
- package/dist/commands/catalog/list.js +2 -2
- package/dist/commands/catalog/methods.d.ts +12 -0
- package/dist/commands/catalog/methods.d.ts.map +1 -0
- package/dist/commands/catalog/methods.js +43 -0
- package/dist/commands/catalog/show.js +2 -2
- package/dist/commands/catalog/validate.js +2 -2
- package/dist/commands/config/doctor.js +1 -1
- package/dist/commands/config/edit.js +1 -1
- package/dist/commands/config/get.js +1 -1
- package/dist/commands/config/set.js +1 -1
- package/dist/commands/evidence/affirm.d.ts +17 -0
- package/dist/commands/evidence/affirm.d.ts.map +1 -0
- package/dist/commands/evidence/affirm.js +67 -0
- package/dist/commands/evidence/audit.d.ts +16 -0
- package/dist/commands/evidence/audit.d.ts.map +1 -0
- package/dist/commands/evidence/audit.js +80 -0
- package/dist/commands/evidence/baseline.d.ts +14 -0
- package/dist/commands/evidence/baseline.d.ts.map +1 -0
- package/dist/commands/evidence/baseline.js +79 -0
- package/dist/commands/evidence/gc.d.ts +13 -0
- package/dist/commands/evidence/gc.d.ts.map +1 -0
- package/dist/commands/evidence/gc.js +34 -0
- package/dist/commands/evidence/index.d.ts +8 -0
- package/dist/commands/evidence/index.d.ts.map +1 -0
- package/dist/commands/evidence/index.js +18 -0
- package/dist/commands/evidence/record.d.ts +19 -0
- package/dist/commands/evidence/record.d.ts.map +1 -0
- package/dist/commands/evidence/record.js +72 -0
- package/dist/commands/matrix.js +1 -1
- package/dist/commands/module/ensure-defaults.js +3 -3
- package/dist/commands/module/install.js +2 -2
- package/dist/commands/module/list.js +2 -2
- package/dist/commands/module/remove.js +2 -2
- package/dist/commands/review.js +1 -1
- package/dist/commands/to-plan.js +1 -1
- package/dist/commands/update.js +2 -2
- package/dist/commands/write.js +3 -3
- package/dist/evidence/index.d.ts +13 -0
- package/dist/evidence/index.d.ts.map +1 -0
- package/dist/evidence/record.d.ts +58 -0
- package/dist/evidence/record.d.ts.map +1 -0
- package/dist/evidence/store.d.ts +147 -0
- package/dist/evidence/store.d.ts.map +1 -0
- package/dist/evidence/types.d.ts +143 -0
- package/dist/evidence/types.d.ts.map +1 -0
- package/dist/evidence-QUw0KyMH.js +209 -0
- package/dist/{flow-command-Cu3AeDeV.js → flow-command-B-ZBn9Sd.js} +1 -1
- package/dist/index.js +6 -6
- package/dist/{modules-BumGtAYj.js → modules-DSkUXhHn.js} +2 -2
- package/dist/{plugins-DkBB_VkF.js → plugins-DiS0OXoo.js} +1 -1
- package/dist/quire/contract.d.ts +82 -0
- package/dist/quire/contract.d.ts.map +1 -0
- package/dist/quire/exec.d.ts +44 -0
- package/dist/quire/exec.d.ts.map +1 -0
- package/dist/quire/index.d.ts +12 -0
- package/dist/quire/index.d.ts.map +1 -0
- package/dist/quire/types.d.ts +155 -0
- package/dist/quire/types.d.ts.map +1 -0
- package/dist/quire/validate.d.ts +34 -0
- package/dist/quire/validate.d.ts.map +1 -0
- package/dist/quire-D7ra5rUF.js +4926 -0
- package/dist/schemas/coverage-v1.schema.json +191 -0
- package/dist/schemas/properties-v1.schema.json +134 -0
- package/dist/{version-4FRTZpv_.js → version-DmZHxX4n.js} +1 -1
- package/dist/{write-UmBcjFtj.js → write-CPdSNIkF.js} +1 -1
- package/package.json +6 -2
- package/skills/spec-evidence-analysis/SKILL.md +79 -51
|
@@ -0,0 +1,18 @@
|
|
|
1
|
+
import { t as e } from "../../base-D_-Jy4cE.js";
|
|
2
|
+
//#region src/commands/evidence/index.ts
|
|
3
|
+
var t = class t extends e {
|
|
4
|
+
static summary = "The evidence store — what actually ran, and against which statement.";
|
|
5
|
+
static description = "The artifact of record for verification (FR-030). quoin TRANSCRIBES; the\nconsumer's CI executes — nothing here runs a test.\n\nLayout, under spec/evidence/:\n\n suites.md authored suite registry (validated corpus document)\n inspections.md authored inspection acts (validated corpus document)\n bindings.json obligation -> hash-at-binding -> evidence\n baseline.json the accepted violation set the ratchet compares against\n runs/<SUITE-N>/<commit12>.json one file = one run of one suite\n\nSubcommands:\n quoin evidence record transcribe a suite run\n quoin evidence affirm re-affirm a binding after its statement changed\n quoin evidence audit read the store and report\n quoin evidence baseline accept the current findings as the ratchet baseline\n quoin evidence gc drop run records nothing references";
|
|
6
|
+
static examples = [
|
|
7
|
+
"quoin evidence record --suite SUITE-001 --commit $(git rev-parse HEAD) --tool 'cargo test' --results run.json",
|
|
8
|
+
"quoin evidence affirm --obligation FR-001-AC-1 --who @reviewer",
|
|
9
|
+
"quoin evidence audit --ratchet --strict",
|
|
10
|
+
"quoin evidence baseline",
|
|
11
|
+
"quoin evidence gc --dry-run"
|
|
12
|
+
];
|
|
13
|
+
async run() {
|
|
14
|
+
this.log(t.description);
|
|
15
|
+
}
|
|
16
|
+
};
|
|
17
|
+
//#endregion
|
|
18
|
+
export { t as default };
|
|
@@ -0,0 +1,19 @@
|
|
|
1
|
+
import { QuoinCommand } from '../../base.js';
|
|
2
|
+
export default class EvidenceRecord extends QuoinCommand {
|
|
3
|
+
static summary: string;
|
|
4
|
+
static description: string;
|
|
5
|
+
static examples: string[];
|
|
6
|
+
static flags: {
|
|
7
|
+
suite: import('@oclif/core/interfaces').OptionFlag<string, import('@oclif/core/interfaces').CustomOptions>;
|
|
8
|
+
commit: import('@oclif/core/interfaces').OptionFlag<string, import('@oclif/core/interfaces').CustomOptions>;
|
|
9
|
+
tool: import('@oclif/core/interfaces').OptionFlag<string, import('@oclif/core/interfaces').CustomOptions>;
|
|
10
|
+
kind: import('@oclif/core/interfaces').OptionFlag<string | undefined, import('@oclif/core/interfaces').CustomOptions>;
|
|
11
|
+
results: import('@oclif/core/interfaces').OptionFlag<string, import('@oclif/core/interfaces').CustomOptions>;
|
|
12
|
+
repo: import('@oclif/core/interfaces').OptionFlag<string, import('@oclif/core/interfaces').CustomOptions>;
|
|
13
|
+
module: import('@oclif/core/interfaces').OptionFlag<string | undefined, import('@oclif/core/interfaces').CustomOptions>;
|
|
14
|
+
timestamp: import('@oclif/core/interfaces').OptionFlag<string | undefined, import('@oclif/core/interfaces').CustomOptions>;
|
|
15
|
+
json: import('@oclif/core/interfaces').BooleanFlag<boolean>;
|
|
16
|
+
};
|
|
17
|
+
run(): Promise<void>;
|
|
18
|
+
}
|
|
19
|
+
//# sourceMappingURL=record.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../../src/commands/evidence/record.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,YAAY,EAAE,MAAM,eAAe,CAAC;AAa7C,MAAM,CAAC,OAAO,OAAO,cAAe,SAAQ,YAAY;IACtD,MAAM,CAAC,OAAO,SAAuD;IACrE,MAAM,CAAC,WAAW,SAa2D;IAE7E,MAAM,CAAC,QAAQ,WAEb;IAEF,MAAM,CAAC,KAAK;;;;;;;;;;MAmCV;IAEI,GAAG,IAAI,OAAO,CAAC,IAAI,CAAC;CAuD3B"}
|
|
@@ -0,0 +1,72 @@
|
|
|
1
|
+
import { i as e, n as t, o as n, t as r } from "../../quire-D7ra5rUF.js";
|
|
2
|
+
import { t as i } from "../../base-D_-Jy4cE.js";
|
|
3
|
+
import { n as a, t as o } from "../../evidence-QUw0KyMH.js";
|
|
4
|
+
import { readFileSync as s } from "node:fs";
|
|
5
|
+
import { Flags as c } from "@oclif/core";
|
|
6
|
+
//#region src/commands/evidence/record.ts
|
|
7
|
+
var l = class s extends i {
|
|
8
|
+
static summary = "Transcribe one suite run into the evidence store.";
|
|
9
|
+
static description = "Records ONE run of ONE suite at ONE commit, then binds every obligation that\nrun discharged, stamping the statement hash as it stands now.\n\nquoin transcribes; the consumer's CI executes (ADR-0011 invariant 1). This\ncommand runs no test and judges no result — recording a FAILING run is as\nlegitimate as recording a passing one, and more useful, because a suite that\nstopped passing is exactly what a freshness check needs to see.\n\n--results takes normalized entries:\n\n {\"entries\": [{\"symbol\": \"tests::tc001\", \"outcome\": \"pass\", \"traceIds\": [\"FR-001-AC-1\"]}]}\n\nFormat adapters (junit, llvm-cov, cargo-mutants, SARIF) are a separate ticket\n(agent-ix/quoin#91); this verb owns the store, not the parsing of every tool.";
|
|
10
|
+
static examples = ["quoin evidence record --suite SUITE-001 --commit $(git rev-parse HEAD) --tool 'cargo test' --results run.json"];
|
|
11
|
+
static flags = {
|
|
12
|
+
suite: c.string({
|
|
13
|
+
description: "Suite id from spec/evidence/suites.md (e.g. SUITE-001).",
|
|
14
|
+
required: !0
|
|
15
|
+
}),
|
|
16
|
+
commit: c.string({
|
|
17
|
+
description: "Full commit sha the run was performed at.",
|
|
18
|
+
required: !0
|
|
19
|
+
}),
|
|
20
|
+
tool: c.string({
|
|
21
|
+
description: "Tool and version, as it identifies itself.",
|
|
22
|
+
required: !0
|
|
23
|
+
}),
|
|
24
|
+
kind: c.string({ description: "Evidence kind this run produced (Unit, Property, Static, Manual, …) — the vocabulary the catalog's `evidence_kind` and the suite registry's `Evidence Kind` column use. Method conformance compares kind to kind; without it the check stays silent rather than guessing." }),
|
|
25
|
+
results: c.string({
|
|
26
|
+
description: "Normalized run entries as JSON. `-` reads stdin.",
|
|
27
|
+
required: !0
|
|
28
|
+
}),
|
|
29
|
+
repo: c.string({
|
|
30
|
+
description: "Repository root. Defaults to the working directory.",
|
|
31
|
+
default: "."
|
|
32
|
+
}),
|
|
33
|
+
module: c.string({ description: "Module directory supplying the traceability model." }),
|
|
34
|
+
timestamp: c.string({ description: "ISO-8601 run time. Defaults to now." }),
|
|
35
|
+
json: c.boolean({ description: "Emit the outcome as JSON." })
|
|
36
|
+
};
|
|
37
|
+
async run() {
|
|
38
|
+
let { flags: i } = await this.parse(s), c = n(r());
|
|
39
|
+
c && this.error(c.message, { exit: 2 });
|
|
40
|
+
let l = u(i.results), d = [
|
|
41
|
+
"coverage",
|
|
42
|
+
"--scope",
|
|
43
|
+
i.repo,
|
|
44
|
+
"--json"
|
|
45
|
+
];
|
|
46
|
+
i.module && d.push("--module", i.module);
|
|
47
|
+
let f = t(d), p = e(f);
|
|
48
|
+
p.ok || this.error(`${p.error.message}\n${p.error.errors.slice(0, 10).join("\n")}`, { exit: 2 });
|
|
49
|
+
let m = a({
|
|
50
|
+
repo: i.repo,
|
|
51
|
+
suite: i.suite,
|
|
52
|
+
commit: i.commit,
|
|
53
|
+
tool: i.tool,
|
|
54
|
+
evidenceKind: i.kind,
|
|
55
|
+
timestamp: i.timestamp ?? (/* @__PURE__ */ new Date()).toISOString(),
|
|
56
|
+
entries: l,
|
|
57
|
+
obligations: o(p.value)
|
|
58
|
+
});
|
|
59
|
+
if (i.json) {
|
|
60
|
+
this.log(JSON.stringify(m, null, 2));
|
|
61
|
+
return;
|
|
62
|
+
}
|
|
63
|
+
this.log(`recorded ${i.suite} @ ${i.commit.slice(0, 12)} → ${m.runPath}`), this.log(` bound: ${m.bound.length}`), m.suspect.length > 0 && this.log(` suspect (statement changed since binding, re-affirm to clear): ${m.suspect.join(", ")}`), m.unmatched.length > 0 && this.log(` unmatched trace ids (tagged in the suite, stated by no obligation): ${m.unmatched.join(", ")}`);
|
|
64
|
+
}
|
|
65
|
+
};
|
|
66
|
+
function u(e) {
|
|
67
|
+
let t = s(e === "-" ? 0 : e, "utf8"), n = JSON.parse(t);
|
|
68
|
+
if (!Array.isArray(n.entries)) throw Error("--results must be JSON of the form {\"entries\": [{symbol, outcome, traceIds?}]}");
|
|
69
|
+
return n.entries;
|
|
70
|
+
}
|
|
71
|
+
//#endregion
|
|
72
|
+
export { l as default };
|
package/dist/commands/matrix.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
|
-
import { t as e } from "../../base-
|
|
2
|
-
import { r as t } from "../../plugins-
|
|
3
|
-
import { n } from "../../modules-
|
|
1
|
+
import { t as e } from "../../base-D_-Jy4cE.js";
|
|
2
|
+
import { r as t } from "../../plugins-DiS0OXoo.js";
|
|
3
|
+
import { n } from "../../modules-DSkUXhHn.js";
|
|
4
4
|
//#region src/commands/module/ensure-defaults.ts
|
|
5
5
|
var r = class r extends e {
|
|
6
6
|
static summary = "Idempotently install the default spec module set.";
|
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { t as e } from "../../base-
|
|
2
|
-
import { n as t } from "../../plugins-
|
|
1
|
+
import { t as e } from "../../base-D_-Jy4cE.js";
|
|
2
|
+
import { n as t } from "../../plugins-DiS0OXoo.js";
|
|
3
3
|
import { Args as n } from "@oclif/core";
|
|
4
4
|
//#region src/commands/module/install.ts
|
|
5
5
|
var r = class r extends e {
|
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { t as e } from "../../base-
|
|
2
|
-
import { r as t } from "../../plugins-
|
|
1
|
+
import { t as e } from "../../base-D_-Jy4cE.js";
|
|
2
|
+
import { r as t } from "../../plugins-DiS0OXoo.js";
|
|
3
3
|
//#region src/commands/module/list.ts
|
|
4
4
|
var n = class n extends e {
|
|
5
5
|
static summary = "List installed spec modules.";
|
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { t as e } from "../../base-
|
|
2
|
-
import { a as t } from "../../plugins-
|
|
1
|
+
import { t as e } from "../../base-D_-Jy4cE.js";
|
|
2
|
+
import { a as t } from "../../plugins-DiS0OXoo.js";
|
|
3
3
|
import { Args as n } from "@oclif/core";
|
|
4
4
|
//#region src/commands/module/remove.ts
|
|
5
5
|
var r = class r extends e {
|
package/dist/commands/review.js
CHANGED
package/dist/commands/to-plan.js
CHANGED
package/dist/commands/update.js
CHANGED
|
@@ -1,5 +1,5 @@
|
|
|
1
|
-
import { t as e } from "../version-
|
|
2
|
-
import { t } from "../base-
|
|
1
|
+
import { t as e } from "../version-DmZHxX4n.js";
|
|
2
|
+
import { t } from "../base-D_-Jy4cE.js";
|
|
3
3
|
import { runSelfUpdate as n } from "@agent-ix/ix-cli-core";
|
|
4
4
|
import { Flags as r } from "@oclif/core";
|
|
5
5
|
//#region src/commands/update.ts
|
package/dist/commands/write.js
CHANGED
|
@@ -1,6 +1,6 @@
|
|
|
1
|
-
import { o as e, t } from "../base-
|
|
2
|
-
import { n } from "../modules-
|
|
3
|
-
import { n as r, r as i, t as a } from "../write-
|
|
1
|
+
import { o as e, t } from "../base-D_-Jy4cE.js";
|
|
2
|
+
import { n } from "../modules-DSkUXhHn.js";
|
|
3
|
+
import { n as r, r as i, t as a } from "../write-CPdSNIkF.js";
|
|
4
4
|
import { Args as o, Flags as s } from "@oclif/core";
|
|
5
5
|
//#region src/commands/write.ts
|
|
6
6
|
var c = class c extends t {
|
|
@@ -0,0 +1,13 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The evidence store — the artifact of record for what actually ran (FR-030).
|
|
3
|
+
*
|
|
4
|
+
* Every quoin verification surface used to recompute its view from scratch and
|
|
5
|
+
* emit a report; nothing persisted what was checked, against which statement
|
|
6
|
+
* hash, by which run. That is the "green matrix over dead links" failure mode,
|
|
7
|
+
* already observed at ecosystem scale: 1,014 trace tags binding to nothing
|
|
8
|
+
* while matrices read as covered (agent-ix/quire-rs#72).
|
|
9
|
+
*/
|
|
10
|
+
export { affirm, baselinePath, bind, bindingsPath, canonicalJson, gc, inspectionsPath, latestRun, listRecordedSuites, listRuns, readBaseline, readBindings, readRun, readRuns, runPath, short, storeRoot, suitesPath, writeBaseline, writeBindings, writeRun, } from './store.js';
|
|
11
|
+
export { RUNS_DIR, STORE_SCHEMA_VERSION, type Affirmation, type BaselineFile, type Binding, type BindingsFile, type RunEntry, type RunRecord, } from './types.js';
|
|
12
|
+
export { obligationsFrom, recordRun, type RecordOutcome, type RecordRequest, } from './record.js';
|
|
13
|
+
//# sourceMappingURL=index.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/evidence/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,EACL,MAAM,EACN,YAAY,EACZ,IAAI,EACJ,YAAY,EACZ,aAAa,EACb,EAAE,EACF,eAAe,EACf,SAAS,EACT,kBAAkB,EAClB,QAAQ,EACR,YAAY,EACZ,YAAY,EACZ,OAAO,EACP,QAAQ,EACR,OAAO,EACP,KAAK,EACL,SAAS,EACT,UAAU,EACV,aAAa,EACb,aAAa,EACb,QAAQ,GACT,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,QAAQ,EACR,oBAAoB,EACpB,KAAK,WAAW,EAChB,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,QAAQ,EACb,KAAK,SAAS,GACf,MAAM,YAAY,CAAC;AAEpB,OAAO,EACL,eAAe,EACf,SAAS,EACT,KAAK,aAAa,EAClB,KAAK,aAAa,GACnB,MAAM,aAAa,CAAC"}
|
|
@@ -0,0 +1,58 @@
|
|
|
1
|
+
import { CoverageReport, Obligation } from '../quire/index.js';
|
|
2
|
+
import { RunEntry } from './types.js';
|
|
3
|
+
/** What a caller supplies to record one run. */
|
|
4
|
+
export interface RecordRequest {
|
|
5
|
+
repo: string;
|
|
6
|
+
suite: string;
|
|
7
|
+
commit: string;
|
|
8
|
+
tool: string;
|
|
9
|
+
/**
|
|
10
|
+
* The kind of evidence this run produced, from the declared `test_type`
|
|
11
|
+
* vocabulary. Optional; method conformance compares kind to kind and stays
|
|
12
|
+
* silent when a run declares none, rather than inferring one.
|
|
13
|
+
*/
|
|
14
|
+
evidenceKind?: string;
|
|
15
|
+
/** ISO-8601. Passed in rather than read from the clock, so a record is reproducible. */
|
|
16
|
+
timestamp: string;
|
|
17
|
+
entries: RunEntry[];
|
|
18
|
+
/**
|
|
19
|
+
* The obligations as quire derives them **today**.
|
|
20
|
+
*
|
|
21
|
+
* Read live rather than stored: an obligation is always re-derivable from
|
|
22
|
+
* spec + code at HEAD, so a stored copy could only ever disagree with the
|
|
23
|
+
* requirement it describes.
|
|
24
|
+
*/
|
|
25
|
+
obligations: Obligation[];
|
|
26
|
+
}
|
|
27
|
+
/** What recording a run changed. */
|
|
28
|
+
export interface RecordOutcome {
|
|
29
|
+
runPath: string;
|
|
30
|
+
/** Obligations bound for the first time by this run. */
|
|
31
|
+
bound: string[];
|
|
32
|
+
/**
|
|
33
|
+
* Obligations already bound whose statement has changed since — the suspect
|
|
34
|
+
* set. Reported, never auto-cleared: re-running a test does not re-affirm a
|
|
35
|
+
* reworded requirement.
|
|
36
|
+
*/
|
|
37
|
+
suspect: string[];
|
|
38
|
+
/** Trace ids in the run that match no derived obligation. */
|
|
39
|
+
unmatched: string[];
|
|
40
|
+
}
|
|
41
|
+
/**
|
|
42
|
+
* Record one suite run and update the binding graph.
|
|
43
|
+
*
|
|
44
|
+
* The join is: run entry → trace ids it carries → obligation of the same id.
|
|
45
|
+
* A trace id matching no obligation is reported rather than dropped, because
|
|
46
|
+
* that is the quire-rs#72 class arriving from the other direction — a test
|
|
47
|
+
* claiming to verify something the spec does not state.
|
|
48
|
+
*/
|
|
49
|
+
export declare function recordRun(request: RecordRequest): RecordOutcome;
|
|
50
|
+
/**
|
|
51
|
+
* The obligations carried by a validated coverage payload.
|
|
52
|
+
*
|
|
53
|
+
* A payload from a model declaring no obligation sources carries none, which is
|
|
54
|
+
* an empty list rather than an error: a repository that has not adopted
|
|
55
|
+
* obligations can still record runs, it just binds nothing.
|
|
56
|
+
*/
|
|
57
|
+
export declare function obligationsFrom(report: CoverageReport): Obligation[];
|
|
58
|
+
//# sourceMappingURL=record.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"record.d.ts","sourceRoot":"","sources":["../../src/evidence/record.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAC;AAEpE,OAAO,EAAsC,KAAK,QAAQ,EAAE,MAAM,YAAY,CAAC;AAE/E,gDAAgD;AAChD,MAAM,WAAW,aAAa;IAC5B,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,wFAAwF;IACxF,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,QAAQ,EAAE,CAAC;IACpB;;;;;;OAMG;IACH,WAAW,EAAE,UAAU,EAAE,CAAC;CAC3B;AAED,oCAAoC;AACpC,MAAM,WAAW,aAAa;IAC5B,OAAO,EAAE,MAAM,CAAC;IAChB,wDAAwD;IACxD,KAAK,EAAE,MAAM,EAAE,CAAC;IAChB;;;;OAIG;IACH,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,6DAA6D;IAC7D,SAAS,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;GAOG;AACH,wBAAgB,SAAS,CAAC,OAAO,EAAE,aAAa,GAAG,aAAa,CAoE/D;AAED;;;;;;GAMG;AACH,wBAAgB,eAAe,CAAC,MAAM,EAAE,cAAc,GAAG,UAAU,EAAE,CAEpE"}
|
|
@@ -0,0 +1,147 @@
|
|
|
1
|
+
import { BaselineFile, Binding, BindingsFile, RunRecord } from './types.js';
|
|
2
|
+
/**
|
|
3
|
+
* The store root for a repository.
|
|
4
|
+
*
|
|
5
|
+
* Under `spec/`, not at the repository root. quire-rs CR-045 bounds the
|
|
6
|
+
* document walk to `<scope>/spec`, so the authored half of the store —
|
|
7
|
+
* `suites.md` and `inspections.md` — is only a validated corpus document if it
|
|
8
|
+
* lives there. The machine-written half sits beside it so the whole store is
|
|
9
|
+
* one directory rather than two halves in different places.
|
|
10
|
+
*
|
|
11
|
+
* agent-ix/quoin#79's original layout put `evidence/` at the repository root on
|
|
12
|
+
* the premise that quire "validates them wherever they live". Measured: it does
|
|
13
|
+
* not — a typed registry at the root minted nothing and was reported nowhere.
|
|
14
|
+
*/
|
|
15
|
+
export declare function storeRoot(repo: string): string;
|
|
16
|
+
export declare function suitesPath(repo: string): string;
|
|
17
|
+
export declare function inspectionsPath(repo: string): string;
|
|
18
|
+
export declare function bindingsPath(repo: string): string;
|
|
19
|
+
export declare function baselinePath(repo: string): string;
|
|
20
|
+
/** `runs/<SUITE-N>/<commit12>.json` — one file is one run of one suite. */
|
|
21
|
+
export declare function runPath(repo: string, suite: string, commit: string): string;
|
|
22
|
+
/** The 12-character commit prefix the run filenames use. */
|
|
23
|
+
export declare function short(commit: string): string;
|
|
24
|
+
/**
|
|
25
|
+
* Canonical JSON: keys sorted at every level, two-space indent, trailing
|
|
26
|
+
* newline. Deterministic by construction, so two runs over identical inputs
|
|
27
|
+
* produce identical bytes.
|
|
28
|
+
*/
|
|
29
|
+
export declare function canonicalJson(value: unknown): string;
|
|
30
|
+
/**
|
|
31
|
+
* A store file that exists and cannot be read as JSON.
|
|
32
|
+
*
|
|
33
|
+
* `bindings.json` and `baseline.json` are **checked into git**, so a merge
|
|
34
|
+
* conflict leaves `<<<<<<< HEAD` in one of them. Before this, every store read
|
|
35
|
+
* threw a bare `SyntaxError: Unexpected token '<'` naming no file
|
|
36
|
+
* (agent-ix/quoin#106).
|
|
37
|
+
*/
|
|
38
|
+
export declare class StoreReadError extends Error {
|
|
39
|
+
readonly path: string;
|
|
40
|
+
readonly cause: unknown;
|
|
41
|
+
constructor(path: string, cause: unknown);
|
|
42
|
+
}
|
|
43
|
+
/** Write one run record. Last-write-wins at the same (suite, commit). */
|
|
44
|
+
export declare function writeRun(repo: string, record: RunRecord): string;
|
|
45
|
+
/** Read one run record, or `null` when that (suite, commit) has none. */
|
|
46
|
+
export declare function readRun(repo: string, suite: string, commit: string): RunRecord | null;
|
|
47
|
+
/**
|
|
48
|
+
* Every run file recorded for a suite, in filename order.
|
|
49
|
+
*
|
|
50
|
+
* Filename order is **not** time order — a filename is a commit prefix, which
|
|
51
|
+
* is uniformly random hex. Use [`latestRun`] when you mean the newest run;
|
|
52
|
+
* this exists for enumeration.
|
|
53
|
+
*/
|
|
54
|
+
export declare function listRuns(repo: string, suite: string): string[];
|
|
55
|
+
/**
|
|
56
|
+
* Every run recorded for a suite, oldest first by `timestamp`.
|
|
57
|
+
*
|
|
58
|
+
* An unreadable run file is skipped and its path pushed onto `skipped` when the
|
|
59
|
+
* caller passes one — one corrupt record must not hide every finding in the
|
|
60
|
+
* report (agent-ix/quoin#106).
|
|
61
|
+
*/
|
|
62
|
+
export declare function readRuns(repo: string, suite: string, skipped?: string[]): RunRecord[];
|
|
63
|
+
/**
|
|
64
|
+
* The newest run of a suite, by **timestamp** — or `null` when it has none.
|
|
65
|
+
*
|
|
66
|
+
* Not `listRuns().at(-1)`. A run filename is `<commit12>.json` and a commit
|
|
67
|
+
* prefix is uniformly random hex, so the lexicographically last file is the
|
|
68
|
+
* newest run with probability 1/n. That arbitrary choice drove the auditor's
|
|
69
|
+
* freshness and vacuity checks and `gc`'s retention: record a fresh run at HEAD
|
|
70
|
+
* and, if an older run's prefix happened to sort higher, `stale-evidence` was
|
|
71
|
+
* reported against evidence that was current — and re-recording could not fix
|
|
72
|
+
* it, because the ordering is a property of the hashes and not of what you do
|
|
73
|
+
* (agent-ix/quoin#104).
|
|
74
|
+
*
|
|
75
|
+
* `RunRecord.timestamp` was there the whole time. The commit is the tiebreak,
|
|
76
|
+
* so two runs stamped identically still order deterministically.
|
|
77
|
+
*/
|
|
78
|
+
export declare function latestRun(repo: string, suite: string, skipped?: string[]): RunRecord | null;
|
|
79
|
+
/** Every suite that has at least one recorded run. */
|
|
80
|
+
export declare function listRecordedSuites(repo: string): string[];
|
|
81
|
+
/** The binding graph. An absent file reads as an empty graph, not an error. */
|
|
82
|
+
export declare function readBindings(repo: string): BindingsFile;
|
|
83
|
+
/**
|
|
84
|
+
* Write the binding graph, ordered by `(obligation, suite)` so diffs stay
|
|
85
|
+
* minimal.
|
|
86
|
+
*
|
|
87
|
+
* Compared with plain `<`, not `localeCompare`: this file is checked in and its
|
|
88
|
+
* diff is meant to *be* the per-PR delta, and `localeCompare` without an
|
|
89
|
+
* explicit locale depends on the runtime's ICU data — so two machines could
|
|
90
|
+
* serialize the same binding set in different orders and produce a diff nobody
|
|
91
|
+
* made.
|
|
92
|
+
*/
|
|
93
|
+
export declare function writeBindings(repo: string, file: BindingsFile): void;
|
|
94
|
+
/** The ratchet baseline, or `null` when none has been accepted. */
|
|
95
|
+
export declare function readBaseline(repo: string): BaselineFile | null;
|
|
96
|
+
export declare function writeBaseline(repo: string, file: BaselineFile): void;
|
|
97
|
+
/**
|
|
98
|
+
* Retain the latest run per suite plus anything a binding references; delete
|
|
99
|
+
* the rest. Returns the deleted paths.
|
|
100
|
+
*
|
|
101
|
+
* Dir-per-suite is what makes this local: a policy change for one expensive
|
|
102
|
+
* suite touches one directory, and a `.gitignore` decision can be made per
|
|
103
|
+
* suite rather than for the whole store.
|
|
104
|
+
*/
|
|
105
|
+
export declare function gc(repo: string, dryRun?: boolean): string[];
|
|
106
|
+
/**
|
|
107
|
+
* Bind an obligation to the run that discharged it, stamping the statement hash
|
|
108
|
+
* as it stands now.
|
|
109
|
+
*
|
|
110
|
+
* **Keyed on `(obligation, suite)`, not on the obligation alone.** The binding
|
|
111
|
+
* graph is cross-suite by design — one obligation discharged by a unit suite
|
|
112
|
+
* and a mutation suite is the case `bindings.json` exists to hold in one file —
|
|
113
|
+
* and keying on the obligation made the second suite *overwrite* the first.
|
|
114
|
+
* Two consequences, both silent: the cross-suite relationship was destroyed on
|
|
115
|
+
* write, and `insufficient-multiplicity` counted distinct suites per obligation
|
|
116
|
+
* across a set that could never hold more than one, so the finding could not be
|
|
117
|
+
* cleared by any amount of evidence (agent-ix/quoin#102).
|
|
118
|
+
*
|
|
119
|
+
* **Auto-bind, explicit affirmation.** First discharge binds without asking:
|
|
120
|
+
* requiring a human to confirm a binding the evidence already proves would put
|
|
121
|
+
* a gate in front of the common case and teach people to click through it. What
|
|
122
|
+
* stays explicit is *re-affirmation* after a statement changes — that is the
|
|
123
|
+
* judgement call, and it is the one worth a signature.
|
|
124
|
+
*
|
|
125
|
+
* Returns the binding, whether it was newly created, and (when this
|
|
126
|
+
* `(obligation, suite)` already existed) whether it is now suspect.
|
|
127
|
+
*/
|
|
128
|
+
export declare function bind(existing: Binding[], next: Omit<Binding, "affirmations">): {
|
|
129
|
+
bindings: Binding[];
|
|
130
|
+
created: boolean;
|
|
131
|
+
suspect: boolean;
|
|
132
|
+
};
|
|
133
|
+
/**
|
|
134
|
+
* Record a re-affirmation, clearing suspicion.
|
|
135
|
+
*
|
|
136
|
+
* Affirms **every** binding for the obligation, not the first one found. The
|
|
137
|
+
* judgement being recorded is "I have read the new statement and the evidence
|
|
138
|
+
* still discharges it", and that is a judgement about the requirement rather
|
|
139
|
+
* than about one suite — affirming only the first would leave a sibling suite
|
|
140
|
+
* suspect for a reason nobody could act on. `suite` narrows it when the
|
|
141
|
+
* reviewer means only one.
|
|
142
|
+
*/
|
|
143
|
+
export declare function affirm(existing: Binding[], obligation: string, currentHash: string, who: string, commit: string, note?: string, suite?: string): {
|
|
144
|
+
bindings: Binding[];
|
|
145
|
+
found: boolean;
|
|
146
|
+
};
|
|
147
|
+
//# sourceMappingURL=store.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"store.d.ts","sourceRoot":"","sources":["../../src/evidence/store.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAYH,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,OAAO,EACZ,KAAK,YAAY,EACjB,KAAK,SAAS,EACf,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;GAYG;AACH,wBAAgB,SAAS,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE9C;AAED,wBAAgB,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAE/C;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEpD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAEjD;AAED,2EAA2E;AAC3E,wBAAgB,OAAO,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,GAAG,MAAM,CAE3E;AAED,4DAA4D;AAC5D,wBAAgB,KAAK,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CAE5C;AAED;;;;GAIG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,OAAO,GAAG,MAAM,CAEpD;AAiBD;;;;;;;GAOG;AACH,qBAAa,cAAe,SAAQ,KAAK;IAErC,QAAQ,CAAC,IAAI,EAAE,MAAM;IACrB,QAAQ,CAAC,KAAK,EAAE,OAAO;gBADd,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,OAAO;CAU1B;AAgCD,yEAAyE;AACzE,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,EAAE,SAAS,GAAG,MAAM,CAIhE;AAED,yEAAyE;AACzE,wBAAgB,OAAO,CACrB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,GACb,SAAS,GAAG,IAAI,CAElB;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CAAC,IAAI,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,MAAM,EAAE,CAM9D;AAED;;;;;;GAMG;AACH,wBAAgB,QAAQ,CACtB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,MAAM,EAAO,GACrB,SAAS,EAAE,CAab;AAED;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,SAAS,CACvB,IAAI,EAAE,MAAM,EACZ,KAAK,EAAE,MAAM,EACb,OAAO,GAAE,MAAM,EAAO,GACrB,SAAS,GAAG,IAAI,CAElB;AAOD,sDAAsD;AACtD,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,EAAE,CAOzD;AAED,+EAA+E;AAC/E,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,CAOvD;AAED;;;;;;;;;GASG;AACH,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAMpE;AAED,mEAAmE;AACnE,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,GAAG,YAAY,GAAG,IAAI,CAE9D;AAED,wBAAgB,aAAa,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,YAAY,GAAG,IAAI,CAMpE;AAED;;;;;;;GAOG;AACH,wBAAgB,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,MAAM,UAAQ,GAAG,MAAM,EAAE,CAwBzD;AAUD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,wBAAgB,IAAI,CAClB,QAAQ,EAAE,OAAO,EAAE,EACnB,IAAI,EAAE,IAAI,CAAC,OAAO,EAAE,cAAc,CAAC,GAClC;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,OAAO,EAAE,OAAO,CAAC;IAAC,OAAO,EAAE,OAAO,CAAA;CAAE,CAwB7D;AAED;;;;;;;;;GASG;AACH,wBAAgB,MAAM,CACpB,QAAQ,EAAE,OAAO,EAAE,EACnB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,IAAI,CAAC,EAAE,MAAM,EACb,KAAK,CAAC,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,OAAO,EAAE,CAAC;IAAC,KAAK,EAAE,OAAO,CAAA;CAAE,CAkBzC"}
|
|
@@ -0,0 +1,143 @@
|
|
|
1
|
+
/**
|
|
2
|
+
* The evidence store's machine-written records (FR-030).
|
|
3
|
+
*
|
|
4
|
+
* ## Governing principle
|
|
5
|
+
*
|
|
6
|
+
* **Store only what cannot be recomputed from spec + code at HEAD.**
|
|
7
|
+
*
|
|
8
|
+
* Run outcomes, hash-at-binding, affirmations and the ratchet baseline are
|
|
9
|
+
* facts about the past — nothing can re-derive them tomorrow. Obligations are
|
|
10
|
+
* not: they are re-derived live from quire (quire-rs FR-053) on every read, so
|
|
11
|
+
* they cannot drift out of agreement with the spec. A stored copy of an
|
|
12
|
+
* obligation would be one more thing to keep in sync, and the thing it would
|
|
13
|
+
* most likely disagree with is the requirement itself.
|
|
14
|
+
*
|
|
15
|
+
* ## Format rule
|
|
16
|
+
*
|
|
17
|
+
* Authored → markdown, validated as a corpus document (the `SuiteRegistry` and
|
|
18
|
+
* `Inspections` archetypes, spec-artifacts-process FR-006).
|
|
19
|
+
* Machine-transcribed → JSON, typeless and corpus-invisible, described here.
|
|
20
|
+
*
|
|
21
|
+
* No SQLite anywhere. quoin writes files; parsing, loading and indexing for an
|
|
22
|
+
* application is `filament-ide-rs` daemon territory, and a derived index inside
|
|
23
|
+
* the store would be a second source of truth for facts the files already hold.
|
|
24
|
+
*/
|
|
25
|
+
/** Where a suite's run records live, relative to the store root. */
|
|
26
|
+
export declare const RUNS_DIR = "runs";
|
|
27
|
+
/** Schema version carried by every machine-written file in the store. */
|
|
28
|
+
export declare const STORE_SCHEMA_VERSION = 1;
|
|
29
|
+
/**
|
|
30
|
+
* One test symbol's outcome within a run.
|
|
31
|
+
*
|
|
32
|
+
* `symbol` is the FR-051 stable symbol identity — the join between what a tool
|
|
33
|
+
* reports and what the matrix declares. A tool's own test name is not that
|
|
34
|
+
* identity and must be mapped to it by the adapter (agent-ix/quoin#91) before a
|
|
35
|
+
* record is written.
|
|
36
|
+
*/
|
|
37
|
+
export interface RunEntry {
|
|
38
|
+
/** FR-051 stable symbol identity. */
|
|
39
|
+
symbol: string;
|
|
40
|
+
outcome: "pass" | "fail" | "skip" | "error";
|
|
41
|
+
/**
|
|
42
|
+
* A numeric result where the method produces one — a mutation score, a
|
|
43
|
+
* coverage percentage, a measured latency. Absent for a plain pass/fail.
|
|
44
|
+
*/
|
|
45
|
+
score?: number;
|
|
46
|
+
/** Trace ids this symbol carries, as the adapter read them. */
|
|
47
|
+
traceIds?: string[];
|
|
48
|
+
}
|
|
49
|
+
/**
|
|
50
|
+
* One run of ONE suite at ONE commit.
|
|
51
|
+
*
|
|
52
|
+
* The suite is the atomic unit of evidence: aggregation is a view, and a
|
|
53
|
+
* partial run must never be able to masquerade as a full one. The `make ci` /
|
|
54
|
+
* `make ci-python` split already caused exactly that rot (quire-rs TC-715),
|
|
55
|
+
* where a green "CI" meant one of two suites.
|
|
56
|
+
*
|
|
57
|
+
* Re-runs at the same commit are **last-write-wins, latest only**. Flake
|
|
58
|
+
* history is analytics, not the record of record — keeping every attempt here
|
|
59
|
+
* would make the store grow without bound to answer a question a different
|
|
60
|
+
* tool should answer.
|
|
61
|
+
*/
|
|
62
|
+
export interface RunRecord {
|
|
63
|
+
schemaVersion: number;
|
|
64
|
+
suite: string;
|
|
65
|
+
/** Full commit sha the run was performed at. */
|
|
66
|
+
commit: string;
|
|
67
|
+
/** Tool and version, as the adapter reported them. */
|
|
68
|
+
tool: string;
|
|
69
|
+
/**
|
|
70
|
+
* The kind of evidence this run produced, from the declared `test_type`
|
|
71
|
+
* vocabulary (`Unit`, `Property`, `Static`, `Manual`, …) — the same
|
|
72
|
+
* vocabulary the suite registry's `Evidence Kind` column and the catalog's
|
|
73
|
+
* `evidence_kind` use.
|
|
74
|
+
*
|
|
75
|
+
* Optional, and its absence is **not** an invitation to guess. Method
|
|
76
|
+
* conformance used to infer "this was a test run" from `entries.length > 0`,
|
|
77
|
+
* which is true of a transcribed inspection too — so every `Inspection` or
|
|
78
|
+
* `Analysis` obligation recorded through `quoin evidence record` was flagged
|
|
79
|
+
* (agent-ix/quoin#105). With no kind declared the question cannot be asked,
|
|
80
|
+
* and the check says nothing rather than something wrong.
|
|
81
|
+
*/
|
|
82
|
+
evidenceKind?: string;
|
|
83
|
+
/** ISO-8601, supplied by the caller — never read from the clock here. */
|
|
84
|
+
timestamp: string;
|
|
85
|
+
entries: RunEntry[];
|
|
86
|
+
}
|
|
87
|
+
/** Someone re-affirming a binding after the statement it was made against changed. */
|
|
88
|
+
export interface Affirmation {
|
|
89
|
+
who: string;
|
|
90
|
+
commit: string;
|
|
91
|
+
note?: string;
|
|
92
|
+
}
|
|
93
|
+
/**
|
|
94
|
+
* One obligation bound to the evidence that discharges it.
|
|
95
|
+
*
|
|
96
|
+
* `statementHashAtBinding` is the entire mechanism: suspect detection is
|
|
97
|
+
* `currentHash !== statementHashAtBinding`, computed by comparing this against
|
|
98
|
+
* the obligation quire re-derives today. quire computes the hash; quoin only
|
|
99
|
+
* ever compares.
|
|
100
|
+
*/
|
|
101
|
+
export interface Binding {
|
|
102
|
+
/** Obligation id — the same id the coverage rollup and trace tags key on. */
|
|
103
|
+
obligation: string;
|
|
104
|
+
/** The statement hash as it stood when the binding was first made. */
|
|
105
|
+
statementHashAtBinding: string;
|
|
106
|
+
/** Suite that discharged it. */
|
|
107
|
+
suite: string;
|
|
108
|
+
/** Commit of the run that first discharged it. */
|
|
109
|
+
commit: string;
|
|
110
|
+
/** Symbols within that suite that carry the obligation's trace id. */
|
|
111
|
+
symbols: string[];
|
|
112
|
+
/** Re-affirmations recorded after a statement changed. */
|
|
113
|
+
affirmations?: Affirmation[];
|
|
114
|
+
}
|
|
115
|
+
/**
|
|
116
|
+
* The unified binding graph.
|
|
117
|
+
*
|
|
118
|
+
* Unified rather than per-suite because the graph IS cross-suite: one
|
|
119
|
+
* obligation can be discharged by a unit test and a benchmark, and splitting
|
|
120
|
+
* the file per suite would make that relationship something to reassemble.
|
|
121
|
+
*/
|
|
122
|
+
export interface BindingsFile {
|
|
123
|
+
schemaVersion: number;
|
|
124
|
+
bindings: Binding[];
|
|
125
|
+
}
|
|
126
|
+
/**
|
|
127
|
+
* The accepted violation set a ratchet compares against.
|
|
128
|
+
*
|
|
129
|
+
* `accepted` holds `<kind>:<obligation>` keys — **every** finding kind, not two
|
|
130
|
+
* named buckets. The original shape carried `undischarged` and `suspect` only,
|
|
131
|
+
* so `stale-evidence`, `vacuous-evidence`, `method-conformance`,
|
|
132
|
+
* `unknown-method` and `insufficient-multiplicity` could never appear in a
|
|
133
|
+
* baseline and `--ratchet` reported the entire existing backlog for all five —
|
|
134
|
+
* the outcome ratchet mode exists to prevent (agent-ix/quoin#105).
|
|
135
|
+
*/
|
|
136
|
+
export interface BaselineFile {
|
|
137
|
+
schemaVersion: number;
|
|
138
|
+
/** Commit the baseline was accepted at. */
|
|
139
|
+
commit: string;
|
|
140
|
+
/** Accepted findings as `<kind>:<obligation>`, sorted. */
|
|
141
|
+
accepted: string[];
|
|
142
|
+
}
|
|
143
|
+
//# sourceMappingURL=types.d.ts.map
|
|
@@ -0,0 +1 @@
|
|
|
1
|
+
{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../src/evidence/types.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,oEAAoE;AACpE,eAAO,MAAM,QAAQ,SAAS,CAAC;AAE/B,yEAAyE;AACzE,eAAO,MAAM,oBAAoB,IAAI,CAAC;AAEtC;;;;;;;GAOG;AACH,MAAM,WAAW,QAAQ;IACvB,qCAAqC;IACrC,MAAM,EAAE,MAAM,CAAC;IACf,OAAO,EAAE,MAAM,GAAG,MAAM,GAAG,MAAM,GAAG,OAAO,CAAC;IAC5C;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,+DAA+D;IAC/D,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;CACrB;AAED;;;;;;;;;;;;GAYG;AACH,MAAM,WAAW,SAAS;IACxB,aAAa,EAAE,MAAM,CAAC;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,gDAAgD;IAChD,MAAM,EAAE,MAAM,CAAC;IACf,sDAAsD;IACtD,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;;;;;;OAYG;IACH,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,yEAAyE;IACzE,SAAS,EAAE,MAAM,CAAC;IAClB,OAAO,EAAE,QAAQ,EAAE,CAAC;CACrB;AAED,sFAAsF;AACtF,MAAM,WAAW,WAAW;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,MAAM,EAAE,MAAM,CAAC;IACf,IAAI,CAAC,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,OAAO;IACtB,6EAA6E;IAC7E,UAAU,EAAE,MAAM,CAAC;IACnB,sEAAsE;IACtE,sBAAsB,EAAE,MAAM,CAAC;IAC/B,gCAAgC;IAChC,KAAK,EAAE,MAAM,CAAC;IACd,kDAAkD;IAClD,MAAM,EAAE,MAAM,CAAC;IACf,sEAAsE;IACtE,OAAO,EAAE,MAAM,EAAE,CAAC;IAClB,0DAA0D;IAC1D,YAAY,CAAC,EAAE,WAAW,EAAE,CAAC;CAC9B;AAED;;;;;;GAMG;AACH,MAAM,WAAW,YAAY;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,QAAQ,EAAE,OAAO,EAAE,CAAC;CACrB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,YAAY;IAC3B,aAAa,EAAE,MAAM,CAAC;IACtB,2CAA2C;IAC3C,MAAM,EAAE,MAAM,CAAC;IACf,0DAA0D;IAC1D,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB"}
|