@pmelab/gtd 15.10.0 → 16.0.0

package/schema.json

@@ -63,6 +63,16 @@
       "additionalProperties": false,
       "description": "Settings for `gtd ui`: where it listens, and optional TLS."
     },
+    "skills": {
+      "type": "object",
+      "description": "Flat step full-name -> skill-name array map. Each entry REPLACES the named step's bundled skill list wholesale (never merges into it); [] means no skills at all for that step, and no preamble. A key naming a step the workflow in play does not declare is a load error listing the known names — the schema itself cannot validate a key, only a value's shape.",
+      "additionalProperties": {
+        "type": "array",
+        "items": {
+          "type": "string"
+        }
+      }
+    },
     "$schema": {
       "type": "string",
       "description": "Editor-only pointer at this schema. Stripped by gtd before validation."

package/src/flows/runtime.ts

@@ -138,6 +138,15 @@ export interface FlowContext {
   readonly vars: Readonly<Record<string, string>>
   readonly head: () => string
   readonly start: () => string
+  /**
+   * The skill list `localName` (scoped from here, same as `agent()`) resolves
+   * to — for a prompt preamble. `ownSkills`, when given, is the same
+   * precedence tier as a call's own `skills` option: it stands in for the
+   * bundled default when there isn't one, but a `.gtdrc` entry still beats
+   * it. Shares its resolution with `agent()`'s own wire resolver (both read
+   * `Workflow.ts`'s `configuredSkills`/`skills`), so the two can never drift.
+   */
+  readonly skillsFor: (localName: string, ownSkills?: readonly string[]) => readonly string[]
 }
 
 const CONTEXT_KEY = Symbol.for("@pmelab/gtd/flow-context")
@@ -243,6 +252,10 @@ export const head = (): string => ctx().head()
 /** The process's diff base: the commit before it began, or the base `gtd --entry` fixed. */
 export const start = (): string => ctx().start()
 
+/** The skill list `localName` (scoped from here, same as `agent()`) resolves to — for a prompt preamble. See `FlowContext.skillsFor` for `ownSkills`. */
+export const skillsFor = (localName: string, ownSkills?: readonly string[]): readonly string[] =>
+  ctx().skillsFor(localName, ownSkills)
+
 /** The merged workflow variables. */
 export const vars: Readonly<Record<string, string>> = new Proxy(
   {},

package/src/workflows/review.ts

@@ -35,8 +35,12 @@ import {
 } from "./steps.js"
 import * as t from "./text.js"
 
-/** The skills the quality lap reviews with, one turn each: the `qualityReviews` var. */
-export const qualityLenses = (): readonly string[] => t.splitSkills(vars.qualityReviews)
+/** The lenses the quality lap reviews with, one turn each: the `qualityReviews` var, split on `,` and trimmed. Unlike a `skills:` entry, this fans out into one whole turn per entry rather than naming one step's skill list — see `build.quality.reviewing` in `./skills.ts` for the (separate) skills a lens turn itself loads. */
+export const qualityLenses = (): readonly string[] =>
+  (vars.qualityReviews ?? "")
+    .split(",")
+    .map((lens) => lens.trim())
+    .filter((lens) => lens.length > 0)
 
 /**
  * One review turn per lens over the whole change, each appending what it

package/src/workflows/skills.test.ts

@@ -0,0 +1,93 @@
+import { describe, expect, it } from "vitest"
+import { skills } from "./skills.js"
+
+// Pins every bundled step's own declared list, keyed by its full name. This
+// file alone only catches a LOCAL-name rename (the list literally changes);
+// it cannot catch a SCOPE rename (e.g. `scope("architecture")` renamed to
+// `scope("design.architecture")`), because it never runs the real flow — it
+// compares the map against itself. Every one of the sixteen keys has its
+// own e2e grounding closing that gap instead — each runs the actual scoped
+// name through replay, so a scope rename desyncs a preamble assertion there,
+// not just silently drops a step's skills (see AGENTS.md's "workflow is
+// code" rule: a step's full name is public API):
+//   - design.triage, architecture.author, architecture.decompose,
+//     packages.item.building — default-workflow.feature's main scenario
+//   - packages.item.spec.review, packages.item.fix-spec — the same
+//     scenario, continued
+//   - packages.item.fix-suite, packages.item.health.describe — the
+//     "escalation loop ... under packages.item" scenario
+//   - build.fix — state-skills.feature
+//   - build.health.describe — the "repeated check failures escalate"
+//     scenario
+//   - build.quality.reviewing — per-step-skills.feature
+//   - build.fix-quality — quality-review-lap.feature
+//   - build.review.reviewing, build.review.collecting —
+//     default-workflow.feature's review-loop scenarios
+//   - build.review.answer-review-questions, build.review.fix-nits — NOT yet
+//     e2e-grounded; only steps.test.ts's preamble checks, which use local names
+describe("the bundled workflow's skills map", () => {
+  it("declares exactly the sixteen bundled agent steps, by full name", () => {
+    expect(Object.keys(skills).sort()).toEqual(
+      [
+        "design.triage",
+        "architecture.author",
+        "architecture.decompose",
+        "packages.item.building",
+        "packages.item.fix-suite",
+        "packages.item.fix-spec",
+        "packages.item.spec.review",
+        "packages.item.health.describe",
+        "build.fix",
+        "build.health.describe",
+        "build.quality.reviewing",
+        "build.fix-quality",
+        "build.review.reviewing",
+        "build.review.answer-review-questions",
+        "build.review.fix-nits",
+        "build.review.collecting",
+      ].sort(),
+    )
+  })
+
+  it("packages.item.health.describe and build.health.describe are both present, with the same list — the shared escalation loop resolves under both scopes", () => {
+    expect(skills["packages.item.health.describe"]).toEqual(skills["build.health.describe"])
+    expect(skills["packages.item.health.describe"]).toEqual(["debugging-and-error-recovery"])
+  })
+
+  it("pins each step's own declared list", () => {
+    expect(skills["design.triage"]).toEqual([
+      "spec-driven-development",
+      "planning-and-task-breakdown",
+    ])
+    expect(skills["architecture.author"]).toEqual([
+      "api-and-interface-design",
+      "documentation-and-adrs",
+      "ponytail",
+    ])
+    expect(skills["architecture.decompose"]).toEqual([
+      "incremental-implementation",
+      "planning-and-task-breakdown",
+    ])
+    expect(skills["packages.item.building"]).toEqual([
+      "test-driven-development",
+      "incremental-implementation",
+    ])
+    expect(skills["packages.item.fix-suite"]).toEqual(["debugging-and-error-recovery"])
+    expect(skills["build.fix"]).toEqual(["debugging-and-error-recovery"])
+    expect(skills["packages.item.fix-spec"]).toEqual([
+      "incremental-implementation",
+      "code-simplification",
+    ])
+    expect(skills["build.fix-quality"]).toEqual([
+      "incremental-implementation",
+      "code-simplification",
+    ])
+    expect(skills["packages.item.spec.review"]).toEqual([
+      "code-review-and-quality",
+      "spec-driven-development",
+    ])
+    expect(skills["build.review.reviewing"]).toEqual(["code-review-and-quality"])
+    expect(skills["build.review.collecting"]).toEqual(["code-review-and-quality"])
+    expect(skills["build.quality.reviewing"]).toEqual([])
+  })
+})

package/src/workflows/skills.ts

@@ -0,0 +1,37 @@
+// The bundled workflow's default skills, one list per agent step, keyed by
+// the step's FULL name (its scope prefixes included) — the same name a
+// `.gtdrc` `skills:` entry addresses. A step's name is not derivable from
+// flow code alone (loops, branches, shared calls), so this map is the only
+// place every addressable name is declared up front; `steps.test.ts` pins
+// each step's declared list against a renamed map key.
+//
+// `packages.item.health.describe` and `build.health.describe` are not a
+// duplicate: the escalation loop (`healthy()`, in `./health.ts`) is shared
+// code reached from both `scope("packages") -> scope("item")` and
+// `scope("build")`, so the one `health.describe` step name resolves to two
+// different full names depending on which caller is looping.
+export const skills: Readonly<Record<string, readonly string[]>> = {
+  "design.triage": ["spec-driven-development", "planning-and-task-breakdown"],
+  "architecture.author": ["api-and-interface-design", "documentation-and-adrs", "ponytail"],
+  "architecture.decompose": ["incremental-implementation", "planning-and-task-breakdown"],
+  "packages.item.building": ["test-driven-development", "incremental-implementation"],
+  "packages.item.fix-suite": ["debugging-and-error-recovery"],
+  "packages.item.fix-spec": ["incremental-implementation", "code-simplification"],
+  "packages.item.spec.review": ["code-review-and-quality", "spec-driven-development"],
+  "packages.item.health.describe": ["debugging-and-error-recovery"],
+  "build.fix": ["debugging-and-error-recovery"],
+  "build.health.describe": ["debugging-and-error-recovery"],
+  // No bundled default: unlike every other entry, the lens named in the
+  // prompt BODY already varies per turn (see `reviewQuality` in
+  // `./steps.ts`), which is what the preamble falls back to naming instead —
+  // a fixed bundled list here would repeat one entry on every turn. A
+  // `.gtdrc` `skills:` entry still overrides that per-turn fallback, on the
+  // wire and in the preamble alike (`resolveSkills` in `../replay/Replay.ts`
+  // is what both share).
+  "build.quality.reviewing": [],
+  "build.fix-quality": ["incremental-implementation", "code-simplification"],
+  "build.review.reviewing": ["code-review-and-quality"],
+  "build.review.answer-review-questions": ["code-review-and-quality"],
+  "build.review.fix-nits": ["incremental-implementation", "code-simplification"],
+  "build.review.collecting": ["code-review-and-quality"],
+}

package/src/workflows/steps.test.ts

@@ -5,107 +5,114 @@ import * as steps from "./steps.js"
 
 const capture = (
   fn: () => Promise<void>,
-  vars: Readonly<Record<string, string>> = {},
-): Promise<StepRequest> => captureStep(fn, { vars })
+  skills?: Readonly<Record<string, readonly string[]>>,
+): Promise<StepRequest> => captureStep(fn, skills !== undefined ? { skills } : {})
 
-const agentSkills = (request: StepRequest): readonly string[] | undefined => {
+const agentPrompt = (request: StepRequest): string => {
+  if (request.kind !== "agent") throw new Error(`expected an agent step, got ${request.kind}`)
+  return request.prompt
+}
+
+// The preamble (`agentPrompt`) reflects `skillsFor`'s resolved map — but the
+// WIRE `skills` field a request actually carries is whatever `options.skills`
+// the step itself passed; `Replay.ts`'s `resolve()` only overrides it from
+// `.gtdrc` (never reachable here — this fixture skips replay entirely). Most
+// bundled steps pass no `skills` option of their own, so this is normally
+// `undefined`; `reviewQuality` is the one step that does.
+const agentSkillsOption = (request: StepRequest): readonly string[] | undefined => {
   if (request.kind !== "agent") throw new Error(`expected an agent step, got ${request.kind}`)
   return request.options.skills
 }
 
-describe("the bundled workflow's steps declare skills", () => {
-  it("triage declares triageSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.triage("base")))).toEqual([
-      "spec-driven-development",
-      "planning-and-task-breakdown",
-    ])
+describe("the bundled workflow's steps declare skills — a bundled step's rendered prompt carries its bundled skills.ts preamble", () => {
+  it("triage carries design.triage's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.triage("base")))
+    expect(prompt).toContain("spec-driven-development, planning-and-task-breakdown")
+  })
+
+  it("author carries architecture.author's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.author()))
+    expect(prompt).toContain("api-and-interface-design, documentation-and-adrs, ponytail")
+  })
+
+  it("decompose carries architecture.decompose's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.decompose()))
+    expect(prompt).toContain("incremental-implementation, planning-and-task-breakdown")
   })
 
-  it("author declares architectureSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.author()))).toEqual([
-      "api-and-interface-design",
-      "documentation-and-adrs",
-      "ponytail",
-    ])
+  it("build carries packages.item.building's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.build("pkg")))
+    expect(prompt).toContain("test-driven-development, incremental-implementation")
   })
 
-  it("decompose declares decomposeSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.decompose()))).toEqual([
-      "incremental-implementation",
-      "planning-and-task-breakdown",
-    ])
+  it("fixSuite carries packages.item.fix-suite's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fixSuite()))
+    expect(prompt).toContain("debugging-and-error-recovery")
   })
 
-  it("build declares buildSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.build("pkg")))).toEqual([
-      "test-driven-development",
-      "incremental-implementation",
-    ])
+  it("fixSpec carries packages.item.fix-spec's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fixSpec("pkg")))
+    expect(prompt).toContain("incremental-implementation, code-simplification")
   })
 
-  it("fixSuite declares fixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fixSuite()))).toEqual([
-      "debugging-and-error-recovery",
-    ])
+  it("reviewPackage carries packages.item.spec.review's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.reviewPackage("pkg")))
+    expect(prompt).toContain("code-review-and-quality, spec-driven-development")
   })
 
-  it("fixSpec declares reviewFixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fixSpec("pkg")))).toEqual([
-      "incremental-implementation",
-      "code-simplification",
-    ])
+  it("fix carries build.fix's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fix()))
+    expect(prompt).toContain("debugging-and-error-recovery")
   })
 
-  it("reviewPackage declares specReviewSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.reviewPackage("pkg")))).toEqual([
-      "code-review-and-quality",
-      "spec-driven-development",
-    ])
+  it("describeEscalation carries health.describe's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.describeEscalation()))
+    expect(prompt).toContain("debugging-and-error-recovery")
   })
 
-  it("fix declares fixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fix()))).toEqual(["debugging-and-error-recovery"])
+  it("reviewQuality's preamble falls back to the lens itself by default — build.quality.reviewing bundles no fixed skills of its own", async () => {
+    const prompt = agentPrompt(await capture(() => steps.reviewQuality("owasp-security")))
+    expect(prompt).toContain("missing one: owasp-security")
   })
 
-  it("describeEscalation declares escalateSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.describeEscalation()))).toEqual([
-      "debugging-and-error-recovery",
-    ])
+  it("reviewQuality's own wire skills option IS the lens by default — the same list its preamble now names, never one without the other", async () => {
+    const request = await capture(() => steps.reviewQuality("owasp-security"))
+    expect(agentSkillsOption(request)).toEqual(["owasp-security"])
   })
 
-  it("reviewQuality declares exactly the one lens handed to it, not split further", async () => {
-    expect(agentSkills(await capture(() => steps.reviewQuality("owasp-security")))).toEqual([
-      "owasp-security",
-    ])
+  it("reviewQuality's preamble reflects a configured build.quality.reviewing entry, every turn, regardless of lens", async () => {
+    const prompt = agentPrompt(
+      await capture(() => steps.reviewQuality("owasp-security"), {
+        "quality.reviewing": ["my-org-checklist"],
+      }),
+    )
+    expect(prompt).toContain("my-org-checklist")
+    // The body still names the lens — what makes N otherwise identical prompts distinguishable.
+    expect(prompt).toContain("owasp-security")
   })
 
-  it("fixQuality declares reviewFixSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.fixQuality()))).toEqual([
-      "incremental-implementation",
-      "code-simplification",
-    ])
+  it("fixQuality carries build.fix-quality's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.fixQuality()))
+    expect(prompt).toContain("incremental-implementation, code-simplification")
   })
 
-  it("reviewing declares reviewSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.reviewing("base")))).toEqual([
-      "code-review-and-quality",
-    ])
+  it("reviewing carries build.review.reviewing's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.reviewing("base")))
+    expect(prompt).toContain("code-review-and-quality")
   })
 
-  it("collecting declares reviewSkills, split", async () => {
-    expect(agentSkills(await capture(() => steps.collecting("capture")))).toEqual([
-      "code-review-and-quality",
-    ])
+  it("collecting carries build.review.collecting's bundled skills", async () => {
+    const prompt = agentPrompt(await capture(() => steps.collecting("capture")))
+    expect(prompt).toContain("code-review-and-quality")
   })
 
-  it("a blanked *Skills var leaves that step's skills empty, and its rendered prompt bare", async () => {
-    const request = await capture(() => steps.fix(), { fixSkills: "" })
+  it("an empty configured list leaves that step's skills empty, and its rendered prompt bare", async () => {
+    const request = await capture(() => steps.fix(), { fix: [] })
     if (request.kind !== "agent") throw new Error("unreachable")
-    expect(request.options.skills).toEqual([])
     expect(request.prompt).not.toContain("Load whatever's listed here")
   })
 
-  it("answerReviewQuestions answers inline in .gtd/REVIEW.md as the reviewer, with reviewSkills", async () => {
+  it("answerReviewQuestions answers inline in .gtd/REVIEW.md as the reviewer, with its bundled skills", async () => {
     const request = await capture(() =>
       steps.answerReviewQuestions([{ id: "note-1", anchor: "calc ./a.ts#1-1", text: "why?" }]),
     )
@@ -114,8 +121,8 @@ describe("the bundled workflow's steps declare skills", () => {
     expect(request.options).toMatchObject({
       file: ".gtd/REVIEW.md",
       mode: "review",
-      skills: ["code-review-and-quality"],
     })
+    expect(request.prompt).toContain("code-review-and-quality")
     expect(request.prompt).toContain("note-1 — calc ./a.ts#1-1")
     expect(request.prompt).toContain("`A: ` line")
     expect(request.prompt).toContain("gtd check review .gtd/REVIEW.md")
@@ -130,7 +137,7 @@ describe("the bundled workflow's steps declare skills", () => {
     )
     if (request.kind !== "agent") throw new Error("unreachable")
     expect(request.name).toBe("review.fix-nits")
-    expect(request.options.skills).toEqual(["incremental-implementation", "code-simplification"])
+    expect(request.prompt).toContain("incremental-implementation, code-simplification")
     expect(request.prompt).toContain("typo")
     expect(request.prompt).toContain("semicolon")
     expect(request.prompt).toContain("Leave `.gtd/REVIEW.md` untouched")

package/src/workflows/steps.ts

@@ -21,7 +21,7 @@ const coder = (): string => vars.coderModel ?? ""
 
 /** Turn the sketch since `base` into `.gtd/REQUIREMENTS.md`. */
 export const triage = (base: string): Promise<void> =>
-  t.agentWithSkills("triage", vars.triageSkills, t.designTriagePrompt(base), {
+  t.agentWithSkills("triage", t.designTriagePrompt(base), {
     label: "Triaging the change",
     file: REQUIREMENTS,
     mode: "qa",
@@ -30,7 +30,7 @@ export const triage = (base: string): Promise<void> =>
   })
 
 export const author = (): Promise<void> =>
-  t.agentWithSkills("author", vars.architectureSkills, t.architectureAuthorPrompt(), {
+  t.agentWithSkills("author", t.architectureAuthorPrompt(), {
     label: "Refining the technical plan",
     file: ARCHITECTURE,
     mode: "qa",
@@ -39,7 +39,7 @@ export const author = (): Promise<void> =>
   })
 
 export const decompose = (): Promise<void> =>
-  t.agentWithSkills("decompose", vars.decomposeSkills, t.architectureDecomposePrompt(), {
+  t.agentWithSkills("decompose", t.architectureDecomposePrompt(), {
     label: "Decomposing into packages",
     model: planner(),
     system: t.architectSystem(),
@@ -66,14 +66,14 @@ export const answerTechnicalQuestions = (): Promise<void> =>
 // ── Packages ────────────────────────────────────────────────────────────────
 
 export const build = (pkg: string): Promise<void> =>
-  t.agentWithSkills("building", vars.buildSkills, t.packagesItemBuildingPrompt(pkg), {
+  t.agentWithSkills("building", t.packagesItemBuildingPrompt(pkg), {
     label: "Building",
     model: coder(),
     system: t.builderSystem(),
   })
 
 export const fixSuite = (): Promise<void> =>
-  t.agentWithSkills("fix-suite", vars.fixSkills, t.packagesItemFixSuitePrompt(), {
+  t.agentWithSkills("fix-suite", t.packagesItemFixSuitePrompt(), {
     label: "Fixing the check",
     file: FEEDBACK,
     model: coder(),
@@ -81,7 +81,7 @@ export const fixSuite = (): Promise<void> =>
   })
 
 export const fixSpec = (pkg: string): Promise<void> =>
-  t.agentWithSkills("fix-spec", vars.reviewFixSkills, t.packagesItemFixSpecPrompt(pkg), {
+  t.agentWithSkills("fix-spec", t.packagesItemFixSpecPrompt(pkg), {
     label: "Fixing review feedback",
     file: SPEC_FEEDBACK,
     model: coder(),
@@ -90,22 +90,17 @@ export const fixSpec = (pkg: string): Promise<void> =>
 
 /** Review `pkg` against its spec, focused on the `failing` sections the pre-judge could not clear. */
 export const reviewPackage = (pkg: string, failing: readonly string[] = []): Promise<void> =>
-  t.agentWithSkills(
-    "spec.review",
-    vars.specReviewSkills,
-    t.packagesItemSpecReviewPrompt(pkg, failing),
-    {
-      label: "Reviewing the package",
-      model: planner(),
-      system: t.specReviewerSystem(),
-      allowEmpty: true,
-    },
-  )
+  t.agentWithSkills("spec.review", t.packagesItemSpecReviewPrompt(pkg, failing), {
+    label: "Reviewing the package",
+    model: planner(),
+    system: t.specReviewerSystem(),
+    allowEmpty: true,
+  })
 
 // ── Keeping the suite green ─────────────────────────────────────────────────
 
 export const fix = (): Promise<void> =>
-  t.agentWithSkills("fix", vars.fixSkills, t.buildFixPrompt(), {
+  t.agentWithSkills("fix", t.buildFixPrompt(), {
     label: "Fixing the check",
     file: FEEDBACK,
     model: coder(),
@@ -113,7 +108,7 @@ export const fix = (): Promise<void> =>
   })
 
 export const describeEscalation = (): Promise<void> =>
-  t.agentWithSkills("health.describe", vars.escalateSkills, t.healthDescribePrompt(), {
+  t.agentWithSkills("health.describe", t.healthDescribePrompt(), {
     label: "Describing the escalation",
     file: FEEDBACK,
     model: coder(),
@@ -139,18 +134,24 @@ export const escalationExhausted = (): Promise<void> =>
 
 // ── Quality and review ──────────────────────────────────────────────────────
 
-/** One quality review, through the skill `lens`. */
+/**
+ * One quality review, through the skill `lens`. `lens` rides as this turn's
+ * own `skills` option — a `.gtdrc` `build.quality.reviewing` entry still
+ * overrides it (config beats a flow-supplied list same as any other step),
+ * but absent one the lens itself is what the turn loads by default.
+ */
 export const reviewQuality = (lens: string): Promise<void> =>
-  t.agentWithSkills("quality.reviewing", lens, t.buildQualityReviewingPrompt(lens), {
+  t.agentWithSkills("quality.reviewing", t.buildQualityReviewingPrompt(lens), {
     label: "Reviewing (one quality lens)",
     file: QUALITY,
     model: planner(),
     system: t.reviewerSystem(),
     allowEmpty: true,
+    skills: [lens],
   })
 
 export const fixQuality = (): Promise<void> =>
-  t.agentWithSkills("fix-quality", vars.reviewFixSkills, t.buildFixQualityPrompt(), {
+  t.agentWithSkills("fix-quality", t.buildFixQualityPrompt(), {
     label: "Fixing quality findings",
     file: QUALITY,
     model: coder(),
@@ -160,41 +161,31 @@ export const fixQuality = (): Promise<void> =>
 
 /** Write `.gtd/REVIEW.md` over everything since `base`, carrying the answers of commit `carry` when given. */
 export const reviewing = (base: string, carry?: string): Promise<void> =>
-  t.agentWithSkills(
-    "review.reviewing",
-    vars.reviewSkills,
-    t.buildReviewReviewingPrompt(base, carry),
-    {
-      label: "Reviewing",
-      file: REVIEW,
-      mode: "review",
-      model: planner(),
-      system: t.reviewerSystem(),
-      base,
-    },
-  )
+  t.agentWithSkills("review.reviewing", t.buildReviewReviewingPrompt(base, carry), {
+    label: "Reviewing",
+    file: REVIEW,
+    mode: "review",
+    model: planner(),
+    system: t.reviewerSystem(),
+    base,
+  })
 
 /** Answer every `question` note inline in `.gtd/REVIEW.md`. */
 export const answerReviewQuestions = (notes: readonly t.NoteInput[]): Promise<void> =>
-  t.agentWithSkills(
-    "review.answer-review-questions",
-    vars.reviewSkills,
-    t.buildReviewAnswerQuestionsPrompt(notes),
-    {
-      label: "Answering your questions",
-      file: REVIEW,
-      mode: "review",
-      model: planner(),
-      system: t.reviewerSystem(),
-    },
-  )
+  t.agentWithSkills("review.answer-review-questions", t.buildReviewAnswerQuestionsPrompt(notes), {
+    label: "Answering your questions",
+    file: REVIEW,
+    mode: "review",
+    model: planner(),
+    system: t.reviewerSystem(),
+  })
 
 /**
  * Fix every `nit` note in one turn. Its name puts it in the `build.review`
  * conversation, which has one identity — so it runs as the reviewer, not the coder.
  */
 export const fixNits = (notes: readonly t.NoteInput[]): Promise<void> =>
-  t.agentWithSkills("review.fix-nits", vars.reviewFixSkills, t.buildReviewFixNitsPrompt(notes), {
+  t.agentWithSkills("review.fix-nits", t.buildReviewFixNitsPrompt(notes), {
     label: "Fixing your nits",
     file: REVIEW,
     model: planner(),
@@ -219,16 +210,11 @@ export const reviewMissing = (round: string): Promise<void> =>
 
 /** Turn the review round `capture` describes into `.gtd/REQUIREMENTS.md`, or change nothing. */
 export const collecting = (capture: string): Promise<void> =>
-  t.agentWithSkills(
-    "review.collecting",
-    vars.reviewSkills,
-    t.buildReviewCollectingPrompt(capture),
-    {
-      label: "Collecting your feedback",
-      file: REQUIREMENTS,
-      mode: "qa",
-      model: planner(),
-      system: t.reviewerSystem(),
-      allowEmpty: true,
-    },
-  )
+  t.agentWithSkills("review.collecting", t.buildReviewCollectingPrompt(capture), {
+    label: "Collecting your feedback",
+    file: REQUIREMENTS,
+    mode: "qa",
+    model: planner(),
+    system: t.reviewerSystem(),
+    allowEmpty: true,
+  })