@voltro/plan 0.85.0 → 0.87.0

package/dist/lint.js

@@ -0,0 +1,273 @@
+import { ownerItemOf as e, planNumberOf as t } from "./ids.js";
+import { evidenceSchema as n, findingSchema as r, planInstanceSchema as i } from "./schema.js";
+import { sortDiagnostics as a } from "./diagnostics.js";
+import { DERIVED as o, TRANSITIONS as s, derivedStatus as c, indexEvidence as l, verificationGaps as u } from "./state.js";
+import { closureFileSchema as d, closureState as f, planRevision as p } from "./closure.js";
+import { Cause as m, Exit as h, Schema as g, SchemaIssue as _ } from "effect";
+//#region src/lint.ts
+var v = (e, t, n, r, i, a = []) => ({
+	ruleId: e,
+	severity: t,
+	message: n,
+	locator: r,
+	related: [...a].sort(),
+	nextAction: i
+}), y = _.makeFormatterStandardSchemaV1(), b = (e, t, n, r) => {
+	let i = g.decodeUnknownExit(t, {
+		onExcessProperty: "error",
+		errors: "all"
+	}), a = [];
+	for (let t of e) {
+		let e = i(t.content);
+		if (h.isSuccess(e)) {
+			a.push({
+				file: t.file,
+				value: e.value
+			});
+			continue;
+		}
+		let o = m.findErrorOption(e.cause), s = o._tag === "Some" ? y(o.value.issue).issues : [{
+			message: m.pretty(e.cause),
+			path: []
+		}];
+		for (let e of s) {
+			let i = (e.path ?? []).map((e) => String(typeof e == "object" ? e.key : e));
+			r.push(v("schema/invalid", "error", `${n}: ${e.message}`, {
+				file: t.file,
+				path: i.join(".") || "(root)"
+			}, "Correct the field to the v1 contract; unknown fields are not allowed."));
+		}
+	}
+	return a;
+}, x = [
+	["private key", /-----BEGIN [A-Z ]*PRIVATE KEY-----/],
+	["Stripe key", /\b[sr]k_(live|test)_[A-Za-z0-9]{16,}/],
+	["GitHub token", /\bgh[pousr]_[A-Za-z0-9]{30,}/],
+	["AWS access key", /\bAKIA[0-9A-Z]{16}\b/],
+	["Slack token", /\bxox[abprs]-[A-Za-z0-9-]{10,}/],
+	["bearer token", /\bBearer\s+[A-Za-z0-9._~+/-]{20,}/]
+], S = (e, t, n, r) => {
+	if (typeof e == "string") for (let [i, a] of x) a.test(e) && r.push(v("security/secret", "security", `a ${i} is in the plan artefact`, {
+		file: t,
+		path: n
+	}, "Remove the secret, rotate it, and reference where it is kept instead."));
+	else if (Array.isArray(e)) e.forEach((e, i) => S(e, t, `${n}[${i}]`, r));
+	else if (typeof e == "object" && e) for (let [i, a] of Object.entries(e)) S(a, t, n === "" ? i : `${n}.${i}`, r);
+}, C = (e) => {
+	let t = /* @__PURE__ */ new Set(), n = /* @__PURE__ */ new Map(), r = (r) => {
+		let i = [], a = /* @__PURE__ */ new Set(), o = (r) => {
+			i.push(r), a.add(r);
+			for (let s of [...e.get(r) ?? []].sort()) if (e.has(s)) {
+				if (a.has(s)) {
+					let e = i.slice(i.indexOf(s)), t = e.reduce((e, t) => t < e ? t : e), r = [...e.slice(e.indexOf(t)), ...e.slice(0, e.indexOf(t))];
+					n.set(r.join(">"), r);
+				} else t.has(s) || o(s);
+			}
+			i.pop(), a.delete(r), t.add(r);
+		};
+		o(r);
+	};
+	for (let n of [...e.keys()].sort()) t.has(n) || r(n);
+	return [...n.values()].sort((e, t) => e.join(">") < t.join(">") ? -1 : 1);
+}, w = (m) => {
+	let { shape: h, clock: g } = m, _ = h.grammar, y = [];
+	for (let e of [
+		...m.instances,
+		...m.evidence ?? [],
+		...m.findings ?? [],
+		...m.closures ?? []
+	]) S(e.content, e.file, "", y);
+	let x = b(m.instances, i(h), "plan instance", y).map(({ file: e, value: t }) => ({
+		file: e,
+		instance: t
+	})), w = (m.evidence ?? []).flatMap((e) => b(Array.isArray(e.content) ? e.content.map((t, n) => ({
+		file: `${e.file}#${n}`,
+		content: t
+	})) : [e], n(h), "evidence", y).map((e) => e.value)), T = (m.findings ?? []).flatMap((e) => b(Array.isArray(e.content) ? e.content.map((t, n) => ({
+		file: `${e.file}#${n}`,
+		content: t
+	})) : [e], r(h), "finding", y).map((e) => e.value)), E = /* @__PURE__ */ new Map(), D = /* @__PURE__ */ new Map(), O = /* @__PURE__ */ new Map();
+	for (let { file: n, instance: r } of x) {
+		let i = r.plan;
+		E.has(i.id) && y.push(v("identity/duplicate-plan", "error", `${i.id} is declared in two files`, {
+			file: n,
+			plan: i.id
+		}, "Keep one instance file per plan.", [E.get(i.id)])), E.set(i.id, n), t(i.id) !== i.number && y.push(v("identity/plan-number", "error", `${i.id} has number ${i.number}`, {
+			file: n,
+			plan: i.id,
+			path: "plan.number"
+		}, "Make the number match the plan id."));
+		for (let a of r.workItems) {
+			let r = {
+				file: n,
+				plan: i.id,
+				workItem: a.id
+			};
+			D.has(a.id) ? y.push(v("identity/duplicate-work-item", "error", `${a.id} is declared twice`, r, "Give the second item its own id; ids are never reused.", [D.get(a.id).file])) : D.set(a.id, {
+				file: n,
+				item: a
+			}), (a.ownerPlan !== i.id || t(a.id) !== i.number) && y.push(v("identity/owner-mismatch", "error", `${a.id} is owned by ${a.ownerPlan} but lives in ${i.id}`, r, "Move the item to its plan’s file or correct ownerPlan."));
+			let o = [
+				...a.acceptance.map((e) => e.id),
+				...a.evidenceRequirements.map((e) => e.id),
+				...a.sourceRefs.map((e) => e.id)
+			];
+			for (let t of o) e(_, t) !== a.id && y.push(v("identity/child-id", "error", `${t} does not belong to ${a.id}`, r, `Number it under ${a.id}.`));
+			for (let e of a.sourceRefs) O.has(e.id) && y.push(v("source/duplicate", "error", `source ${e.id} is disposed twice`, r, "Dispose each source block exactly once.", [O.get(e.id)])), O.set(e.id, a.id), e.disposition !== "owned-by" && e.targetId === void 0 && y.push(v("source/missing-target", "error", `source ${e.id} is ${e.disposition} without a target`, {
+				...r,
+				path: `sourceRefs.${e.id}`
+			}, "Name the work item or decision it points to."));
+		}
+		if (m.sources !== void 0) {
+			let e = m.sources.get(i.source);
+			e == null ? y.push(v("source/missing", "error", `${i.id}'s source ${i.source} cannot be read`, {
+				file: n,
+				plan: i.id,
+				path: "plan.source"
+			}, "Restore the source or point the plan at it.")) : (e !== i.sourceRevision || e !== r.extraction.sourceRevision) && y.push(v("source/stale", "error", `${i.source} changed since ${i.id} was decomposed (${i.sourceRevision.slice(0, 19)}… → ${e.slice(0, 19)}…)`, {
+				file: n,
+				plan: i.id,
+				path: "plan.sourceRevision"
+			}, "Regenerate the plan’s decomposition from its source; closure waits until then."));
+		}
+		let a = r.workItems.reduce((e, t) => e + t.sourceRefs.length, 0);
+		(r.coverage.disposedSources !== a || r.coverage.unmatchedSources > 0 || r.coverage.duplicateSources > 0 || i.decompositionComplete && r.coverage.result !== "complete") && y.push(v("source/coverage", "error", `${i.id} claims ${r.coverage.disposedSources} disposed sources (${r.coverage.unmatchedSources} unmatched, ${r.coverage.duplicateSources} duplicate, ${r.coverage.result}) and holds ${a}`, {
+			file: n,
+			plan: i.id,
+			path: "coverage"
+		}, "Regenerate the plan’s decomposition from its source."));
+	}
+	let k = new Set(w.map((e) => e.id));
+	for (let { file: e, item: t } of D.values()) {
+		let n = {
+			file: e,
+			plan: t.ownerPlan,
+			workItem: t.id
+		};
+		for (let e of t.dependsOn) e === t.id ? y.push(v("graph/self-dependency", "error", `${t.id} depends on itself`, n, "Remove the dependency.")) : D.has(e) || y.push(v("graph/missing-dependency", "error", `${t.id} depends on ${e}, which does not exist`, n, "Point at an existing item or remove the dependency.", [e]));
+		if (m.decisions !== void 0) for (let e of t.links.adrs) m.decisions.has(e) || y.push(v("graph/missing-decision", "error", `${t.id} links ${e}, which the decision records do not hold`, n, "Add the decision record or correct the link.", [e]));
+		for (let e of t.links.relatedTo) D.has(e) || y.push(v("graph/missing-related", "error", `${t.id} relates to ${e}, which does not exist`, n, "Point at an existing item.", [e]));
+		t.supersededBy !== void 0 && !D.has(t.supersededBy) && y.push(v("graph/missing-successor", "error", `${t.id} is superseded by ${t.supersededBy}, which does not exist`, n, "Name the item that replaces it.", [t.supersededBy]));
+		let r = [
+			...t.evidenceRefs,
+			...t.acceptance.flatMap((e) => e.evidenceRefs),
+			...t.evidenceRequirements.flatMap((e) => e.evidenceRefs),
+			...t.statusHistory.flatMap((e) => e.evidenceRefs)
+		];
+		for (let e of [...new Set(r)].sort()) k.has(e) || y.push(v("evidence/missing", "error", `${t.id} names evidence ${e}, which does not exist`, n, "Add the evidence with `voltro plan evidence add` or remove the reference.", [e]));
+		t.owners.length === 0 && y.push(v("quality/no-owner", "warning", `${t.id} has no owner`, n, "Name who owns the item."));
+	}
+	for (let e of C(new Map([...D.values()].map(({ item: e }) => [e.id, e.dependsOn])))) {
+		let t = D.get(e[0]);
+		y.push(v("graph/cycle", "error", `dependency cycle: ${[...e, e[0]].join(" → ")}`, {
+			file: t.file,
+			plan: t.item.ownerPlan,
+			workItem: e[0]
+		}, "Break the cycle: one of these items must not wait for the others.", e));
+	}
+	for (let e of T) for (let t of e.targetWorkItems) D.has(t) || y.push(v("graph/missing-finding-target", "error", `finding ${e.id} targets ${t}, which does not exist`, { workItem: t }, "Point the finding at an existing item.", [e.id]));
+	for (let { file: e, item: t } of D.values()) {
+		let n = {
+			file: e,
+			plan: t.ownerPlan,
+			workItem: t.id
+		};
+		for (let e of t.acceptance) e.status !== "pending" && e.evidenceRefs.length === 0 && y.push(v("acceptance/decided-without-evidence", "error", `${e.id} is ${e.status} without evidence`, {
+			...n,
+			path: e.id
+		}, "Name the evidence the decision rests on."));
+		for (let e of t.evidenceRequirements) e.status === "satisfied" && e.evidenceRefs.length === 0 && y.push(v("acceptance/satisfied-without-evidence", "error", `${e.id} is satisfied without evidence`, {
+			...n,
+			path: e.id
+		}, "Name the evidence that satisfies it.")), e.status === "waived" && e.waiver === void 0 && y.push(v("acceptance/waived-without-waiver", "error", `${e.id} is waived without a waiver`, {
+			...n,
+			path: e.id
+		}, "Write the waiver: rationale, reviewer, expiry and compensating control."));
+	}
+	let A = l(w, T), j = /* @__PURE__ */ new Map(), M = /* @__PURE__ */ new Map(), N = /* @__PURE__ */ new Set(), P = (e) => {
+		let t = j.get(e);
+		if (t !== void 0) return t;
+		let n = D.get(e);
+		if (n === void 0 || N.has(e)) return;
+		N.add(e);
+		let r = u(n.item, A, P, g);
+		N.delete(e);
+		let i = c(n.item, r);
+		return j.set(e, i), M.set(e, r), i;
+	};
+	for (let { file: e, item: t } of [...D.values()].sort((e, t) => e.item.id < t.item.id ? -1 : 1)) {
+		let n = {
+			file: e,
+			plan: t.ownerPlan,
+			workItem: t.id
+		}, r = null;
+		t.statusHistory.forEach((e, i) => {
+			e.from === r ? e.from !== null && !s[e.from].includes(e.to) && y.push(v("state/forbidden-transition", "error", `${t.id} went ${e.from} → ${e.to}`, {
+				...n,
+				path: `statusHistory[${i}]`
+			}, `From ${e.from} an item goes to ${s[e.from].join(", ")}.`)) : y.push(v("state/history-break", "error", `${t.id} history step ${i + 1} starts at ${e.from ?? "nothing"}, after ${r ?? "nothing"}`, {
+				...n,
+				path: `statusHistory[${i}]`
+			}, "Record every transition in order.")), r = e.to;
+		}), r !== t.status && y.push(v("state/history-end", "error", `${t.id} is ${t.status} but its history ends at ${r ?? "nothing"}`, {
+			...n,
+			path: "status"
+		}, "Record the transition that led to the current state.")), t.status === "blocked" && t.blocker === void 0 && y.push(v("state/blocked-without-blocker", "error", `${t.id} is blocked without a blocker`, {
+			...n,
+			path: "blocker"
+		}, "Write down reason, owner, next action and recheck trigger.")), t.status !== "blocked" && t.blocker !== void 0 && y.push(v("state/blocker-not-blocked", "error", `${t.id} carries a blocker but is ${t.status}`, {
+			...n,
+			path: "blocker"
+		}, "Remove the blocker or record the block.")), P(t.id);
+	}
+	let F = /* @__PURE__ */ new Map();
+	for (let { file: e, value: t } of b(m.closures ?? [], d(h), "closure record", y)) E.has(t.plan) ? F.has(t.plan) ? y.push(v("closure/duplicate", "error", `${t.plan} has two closure records`, {
+		file: e,
+		plan: t.plan
+	}, "Keep one closure record per plan.", [F.get(t.plan).file])) : F.set(t.plan, {
+		file: e,
+		record: t
+	}) : y.push(v("closure/unknown-plan", "error", `a closure record names ${t.plan}, which does not exist`, {
+		file: e,
+		plan: t.plan
+	}, "Remove it or correct the plan id."));
+	let I = /* @__PURE__ */ new Map(), L = /* @__PURE__ */ new Map();
+	for (let { instance: e } of x) {
+		let t = p(e, w, T, (e) => j.get(e), m.decisions);
+		I.set(e.plan.id, t);
+		let n = F.get(e.plan.id), r = f(n?.record, t);
+		if (L.set(e.plan.id, r), n !== void 0 && n.record.certificates.length > 0 && r.state !== "certified" && y.push(v("closure/stale-certificate", "warning", `${e.plan.id} changed after its certificate ${n.record.certificates.at(-1).id}: it is open again`, {
+			file: n.file,
+			plan: e.plan.id
+		}, "Verify what changed and run both closure passes again.")), r.state === "certified") for (let t of e.workItems) j.get(t.id) === "verified" && j.set(t.id, "closed");
+		e.plan.status === "complete" && r.state !== "certified" && y.push(v("state/manual-derived", "error", `${e.plan.id} says complete without a certificate on its current revision`, {
+			plan: e.plan.id,
+			path: "plan.status"
+		}, "Close it with both passes: voltro plan close <plan>."));
+	}
+	for (let { file: e, item: t } of [...D.values()].sort((e, t) => e.item.id < t.item.id ? -1 : 1)) {
+		let n = j.get(t.id);
+		o.has(t.status) && n !== t.status && (t.status !== "verified" || n !== "closed") && y.push(v("state/manual-derived", "error", `${t.id} says ${t.status}; the evidence says ${n}: ${(M.get(t.id) ?? []).slice(0, 3).join("; ") || "its plan holds no certificate on its current revision"}`, {
+			file: e,
+			plan: t.ownerPlan,
+			workItem: t.id,
+			path: "status"
+		}, "Add the missing evidence; verified and closed are derived, never set."));
+	}
+	return {
+		program: {
+			instances: x,
+			items: D,
+			evidence: w,
+			findings: T,
+			status: j,
+			gaps: M,
+			closures: F,
+			revisions: I,
+			closure: L
+		},
+		diagnostics: a(y)
+	};
+};
+//#endregion
+export { C as dependencyCycles, w as lintProgram };

package/dist/manifest.js

@@ -0,0 +1,16 @@
+import { Schema as e } from "effect";
+//#region src/manifest.ts
+var t = "voltro-plan-manifest/v1", n = e.String.pipe(e.check(e.isMinLength(1)), e.check(e.makeFilter((e) => !e.startsWith("/") && !/^[A-Za-z]:/.test(e) && !e.split("/").includes("..") || "a path stays inside the project root"))), r = e.Struct({
+	schemaVersion: e.Literal(t),
+	prefix: e.String.pipe(e.check(e.isPattern(/^[A-Z][A-Z0-9]{1,9}$/))),
+	instanceVersion: e.String.pipe(e.check(e.isMinLength(1))),
+	repos: e.Array(e.String.pipe(e.check(e.isMinLength(1)))).pipe(e.check(e.isMinLength(1))),
+	instances: e.Array(n).pipe(e.check(e.isMinLength(1))),
+	evidence: e.optional(e.Array(n)),
+	evidenceDir: e.optional(n),
+	closureDir: e.optional(n),
+	adrDir: e.optional(n),
+	findings: e.optional(e.Array(n))
+});
+//#endregion
+export { t as MANIFEST_SCHEMA_VERSION, r as Manifest };

package/dist/next.js

@@ -0,0 +1,64 @@
+//#region src/next.ts
+var e = {
+	P0: 0,
+	P1: 1,
+	P2: 2,
+	P3: 3
+}, t = (t, n, r) => {
+	if (r) return {
+		outcome: "invalid",
+		reason: "lint reports blocking diagnostics; fix them first (`voltro plan lint`)"
+	};
+	let i = (e) => t.status.get(e), a = new Set([...t.items.values()].filter(({ item: e }) => [
+		"active",
+		"verified",
+		"closed"
+	].includes(i(e.id) ?? "")).map(({ item: e }) => e.ownerPlan)), o = [...t.items.values()].filter(({ item: e }) => e.mandatory && e.supersededBy === void 0 && (n.plan === void 0 || e.ownerPlan === n.plan || e.ownerPlan.endsWith(`-PLAN-${n.plan}`)) && (n.owner === void 0 || e.owners.includes(n.owner)) && (n.repo === void 0 || e.repos.includes(n.repo)));
+	if (o.every(({ item: e }) => ["verified", "closed"].includes(i(e.id) ?? ""))) return { outcome: "complete" };
+	let s = (e) => e.dependsOn.every((e) => ["verified", "closed"].includes(i(e) ?? "")), c = (t) => [
+		i(t.id) === "active" ? 0 : 1,
+		e[t.priority],
+		t.kind === "security" ? 0 : 1,
+		+!a.has(t.ownerPlan),
+		+!s(t),
+		t.id
+	], l = (e, t) => {
+		for (let n = 0; n < e.length; n++) if (e[n] !== t[n]) return e[n] < t[n];
+		return !1;
+	}, u = (e) => {
+		let t;
+		for (let n of o) {
+			if (!e.includes(i(n.item.id) ?? "")) continue;
+			let r = c(n.item);
+			(t === void 0 || l(r, t.rank)) && (t = {
+				entry: n,
+				rank: r
+			});
+		}
+		return t;
+	}, d = u(["active", "ready"]);
+	if (d !== void 0) {
+		let e = d.entry, t = i(e.item.id);
+		return {
+			outcome: "item",
+			workItem: e.item,
+			file: e.file,
+			why: [
+				t === "active" ? "it is already active" : "it is ready",
+				`priority ${e.item.priority}`,
+				...e.item.kind === "security" ? ["security work comes first"] : [],
+				a.has(e.item.ownerPlan) ? `${e.item.ownerPlan} is already under way` : "no started plan has workable items",
+				d.rank[4] === 0 ? "its dependencies are verified" : "no dependency-ready item is left, so it waits on its dependencies"
+			]
+		};
+	}
+	let f = u(["proposed"]), p = o.filter(({ item: e }) => i(e.id) === "proposed").length, m = o.filter(({ item: e }) => i(e.id) === "blocked").length;
+	return {
+		outcome: "blocked",
+		reason: `no mandatory item is active or ready: ${p} proposed await readiness${m > 0 ? `, ${m} blocked` : ""}`,
+		prepare: f?.entry.item ?? null,
+		file: f?.entry.file ?? null
+	};
+};
+//#endregion
+export { t as nextItem };

package/dist/schema.js

@@ -0,0 +1,216 @@
+import { Schema as e } from "effect";
+//#region src/schema.ts
+var t = e.String.pipe(e.check(e.isMinLength(1))), n = e.String.pipe(e.check(e.isPattern(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}(:\d{2}(\.\d+)?)?(Z|[+-]\d{2}:\d{2})$/))), r = e.String.pipe(e.check(e.isPattern(/^sha256:[a-f0-9]{64}$/))), i = (t) => e.Array(t).pipe(e.check(e.makeFilter((e) => new Set(e).size === e.length || "items are listed twice"))), a = (t) => e.Array(t).pipe(e.check(e.isMinLength(1))), o = e.String.pipe(e.check(e.isPattern(/^[a-z0-9]+(?:[.:/-][a-z0-9]+)*$/))), s = [
+	"proposed",
+	"ready",
+	"active",
+	"blocked",
+	"verified",
+	"closed"
+], c = [
+	"proposed",
+	"decomposing",
+	"ready",
+	"active",
+	"verifying",
+	"closure-1",
+	"closure-2",
+	"complete"
+], l = [
+	"commit",
+	"typecheck",
+	"unit-test",
+	"integration-test",
+	"e2e",
+	"browser",
+	"schema",
+	"migration",
+	"roundtrip",
+	"documentation",
+	"agent-guide",
+	"template",
+	"security",
+	"privacy",
+	"accessibility",
+	"rights",
+	"operations",
+	"performance",
+	"research",
+	"review",
+	"artifact"
+], u = [
+	"P0",
+	"P1",
+	"P2",
+	"P3"
+], d = [
+	"architecture",
+	"feature",
+	"framework",
+	"integration",
+	"migration",
+	"operations",
+	"security",
+	"documentation",
+	"research",
+	"tooling"
+], f = (t) => e.String.pipe(e.check(e.isPattern(t))), p = (p) => {
+	let m = p.grammar, h = i(f(m.evidence)), g = e.Struct({
+		id: f(m.source),
+		uri: t,
+		locator: t,
+		excerpt: t,
+		lineHint: e.optional(e.Int.pipe(e.check(e.isGreaterThanOrEqualTo(1)))),
+		contentHash: r,
+		disposition: e.Literals([
+			"owned-by",
+			"referenced-by",
+			"decision",
+			"non-goal"
+		]),
+		targetId: e.optional(e.Union([f(m.workItem), f(m.adr)]))
+	}), _ = e.Struct({
+		id: f(m.acceptance),
+		statement: t,
+		status: e.Literals([
+			"pending",
+			"passed",
+			"failed"
+		]),
+		evidenceRefs: h
+	}), v = e.Struct({
+		rationale: t,
+		reviewer: t,
+		expiresAt: n,
+		compensatingControl: t
+	}), y = e.Struct({
+		id: f(m.requirement),
+		statement: t,
+		kinds: a(e.Literals(l)),
+		status: e.Literals([
+			"open",
+			"satisfied",
+			"waived"
+		]),
+		evidenceRefs: h,
+		waiver: e.optional(v)
+	}), b = e.Struct({
+		capabilities: e.Array(t),
+		journeys: e.Array(t),
+		adrs: i(f(m.adr)),
+		risks: e.Array(t),
+		relatedTo: i(f(m.workItem))
+	}), x = e.Struct({
+		reason: t,
+		owner: t,
+		nextAction: t,
+		recheckTrigger: t,
+		since: n
+	}), S = e.Struct({
+		from: e.NullOr(e.Literals(s)),
+		to: e.Literals(s),
+		reason: t,
+		actor: t,
+		at: n,
+		evidenceRefs: h
+	}), C = e.Struct({
+		id: f(m.workItem),
+		title: t,
+		ownerPlan: f(m.plan),
+		slice: t,
+		kind: e.Literals(d),
+		priority: e.Literals(u),
+		mandatory: e.Boolean,
+		status: e.Literals(s),
+		owners: e.Array(t),
+		repos: a(e.Literals(p.repos)),
+		sourceRefs: a(g),
+		dependsOn: i(f(m.workItem)),
+		links: b,
+		acceptance: a(_),
+		evidenceRequirements: a(y),
+		evidenceRefs: h,
+		impactTags: a(o),
+		statusHistory: a(S),
+		blocker: e.optional(x),
+		supersededBy: e.optional(f(m.workItem)),
+		createdAt: n,
+		updatedAt: n
+	}), w = e.Struct({
+		id: f(m.plan),
+		number: e.String.pipe(e.check(e.isPattern(/^[0-9]{2}$/))),
+		title: t,
+		source: t,
+		sourceRevision: r,
+		status: e.Literals(c),
+		decompositionComplete: e.Boolean,
+		updatedAt: n
+	}), T = e.Struct({
+		rulesVersion: t,
+		sourceRevision: r,
+		blockKinds: e.Array(t),
+		extractedAt: n
+	}), E = e.Struct({
+		extractedSources: e.Int,
+		disposedSources: e.Int,
+		unmatchedSources: e.Int,
+		duplicateSources: e.Int,
+		sourceIdsHash: r,
+		result: e.Literals(["complete", "incomplete"])
+	});
+	return e.Struct({
+		schemaVersion: e.Literal(p.instanceVersion),
+		plan: w,
+		extraction: T,
+		workItems: e.Array(C),
+		coverage: E
+	});
+}, m = (i) => e.Struct({
+	id: f(i.grammar.evidence),
+	kind: e.Literals(l),
+	title: t,
+	uri: t,
+	fingerprint: e.optional(r),
+	result: e.Literals([
+		"passed",
+		"failed",
+		"informational"
+	]),
+	subjectRefs: e.Array(t),
+	command: e.optional(t),
+	environment: e.optional(t),
+	producedBy: t,
+	reviewedBy: e.optional(t),
+	observedAt: n,
+	idempotencyKey: e.optional(t)
+}), h = (r) => e.Struct({
+	id: f(r.grammar.finding),
+	title: t,
+	severity: e.Literals([
+		"critical",
+		"high",
+		"medium",
+		"low"
+	]),
+	status: e.Literals([
+		"open",
+		"resolved",
+		"accepted-risk"
+	]),
+	source: e.Literals([
+		"contract-reconciliation",
+		"adversarial-audit",
+		"test",
+		"incident",
+		"research",
+		"review",
+		"production"
+	]),
+	targetWorkItems: a(f(r.grammar.workItem)),
+	impactTags: e.Array(t),
+	evidenceRefs: e.optional(i(f(r.grammar.evidence))),
+	openedAt: n,
+	resolvedAt: e.optional(n)
+});
+//#endregion
+export { l as EVIDENCE_KINDS, d as ITEM_KINDS, c as PLAN_STATUSES, u as PRIORITIES, s as WORK_ITEM_STATUSES, m as evidenceSchema, h as findingSchema, p as planInstanceSchema };

package/dist/state.js

@@ -0,0 +1,67 @@
+//#region src/state.ts
+var e = {
+	proposed: ["ready", "blocked"],
+	ready: [
+		"active",
+		"blocked",
+		"proposed"
+	],
+	active: [
+		"blocked",
+		"verified",
+		"ready"
+	],
+	blocked: [
+		"proposed",
+		"ready",
+		"active"
+	],
+	verified: ["closed", "active"],
+	closed: ["active"]
+}, t = /* @__PURE__ */ new Set(["verified", "closed"]), n = (e, t) => {
+	let n = /* @__PURE__ */ new Map();
+	for (let e of t) if (e.status === "open") for (let t of e.targetWorkItems) {
+		let r = n.get(t);
+		r === void 0 ? n.set(t, [e]) : r.push(e);
+	}
+	let r = /* @__PURE__ */ new Map();
+	for (let t of e) for (let e of new Set(t.subjectRefs)) {
+		let n = r.get(e);
+		n === void 0 ? r.set(e, [t]) : n.push(t);
+	}
+	return {
+		evidence: new Map(e.map((e) => [e.id, e])),
+		bySubject: r,
+		openFindings: n
+	};
+}, r = (e, t, n, r) => e.result === "passed" && e.subjectRefs.includes(n) && (r === void 0 || r.includes(e.kind)) && Date.parse(e.observedAt) >= Date.parse(t.updatedAt), i = (e, t, n, i) => {
+	let a = [], o = t.bySubject.get(e.id) ?? [], s;
+	if (e.acceptance.length > 4 || e.acceptance.length + e.evidenceRequirements.length > 4 && e.acceptance.length + e.evidenceRequirements.filter((e) => e.status !== "waived").length > 4) {
+		let t = /* @__PURE__ */ new Set([...e.acceptance.map((e) => e.id), ...e.evidenceRequirements.filter((e) => e.status !== "waived").map((e) => e.id)]);
+		s = /* @__PURE__ */ new Map();
+		let n = Date.parse(e.updatedAt);
+		for (let e of o) if (e.result === "passed" && Date.parse(e.observedAt) >= n) for (let n of e.subjectRefs) {
+			if (!t.has(n)) continue;
+			let r = s.get(n);
+			r === void 0 ? s.set(n, /* @__PURE__ */ new Set([e.kind])) : r.add(e.kind);
+		}
+	}
+	let c = (t, n) => {
+		if (s === void 0) return o.some((i) => r(i, e, t, n));
+		let i = s.get(t);
+		return i !== void 0 && (n === void 0 || n.some((e) => i.has(e)));
+	}, l = (n, i) => n.some((n) => {
+		let a = t.evidence.get(n);
+		return a !== void 0 && r(a, e, e.id, i);
+	});
+	for (let t of e.acceptance) !c(t.id) && !(t.status === "passed" && l(t.evidenceRefs)) && a.push(`acceptance ${t.id} has no passing evidence`);
+	for (let t of e.evidenceRequirements) t.status === "waived" ? (t.waiver === void 0 || Date.parse(t.waiver.expiresAt) <= i.now().getTime()) && a.push(`the waiver of ${t.id} has expired`) : !c(t.id, t.kinds) && !l(t.evidenceRefs, t.kinds) && a.push(`requirement ${t.id} has no passing ${t.kinds.join("/")} evidence`);
+	for (let n of t.openFindings.get(e.id) ?? []) a.push(`finding ${n.id} is open`);
+	for (let t of e.dependsOn) {
+		let e = n(t);
+		e !== "verified" && e !== "closed" && a.push(`dependency ${t} is ${e ?? "missing"}`);
+	}
+	return a;
+}, a = (e, n) => n.length === 0 ? "verified" : t.has(e.status) ? "active" : e.status;
+//#endregion
+export { t as DERIVED, e as TRANSITIONS, a as derivedStatus, n as indexEvidence, i as verificationGaps };

package/dist/status.js

@@ -0,0 +1,35 @@
+import { WORK_ITEM_STATUSES as e } from "./schema.js";
+//#region src/status.ts
+var t = () => Object.fromEntries(e.map((e) => [e, 0])), n = (e) => {
+	let n = t();
+	return {
+		plans: e.instances.map(({ file: r, instance: i }) => {
+			let a = t(), o = t(), s = [];
+			for (let t of i.workItems) {
+				let r = e.status.get(t.id) ?? t.status;
+				(t.mandatory ? a : o)[r]++, t.mandatory && n[r]++, r === "blocked" && t.blocker !== void 0 && s.push({
+					workItem: t.id,
+					reason: t.blocker.reason,
+					owner: t.blocker.owner,
+					nextAction: t.blocker.nextAction
+				});
+			}
+			let c = i.workItems.filter((e) => e.mandatory).length, l = a.verified + a.closed, u = e.closure.get(i.plan.id), d = i.plan.decompositionComplete ? u?.state === "certified" ? "complete" : c > 0 && l === c ? u?.state === "closure-1" ? "closure-1" : "verifying" : a.active + a.blocked + l > 0 ? "active" : a.ready > 0 ? "ready" : "decomposing" : "decomposing";
+			return {
+				plan: i.plan.id,
+				title: i.plan.title,
+				file: r,
+				recorded: i.plan.status,
+				derived: d,
+				certificate: u?.state === "certified" ? u.certificate.id : null,
+				mandatory: a,
+				optional: o,
+				blocked: s.sort((e, t) => e.workItem < t.workItem ? -1 : 1)
+			};
+		}).sort((e, t) => e.plan < t.plan ? -1 : 1),
+		mandatory: n,
+		items: e.items.size
+	};
+};
+//#endregion
+export { n as programStatus };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voltro/plan",
-  "version": "0.85.0",
+  "version": "0.87.0",
   "description": "The executable plan contract: ids, the v1 schema, lint, derived state, status and the next item — pure and browser-safe; the voltro plan CLI feeds it.",
   "keywords": [
     "voltro",