// **A member refused after every member was judged is said and raised** (novox/hq design 47 H ยง767; H-A-1, H-A-18, // H-A-81): when the forge refuses a member after all were judged, the call stops merging and the forge module raises the // finding `merge-partial`, scope `delivery`, id the call, naming each refused member, severity urgent, resolver operator, // in its own state `findings`, which the condition keeper reads. It clears it when a later call lands every refused member // (read from its own `calls`), or by its tool `forge_partial_clear` with `call` and `why`, written in the hand-act log. import type { State } from "@novox/mesh-sdk/state"; import { findingKey } from "./catalog.js"; import type { Calls, KeptCall } from "./calls.js"; export const MERGE_PARTIAL = "merge-partial"; const SCOPE = "delivery"; /** The key of a call's merge-partial in the state findings. */ export const partialKey = (call: string): string => findingKey(SCOPE, call, MERGE_PARTIAL); /** A member's name in a finding, `#`. */ const named = (m: { repository: string; number: number }) => `${m.repository}#${m.number}`; /** The merge-partial of a call the forge refused a member of after judging, as the condition keeper reads it. */ export function partialValue(c: KeptCall, observer = "gitea"): { key: string; value: Record } { const key = partialKey(c.call); const landed = c.members.filter((m) => m.state === "merged").map(named); const refused = c.members.filter((m) => m.state === "refused"); const summary = `the merge call ${c.call} by ${c.by} landed ${landed.length ? landed.join(", ") : "none"} and not ` + refused.map((m) => `${named(m)} (${m.why ?? "refused"})`).join(", "); return { key, value: { v: 1, key, kind: MERGE_PARTIAL, subject: { scope: SCOPE, id: c.call }, severity: "urgent", resolver: "operator", summary, headline: `A merge call landed in part: ${refused.map(named).join(", ")} not merged`, explanation: `The forge refused ${refused.map(named).join(", ")} after every member of the merge call ${c.call} was judged, so ` + `the repositories stand half-merged. A later merge call that lands them clears this, or forge_partial_clear with why.`, resolved: "", evidence: [{ at: c.at, said: summary }], source: `${observer}.${MERGE_PARTIAL}`, observer, at: c.at, } }; } export class Partials { constructor(private readonly findings: State, private readonly calls: Calls, private readonly log: (line: string) => void = () => {}) {} /** Raises merge-partial for a call the forge refused a member of after judging. */ async raise(c: KeptCall): Promise { const f = partialValue(c); await this.findings.put(f.key, f.value); this.log(`merge-partial raised: ${String(f.value.summary)}`); } /** The calls whose merge-partial is held, newest first. */ async held(): Promise { const out: KeptCall[] = []; for (const c of await this.calls.all()) if ((await this.findings.get(partialKey(c.call)))?.value) out.push(c); return out; } /** After a call landed members: every held merge-partial whose refused members a later call landed, each, is cleared. * Answers the calls cleared. */ async landed(): Promise { const all = await this.calls.all(); // newest first const cleared: string[] = []; for (const [i, c] of all.entries()) { if (!(await this.findings.get(partialKey(c.call)))?.value) continue; const later = new Set(all.slice(0, i).flatMap((x) => x.members.filter((m) => m.state === "merged").map(named))); const refused = c.members.filter((m) => m.state === "refused").map(named); if (refused.every((r) => later.has(r))) { await this.findings.delete(partialKey(c.call)); cleared.push(c.call); this.log(`merge-partial of ${c.call} cleared: a later call landed ${refused.join(", ")}`); } } return cleared; } /** Clears one call's merge-partial by hand (forge_partial_clear); answers whether one was held. */ async clear(call: string): Promise { const held = !!(await this.findings.get(partialKey(call)))?.value; if (held) await this.findings.delete(partialKey(call)); return held; } }