@pmelab/gtd 54.0.0 → 56.0.0

package/src/workflows/shared/review.ts

@@ -9,7 +9,6 @@ import {
   requireRevert,
   restoreScript,
   run,
-  showScript,
   vars,
   writeScript,
   type JudgeQuestion,
@@ -21,7 +20,6 @@ import {
   reviewChunks,
   reviewRisks,
   reviewSections,
-  sectionedReview,
   type ReviewNote,
 } from "../../steering/index.js"
 import * as kit from "../../workflow-kit/index.js"
@@ -195,214 +193,59 @@ const triage =
     )
   }
 
-/** Review order: security, one-way doors, the judge unsure, then should, then could. */
-const chunkKey = (s: Severity): number =>
-  s.tier === "could" ? 4 : s.tier === "should" ? 3 : s.security === true ? 0 : s.rank === 0 ? 1 : 2
-
-type Pointer = ReturnType<typeof reviewChunks>[number]["files"][number]
-
-/** A chunk's text, then the code each of its pointers covers: a bare path the whole file. */
-const chunkEvidence = (text: string, files: readonly Pointer[]): string =>
-  [
-    text,
-    ...files.map(({ path, line, rangeEnd }) => {
-      const where = `${path}${line === undefined ? "" : `#${line}${rangeEnd === undefined ? "" : `-${rangeEnd}`}`}`
-      const lines = read(path.replace(/^\.\//, ""))?.split("\n")
-      if (lines === undefined) return `${where}: no longer exists`
-      const code = line === undefined ? lines : lines.slice(line - 1, rangeEnd ?? line)
-      return `${where}:\n${code.join("\n")}`
-    }),
-  ].join("\n\n")
-
-const bytes = (text: string): number => new TextEncoder().encode(text).length
-
-/** Fills each batch while the budget's even share still holds its widest evidence, so nothing is cut that fits alone. */
-const batched = <T extends { readonly evidence: string }>(
-  items: readonly T[],
-  budget: number,
-): T[][] => {
-  const batches: T[][] = []
-  let batch: T[] = []
-  let widest = 0
-  for (const item of items) {
-    const size = bytes(item.evidence)
-    if (batch.length > 0 && Math.floor(budget / (batch.length + 1)) < Math.max(widest, size)) {
-      batches.push(batch)
-      batch = []
-      widest = 0
-    }
-    batch.push(item)
-    widest = Math.max(widest, size)
-  }
-  return batch.length === 0 ? batches : [...batches, batch]
-}
-
-/**
- * Rates every chunk the reviewer wrote and sorts the \`findings\` among them
- * first in \`full\`, each led by its tier and reason; a walkthrough chunk
- * keeps its place and carries no tier. It is still rated, so a review with no
- * findings still reaches \`review.ranking\` and older histories replay.
- */
-const ranked = async (
-  review: string,
-  full: string,
-  findings: ReadonlySet<string>,
-): Promise<string> => {
-  const texts = t.chunkTexts(full)
-  const chunks = reviewChunks(review).map((c, i) => ({
-    id: `C${i + 1}`,
-    title: c.title,
-    evidence: chunkEvidence(texts.get(c.title) ?? "", c.files),
-  }))
-  if (chunks.length === 0) return full
-  const minP = numeric(vars.reviewSeverityMinP, Infinity)
-  const batches = batched(chunks, numeric(vars.judgeBudgetBytes, 32768))
-  const severities = new Map<string, Severity>()
-  for (const [i, batch] of batches.entries()) {
-    const judgment = await judge("review.ranking", {
-      questions: batch.flatMap((c) =>
-        severityQuestions(
-          c.id,
-          `the change review chunk "${c.id}" ("${c.title}") walks through`,
-          `the change in review chunk "${c.id}"`,
-        ),
-      ),
-      evidence: Object.fromEntries(batch.map((c) => [c.id, c.evidence])),
-      message: t.reviewRankingMessage(),
-      label:
-        batches.length === 1
-          ? "Ranking the review"
-          : `Ranking the review (${i + 1}/${batches.length})`,
-    })
-    for (const c of batch) severities.set(c.id, severityOf(c, judgment, minP))
-  }
-  return t.rankedReview(
-    full,
-    chunks
-      .map((c, i) => ({ c, i, s: severities.get(c.id)! }))
-      .filter(({ c }) => findings.has(c.title))
-      .sort((x, y) => chunkKey(x.s) - chunkKey(y.s) || x.i - y.i)
-      .map(({ c, s }) => ({ title: c.title, label: s.reason })),
-  )
-}
-
 export const isCode = (path: string): boolean => path !== ".gtd" && !path.startsWith(".gtd/")
 
-const composedOf = (
-  base: string,
-  report: LensReport,
-  nitFix: string | undefined,
-  answered: ReadonlySet<string>,
-): t.ComposedReview => ({
-  ...report,
-  nitFix,
-  answered,
-  standards: {
-    added: standardsAddedSince(base),
-    undecided: parseStandards(read(STANDARDS) ?? "").undecided,
-  },
-})
-
-/**
- * gtd writes `.gtd/REVIEW.md` from the quality lap's `report` — no reviewer
- * turn. A re-review
- * after fixed nits restores the doc as committed at `carry`, answers kept;
- * a fresh one leaves out the notes the human already answered.
- */
-const composing = (
-  base: string,
-  report: LensReport,
-  carry?: string,
-  nitFix?: string,
-  answered: ReadonlySet<string> = new Set(),
-): Promise<void> =>
-  run(
-    "review.composing",
-    carry === undefined
-      ? writeScript(
-          REVIEW,
-          t.composedReview(base, {
-            ...composedOf(base, report, nitFix, answered),
-            weakened: kit.removedAssertions(changesSince(base)),
-          }),
-        )
-      : showScript(carry, REVIEW, REVIEW),
-    { label: "Composing the review", file: REVIEW, base },
-  )
-
-/**
- * Refuses a review with a chunk pointing at no code, or a lap note without a
- * chunk of its own. A range with no code change has nothing to point at, so
- * there only a note's chunk needs a pointer.
- */
-const requirePointers = (
-  review: string,
-  notes: readonly { title: string }[],
-  codeChanged: boolean,
-): void => {
+/** Refuses a review with a chunk pointing at no code; a range with no code change has nothing to point at. */
+const requirePointers = (review: string, codeChanged: boolean): void => {
   const chunks = reviewChunks(review)
-  const titles = new Set(chunks.map((c) => c.title))
-  const noted = new Set(notes.map((n) => n.title))
   const problems = [
     ...chunks
-      .filter((c) => c.pointers === 0 && (codeChanged || noted.has(c.title)))
+      .filter((c) => c.pointers === 0 && codeChanged)
       .map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — points at no code`),
     ...chunks
       .filter((c) => isConflictTitle(c.title))
       .map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — gtd writes conflicts; leave it out`),
-    ...notes.filter((n) => !titles.has(n.title)).map((n) => `  - ${n.title} — no chunk of its own`),
     // Notes and answers are matched to their chunk by title.
     ...chunks
       .filter((c, i) => chunks.findIndex((d) => d.title === c.title) !== i)
       .map((c) => `  - ${REVIEW}:${c.line + 1}: ${c.title} — a second chunk with this title`),
     ...reviewSections(review).map(
       (s) =>
-        `  - ${REVIEW}:${s.line + 1}: ${REVIEW_SECTIONS[s.section]} — gtd sorts the chunks into sections; write \`## \` chunks only`,
+        `  - ${REVIEW}:${s.line + 1}: ${REVIEW_SECTIONS[s.section]} — write \`## \` chunks only`,
     ),
-    // A risk is fixed before the human sees it; a note is the human's to decide.
-    ...reviewRisks(review)
-      .filter((r) => [...noted].some((title) => r.anchor.startsWith(`${title} ./`)))
-      .map((r) => `  - ${r.anchor} — no \`Risk:\` in a quality finding's chunk`),
   ]
   if (problems.length === 0) return
   refuse(
-    `gtd land: review-pointers: ${problems.length} problem(s) in ${REVIEW} — every chunk needs a pointer to its code, and every quality finding its own chunk, headed exactly as the prompt gave it:\n${problems.join("\n")}`,
+    `gtd land: review-pointers: ${problems.length} problem(s) in ${REVIEW} — every chunk needs a pointer to its code:\n${problems.join("\n")}`,
   )
 }
 
 /**
  * A reviewer walks the human through everything since `base`, every chunk
- * pointing at its code and each of the lap's notes a chunk of its own; gtd
- * then adds each note's text and answer boxes, and the summary chunks.
+ * pointing at its code; gtd then appends the summary chunks.
  */
 const walkthrough = async (
   base: string,
-  report: t.ComposedReview,
+  summary: t.ReviewSummary,
   lap: t.ReviewRange,
   carry: string | undefined,
+  nitFix: string | undefined,
   afterRiskFix: boolean,
 ): Promise<void> => {
-  const notes = t.titledNotes(report)
-  await reviewing(base, carry, lap, t.walkthroughBlock(notes, report.nitFix))
+  await reviewing(base, carry, lap, t.nitFixBlock(nitFix))
   const written = read(REVIEW)
   // A review the reviewer did not write is the round's own refusal or rest.
   if (written === undefined) return
-  const review = t.unranked(written)
-  // Against the file as written, so a refusal's line numbers match it.
   requirePointers(
     written,
-    notes,
     changesSince(base).some((c) => isCode(c.path)),
   )
-  // Its risks are fixed and the review written again, so the re-reviewer edits this draft, never gtd's layout.
+  // Its risks are fixed and the review written again, so the re-reviewer edits this draft, never gtd's additions.
   if (!afterRiskFix && reviewRisks(written).length > 0) return
-  const full = sectionedReview(
-    await ranked(review, t.withWalkthrough(review, report), new Set(notes.map((n) => n.title))),
-    new Set(reviewChunks(review).map((c) => c.title)),
-  )
+  const full = t.withSummary(written, summary)
   if (full !== written) {
     await run("review.carrying", writeScript(REVIEW, full), {
-      label: "Ordering the review and adding the quality lap's findings",
+      label: "Adding the quality lap's summary",
       file: REVIEW,
       base,
     })
@@ -410,12 +253,10 @@ const walkthrough = async (
 }
 
 /**
- * The quality lap's notes reach a human over everything since `base`, who
- * answers each one — fix as suggested, won't fix, or their own answer — and
- * may comment. A fix joins the nit batch, a won't-fix is dropped, and an own
- * answer or comment is judged: edits end the review as `feedback` for the
- * caller to build, questions are answered in place, nits fixed in one batch,
- * praise dropped.
+ * A reviewer's walkthrough of everything since `base` reaches a human, who
+ * may comment: each note is judged — edits end the review as `feedback` for
+ * the caller to build, questions are answered in place, nits fixed in one
+ * batch, praise dropped.
  */
 export const humanReview = (
   base: string,
@@ -432,8 +273,6 @@ export const humanReview = (
   const severities = new Map<string, Severity>()
   // Set by a nit fix, so the fresh review that follows names its commit.
   let nitFix: string | undefined
-  // Every note the human answered in this review, left out of a fresh one.
-  const answered = new Set<string>()
   // Set by a risk fix, so the review written next reaches the human whatever it marks.
   let riskFixed = false
   return kit.review(base, {
@@ -444,20 +283,17 @@ export const humanReview = (
       const fixedAt = nitFix
       const afterRiskFix = riskFixed
       riskFixed = false
-      const report = options.report ?? NO_FINDINGS
-      return options.walkthrough === true
-        ? guarded(
-            () =>
-              walkthrough(
-                b,
-                composedOf(b, report, fixedAt, answered),
-                options.lap ?? "first",
-                carry,
-                afterRiskFix,
-              ),
-            guard,
-          )()
-        : composing(b, report, carry, fixedAt, answered)
+      const summary: t.ReviewSummary = {
+        report: options.report ?? NO_FINDINGS,
+        standards: {
+          added: standardsAddedSince(b),
+          undecided: parseStandards(read(STANDARDS) ?? "").undecided,
+        },
+      }
+      return guarded(
+        () => walkthrough(b, summary, options.lap ?? "first", carry, fixedAt, afterRiskFix),
+        guard,
+      )()
     },
     fixRisks: guarded((notes) => {
       riskFixed = true
@@ -472,7 +308,6 @@ export const humanReview = (
     reviewMissing,
     collecting: feedback.collecting,
     triage: triage(severities),
-    decided: (decisions) => decisions.forEach((d) => answered.add(d.anchor)),
     settles: settlesStandard,
     learn: learnStandards,
     pending: standardsPending,
@@ -526,11 +361,9 @@ export interface BuildTailOptions extends TailOptions {
   readonly feedback?: FeedbackTarget | undefined
   /** Write access for the nit and risk fix turns; absent: the bundled `access` export decides. */
   readonly fixAccess?: ScopeAccess | undefined
-  /** Which round a `walkthrough` reviewer writes; absent: `first`. */
+  /** Which round the reviewer writes; absent: `first`. */
   readonly lap?: t.ReviewRange | undefined
-  /** A reviewer turn writes the review as a walkthrough of the code, the lap's notes among its chunks; absent: gtd composes it from the notes alone. */
-  readonly walkthrough?: boolean | undefined
-  /** What the triaged quality lap left for the review; absent: nothing. */
+  /** What the quality lap and its finding gate did, for the review's summary; absent: nothing. */
   readonly report?: LensReport | undefined
 }
 

package/src/workflows/shared/skills.test.ts

@@ -39,6 +39,7 @@ describe("the bundled workflow's skills export", () => {
         "build.quality.test-audit",
         "build.quality.conventions",
         "build.quality.spec-challenge",
+        "build.quality.criteria-coverage",
         "refactor.build",
         "refactor.build.health",
         "refactor.build.fix.quality",
@@ -98,10 +99,11 @@ describe("the bundled workflow's skills export", () => {
     expect(Object.keys(none).filter((k) => k.startsWith("refactor.build.quality."))).toEqual([])
   })
 
-  it("loads one lens skill per quality lens: correctness its review skill, conventions and spec-challenge none, any other itself", () => {
+  it("loads one lens skill per quality lens: correctness its review skill, conventions, spec-challenge and criteria-coverage none, any other itself", () => {
     expect(bundled["build.quality.correctness"]).toEqual(["code-review-and-quality"])
     expect(bundled["build.quality.conventions"]).toEqual([])
     expect(bundled["build.quality.spec-challenge"]).toEqual([])
+    expect(bundled["build.quality.criteria-coverage"]).toEqual([])
     expect(bundled["build.quality.owasp-security"]).toEqual(["owasp-security"])
   })
 

package/src/workflows/shared/steps.test.ts

@@ -57,12 +57,15 @@ describe("the bundled workflow's steps declare skills — a bundled step's rende
       expect(body).toContain(point)
   })
 
-  it.each(["conventions", "spec-challenge"])("%s carries its brief", async (lens) => {
-    const request = await capture(() => steps.reviewQuality(lens), "build")
-    expect(JSON.stringify(request)).toContain(
-      steps.builtInLenses[lens]!.brief.split("\n")[0]!.slice(0, 40),
-    )
-  })
+  it.each(["conventions", "spec-challenge", "criteria-coverage"])(
+    "%s carries its brief",
+    async (lens) => {
+      const request = await capture(() => steps.reviewQuality(lens), "build")
+      expect(JSON.stringify(request)).toContain(
+        steps.builtInLenses[lens]!.brief.split("\n")[0]!.slice(0, 40),
+      )
+    },
+  )
 
   it("an unknown lens has no brief", async () => {
     const request = await capture(() => steps.reviewQuality("my-lens"), "build")

package/src/workflows/shared/steps.ts

@@ -66,15 +66,24 @@ export const builtInLenses: Readonly<Record<string, BuiltInLens>> = {
   correctness: { skills: ["code-review-and-quality"], brief: t.correctnessBrief },
   conventions: { skills: [], brief: t.conventionsBrief },
   "spec-challenge": { skills: [], brief: t.specChallengeBrief },
+  "criteria-coverage": { skills: [], brief: t.criteriaCoverageBrief },
 }
 
 const coderLenses: ReadonlySet<string> = new Set(["conventions", "ponytail-review", "test-audit"])
 
-/** One quality review through `lens`; each lens is its own scope, so its own conversation and skills. */
-export const reviewQuality = (lens: string, base?: string, model?: string): Promise<void> =>
+/**
+ * One quality review through `lens`; each lens is its own scope, so its own
+ * conversation and skills. `requirements`, when given, are quoted in the prompt.
+ */
+export const reviewQuality = (
+  lens: string,
+  base?: string,
+  model?: string,
+  requirements?: string,
+): Promise<void> =>
   t.agentWithSkills(
     `quality.${lens}.reviewing`,
-    t.buildQualityReviewingPrompt(lens, builtInLenses[lens]?.brief, base),
+    t.buildQualityReviewingPrompt(lens, builtInLenses[lens]?.brief, base, requirements),
     {
       label: "Reviewing (one quality lens)",
       file: QUALITY,

package/src/workflows/shared/tail.test.ts

@@ -211,13 +211,17 @@ const prompts: string[] = []
 const models: (string | undefined)[] = []
 
 describe("the quality lap's lenses", () => {
-  const lap = async (run: () => Promise<unknown>, vars: Record<string, string> = {}) => {
+  const lap = async (
+    run: () => Promise<unknown>,
+    vars: Record<string, string> = {},
+    files: Record<string, string> = {},
+  ) => {
     const log: string[] = []
     prompts.length = 0
     models.length = 0
     installContext(
       fixtureContext(
-        { vars },
+        { vars, read: (path) => files[path] },
         {
           step: (request: StepRequest) => {
             if (request.kind !== "restart") log.push(request.name)
@@ -309,6 +313,20 @@ describe("the quality lap's lenses", () => {
     expect(models).toEqual(["smart", "opus"])
   })
 
+  it("criteria-coverage runs only with requirements, passed or in .gtd/REQUIREMENTS.md, and quotes them", async () => {
+    const lenses = ["criteria-coverage", "conventions"]
+    expect(await lap(() => qualityLap(undefined, lenses))).toEqual([
+      "quality.conventions.reviewing",
+    ])
+    await lap(() => qualityLap(undefined, lenses), {}, { ".gtd/REQUIREMENTS.md": "- AC-1: file" })
+    expect(prompts[0]).toContain("  > - AC-1: file")
+    expect(prompts[1]).not.toContain("AC-1")
+    await lap(() =>
+      tail(() => Promise.resolve(), { green: true, lenses, requirements: "- AC-1: passed" }),
+    )
+    expect(prompts[0]).toContain("  > - AC-1: passed")
+  })
+
   it("tail passes lenses to its lap and a guard after each lens turn", async () => {
     let guards = 0
     const log = await lap(() =>

package/src/workflows/shared/tail.ts

@@ -8,6 +8,7 @@ import {
   vars,
   writeScript,
 } from "../../flows/index.js"
+import { reviewRisks } from "../../steering/index.js"
 import * as kit from "../../workflow-kit/index.js"
 import { guarded, healthy, type EscalationCount, type Guard } from "./health.js"
 import {
@@ -15,6 +16,7 @@ import {
   fixCheck,
   fixRisks,
   QUALITY,
+  REQUIREMENTS,
   REVIEW,
   reviewing,
   reviewMissing,
@@ -35,24 +37,31 @@ export const qualityLap = (
   guard?: Guard,
   lenses?: readonly string[],
   base?: string,
-): Promise<"clean" | "findings"> => lensLap(guard, lenses, base, () => {})
+): Promise<"clean" | "findings"> => lensLap(guard, lenses, base, undefined, () => {})
+
+const COVERAGE = "criteria-coverage"
 
 // `seen` gets each lens and every finding in the file once its turn is done.
 const lensLap = (
   guard: Guard | undefined,
   lenses: readonly string[] | undefined,
   base: string | undefined,
+  given: string | undefined,
   seen: (lens: string, findings: readonly Finding[]) => void,
-): Promise<"clean" | "findings"> =>
-  kit.qualityLap(
-    lenses ?? kit.lensEntriesOf(vars.qualityReviews ?? ""),
+): Promise<"clean" | "findings"> => {
+  const requirements = given ?? read(REQUIREMENTS)
+  return kit.qualityLap(
+    (lenses ?? kit.lensEntriesOf(vars.qualityReviews ?? "")).filter(
+      (entry) => requirements !== undefined || kit.lensOf(entry).lens !== COVERAGE,
+    ),
     guarded(async (entry: string) => {
       const { lens, model } = kit.lensOf(entry)
-      await reviewQuality(lens, base, model)
+      await reviewQuality(lens, base, model, lens === COVERAGE ? requirements : undefined)
       seen(lens, findingsOf(read(QUALITY) ?? ""))
     }, guard),
     QUALITY,
   )
+}
 
 // What the fixer left is in the lap's report by now; the next lap must not append to it.
 const closeQuality = async (): Promise<void> => {
@@ -91,12 +100,17 @@ export interface TailOptions {
   readonly lensBase?: string | undefined
   /** Appended to every fix and describe prompt of the tail. */
   readonly rules?: string | undefined
+  /**
+   * The requirements the change was built to, for the `criteria-coverage`
+   * lens; absent: `.gtd/REQUIREMENTS.md`, and with neither the lens is skipped.
+   */
+  readonly requirements?: string | undefined
 }
 
 /**
  * The build tail: fix (when entered red), keep green, the quality lap — a
- * judge sorts its findings, the mechanical ones are fixed, noise dropped —
- * then `finish` with the rest as notes: a human review, or carrying them on.
+ * judge sorts its findings and the mechanical ones are fixed — then the
+ * finding gate over the rest, then `finish` with what became of them all.
  */
 export function tail<T>(
   finish: (escalations: EscalationCount, report: LensReport) => Promise<T>,
@@ -156,7 +170,7 @@ const tailForm = <T>(
 
 const runTail = <T>(finish: Finish<T>, options: TailOptions): Promise<T> =>
   scope("build", async () => {
-    const { guard, lenses, lensBase, rules } = options
+    const { guard, lenses, lensBase, rules, requirements } = options
     // Only undefined defaults: a null reaches every escalation as falsy, as it reaches review's.
     const guardRests = options.guardRests === undefined ? true : options.guardRests
     const escalations: EscalationCount = { rounds: 0 }
@@ -170,7 +184,7 @@ const runTail = <T>(finish: Finish<T>, options: TailOptions): Promise<T> =>
     // The lap runs once a tail: after its findings are fixed, `finish` follows.
     // Lenses append, so a title the file did not hold before a lens's turn is that lens's.
     const byTitle: { title: string; lens: string }[] = []
-    const lap = await lensLap(guard, lenses, lensBase, (lens, findings) => {
+    const lap = await lensLap(guard, lenses, lensBase, requirements, (lens, findings) => {
       const before = byTitle.map((f) => f.title)
       for (const { title } of findings) {
         const at = before.indexOf(title)
@@ -201,22 +215,29 @@ export const handOffReview = (
   escalations: EscalationCount,
   guard?: Guard,
   report: LensReport = NO_FINDINGS,
-): Promise<void> =>
-  kit.reviewToHandOff(base, {
+): Promise<void> => {
+  // Set by a risk fix, so the re-review written next is summarised whatever it marks.
+  let riskFixed = false
+  return kit.reviewToHandOff(base, {
     file: REVIEW,
     reviewing: guarded(async (b, carry) => {
+      const afterRiskFix = riskFixed
+      riskFixed = false
       await reviewing(b, carry)
-      // gtd adds the lap's chunks itself: .gtd/QUALITY.md is gone, so a reviewer leaving one out would lose it.
       const review = read(REVIEW)
-      if (review === undefined) return
-      const full = t.withLapFindings(review, report)
+      // A risk-marked draft is fixed and written again first: the re-reviewer edits it, never gtd's summary.
+      if (review === undefined || (!afterRiskFix && reviewRisks(review).length > 0)) return
+      const full = t.withSummary(review, { report })
       if (full !== review) {
         await run("review.carrying", writeScript(REVIEW, full), {
-          label: "Adding the quality lap's findings",
+          label: "Adding the quality lap's summary",
         })
       }
     }, guard),
-    fixRisks: guarded(fixRisks, guard),
+    fixRisks: guarded((risks) => {
+      riskFixed = true
+      return fixRisks(risks)
+    }, guard),
     keepGreen: () => healthy(fixCheck, { escalations, guard }),
     awaitReview: (b) => awaitReview(b, t.handOffAwaitReviewMessage(b)),
     reviewMissing,
@@ -233,6 +254,7 @@ export const handOffReview = (
     deleted:
       "gtd land: review-doc: .gtd/REVIEW.md was deleted — restore it, or leave a note to hand to fix.",
   })
+}
 
 /** The tail the fix workflow runs: ends at the hand-off review since `base`, which gets what the lap left. */
 export const handOffTail = (fixFirst: boolean, base: string, guard?: Guard): Promise<void> =>