@pmelab/gtd 56.0.0 → 57.0.0

package/src/workflows/feature/feature.ts

@@ -9,7 +9,7 @@ import {
   start,
 } from "../../flows/index.js"
 import { gate } from "../shared/health.js"
-import { flagModeOn, shipped } from "../shared/options.js"
+import { flagModeOn, naiveTestOn, shipped } from "../shared/options.js"
 import { FEEDBACK, REQUIREMENTS } from "../shared/steps.js"
 import { refusePendingHandOff } from "../shared/tail.js"
 import * as t from "../shared/text.js"
@@ -23,16 +23,15 @@ import {
 } from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
-import { prototypeRounds } from "./prototype.js"
 import { implement, implementing, seamBuild } from "./seam.js"
 import { recordRisk, riskTierOn } from "./tier.js"
 
 // The ordinary start. Any change to the tree starts a process: `idle` →
 // `unwind` reverts the sketch (its intent survives in history) → a
-// green-baseline gate → design → a naive pass, judged with `flagMode` on: it
+// green-baseline gate → design → a naive pass, tried by a person with
+// `naiveTest` on and judged with `flagMode` on: it
 // lands as the implementation, or (refactoring first when the judge asks) is
-// built fresh from → the health loop → a hands-on test of every criterion,
-// fixed and re-tested → the triaged quality lap and its finding gate → a
+// built fresh from → the health loop → the triaged quality lap and its finding gate → a
 // reviewer's walkthrough of the whole change for the human, which signs off
 // (the episode ends back at `idle`) or sends a design → implement lap.
 
@@ -141,7 +140,7 @@ export const ordinaryStart = async (): Promise<void> => {
   refusePendingHandOff()
   // Read right after idle, so a bad value refuses the landing that would pin it.
   flagModeOn()
-  prototypeRounds()
+  naiveTestOn()
   const stated = statedCriteria(changes(), head())
   await unwind()
   if (changes(FEEDBACK).some((c) => c.status !== "deleted")) {

package/src/workflows/feature/flag-mode.feature

@@ -11,7 +11,7 @@ Feature: flag mode off lands the naive pass with no release flag, seam judge or
       """
       import { feature } from "@pmelab/gtd/workflows/feature"
       export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
-      export default feature({ flagMode: false, prototypeRounds: "0" })
+      export default feature({ flagMode: false })
       """
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And a file "src/calc.ts" with:

package/src/workflows/feature/lens-models.feature

@@ -12,7 +12,6 @@ Feature: each quality lens runs on its own model hint
       export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
       export default feature({
         flagMode: false,
-        prototypeRounds: "0",
         qualityReviews: "correctness, conventions, test-audit=opus",
       })
       """

package/src/workflows/feature/lens-review.feature

@@ -11,7 +11,6 @@ Feature: the quality lap's findings are triaged, then decided at the finding gat
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And an environment variable "GTD_FLAGMODE" set to "false"
     And a file "src/calc.ts" with:

package/src/workflows/feature/naive-test.feature

@@ -0,0 +1,258 @@
+@inmem
+Feature: a person tries the naive pass by hand before anything builds on it
+
+  `naiveTest` is a factory option of the shipped workflows, off by default. On,
+  every green naive pass is applied to the working tree and the process rests
+  at `seam.try`. A clean landing signs it off and the process goes on — to the
+  seam judge, or straight to the implementation with `flagMode` off. Notes in
+  `.gtd/NAIVE-TEST.md`, a code edit or a requirements edit send it back: the
+  pass and the person's code edits leave the tree again, and the next naive
+  pass gets the notes and the edits. Every lap ends at the gate again.
+
+  Rule: with flagMode off
+
+    Background:
+      Given a gtd config with:
+        """
+        import { feature } from "@pmelab/gtd/workflows/feature"
+        export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
+        export default feature({ flagMode: false, naiveTest: true })
+        """
+      And an environment variable "GTD_QUALITYREVIEWS" set to ""
+      And a file "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        """
+      And the working tree is committed as "feat: add calculator"
+      And a file "TODO.md" with:
+        """
+        # Add subtract
+
+        subtract(a, b) returns the difference.
+        """
+      And step "unwind" changes nothing
+      And step "start-gate.check" changes nothing
+      And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+        """
+        # Requirements
+
+        ## Impact
+
+        - the calculator module
+
+        ## Acceptance Criteria
+
+        - AC-1: subtract(a, b) returns a - b.
+        """
+      And step "design.gate.answer" changes nothing
+      And step "seam.naive" writes "src/calc.test.ts" with:
+        """
+        it("[AC-1] subtracts", () => {})
+        """
+      And step "seam.naive" writes "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        export const subtract = (a: number, b: number) => a + b
+        """
+      And step "seam.check" changes nothing
+      And step "seam.applying" runs its script
+      And step "seam.restoring" runs its script
+
+    Scenario: a green naive pass rests at seam.try, applied to the working tree
+      When the process is driven
+      Then the process rests at "seam.try"
+      And the resting step's content contains "try it by hand"
+      And the resting step's content contains "`.gtd/NAIVE-TEST.md`"
+      And "src/calc.ts" contains "export const subtract"
+      And the commit subjects end with:
+        """
+        gtd(agent): seam.naive → seam.check
+        gtd(check): seam.check → seam.applying
+        gtd(check): seam.applying → seam.try
+        """
+
+    Scenario: a clean landing signs the pass off, takes it out and lands it as the implementation
+      When the process is driven
+      Then the process rests at "seam.try"
+      When gtd lands
+      And step "implement.applying" runs its script
+      And step "implement.health.check" changes nothing
+      And step "implement.closing" runs its script
+      And the process is driven
+      Then the process rests at "build.review.reviewing"
+      And "src/calc.ts" contains "export const subtract"
+      And the commit subjects end with:
+        """
+        gtd(check): seam.applying → seam.try
+        gtd(human): seam.try → seam.restoring
+        gtd(check): seam.restoring → implement.applying
+        gtd(check): implement.applying → implement.health.check
+        gtd(check): implement.health.check → implement.closing
+        gtd(check): implement.closing → build.review.reviewing
+        """
+
+    Scenario: notes and a code edit send the pass back, out of the tree, to a naive pass that reads both
+      Given step "seam.naive", when prompted with "> subtract(5, 3) printed 8, not 2.", writes "notes-read.txt" with:
+        """
+        read
+        """
+      And step "seam.naive", when prompted with "-- . ':(exclude).gtd'", writes "edits-read.txt" with:
+        """
+        read
+        """
+      When the process is driven
+      Then the process rests at "seam.try"
+      Given a file ".gtd/NAIVE-TEST.md" with:
+        """
+        subtract(5, 3) printed 8, not 2.
+        """
+      And a file "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        export const subtract = (a: number, b: number) => a - b
+        """
+      And a file "src/hint.ts" with:
+        """
+        export const hint = "subtract, not add"
+        """
+      When gtd lands
+      And the process is driven
+      Then the process rests at "seam.try"
+      And "src/hint.ts" does not exist
+      And "notes-read.txt" contains "read"
+      And "edits-read.txt" contains "read"
+      And ".gtd/NAIVE-TEST.md" does not exist
+      And the commit subjects end with:
+        """
+        gtd(check): seam.applying → seam.try
+        gtd(human): seam.try → seam.restoring
+        gtd(check): seam.restoring → seam.naive
+        gtd(agent): seam.naive → seam.check
+        gtd(check): seam.check → seam.applying
+        gtd(check): seam.applying → seam.try
+        """
+
+    Scenario: notes alone send the pass back with no edits to read
+      Given step "seam.naive", when prompted with "They edited the code", writes "edits-read.txt" with:
+        """
+        read
+        """
+      When the process is driven
+      Then the process rests at "seam.try"
+      Given a file ".gtd/NAIVE-TEST.md" with:
+        """
+        subtract adds.
+        """
+      When gtd lands
+      And the process is driven
+      Then the process rests at "seam.try"
+      And "edits-read.txt" does not exist
+
+    Scenario: a requirements edit at seam.try stays, and sends the pass back
+      When the process is driven
+      Then the process rests at "seam.try"
+      Given a file ".gtd/REQUIREMENTS.md" with:
+        """
+        # Requirements
+
+        ## Impact
+
+        - the calculator module
+
+        ## Acceptance Criteria
+
+        - AC-1: subtract(a, b) returns a - b.
+        - AC-2: subtract(a, b) rejects NaN.
+        """
+      When gtd lands
+      And the process is driven
+      Then the process rests at "seam.try"
+      And ".gtd/REQUIREMENTS.md" contains "AC-2: subtract(a, b) rejects NaN."
+      And the commit subjects end with:
+        """
+        gtd(human): seam.try → seam.restoring
+        gtd(check): seam.restoring → seam.naive
+        gtd(agent): seam.naive → seam.check
+        gtd(check): seam.check → seam.applying
+        gtd(check): seam.applying → seam.try
+        """
+
+  Rule: with flagMode on
+
+    Background:
+      Given a gtd config with:
+        """
+        import { feature } from "@pmelab/gtd/workflows/feature"
+        export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
+        export default feature({ naiveTest: true })
+        """
+      And an environment variable "GTD_QUALITYREVIEWS" set to ""
+      And a file "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        """
+      And the working tree is committed as "feat: add calculator"
+      And a file "TODO.md" with:
+        """
+        # Add subtract
+
+        subtract(a, b) returns the difference.
+        """
+      And step "unwind" changes nothing
+      And step "start-gate.check" changes nothing
+      And step "design.triage" writes ".gtd/REQUIREMENTS.md" with:
+        """
+        # Requirements
+
+        ## Impact
+
+        - the calculator module
+
+        ## Acceptance Criteria
+
+        - AC-1: subtract(a, b) returns a - b.
+        """
+      And step "design.gate.answer" changes nothing
+      And step "seam.naive" writes "src/calc.test.ts" with:
+        """
+        it("[AC-1] subtracts", () => {})
+        """
+      And step "seam.naive" writes "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        export const subtract = (a: number, b: number) => a + b
+        """
+      And step "seam.check" changes nothing
+      And step "seam.applying" runs its script
+      And step "seam.restoring" runs its script
+
+    Scenario: with flagMode on the person tries the pass before the seam judge rules
+      When the process is driven
+      Then the process rests at "seam.try"
+      And the resting step's content contains "the seam judge rules on its shape"
+      When gtd lands
+      And the process is driven
+      Then the process rests at "seam.judge"
+
+  Rule: with a naiveTest that is neither true nor false
+
+    Background:
+      Given an environment variable "GTD_NAIVETEST" set to "maybe"
+      And a gtd config with:
+        """
+        import { feature } from "@pmelab/gtd/workflows/feature"
+        export { summary, steering, skills, access } from "@pmelab/gtd/workflows/feature"
+        export default feature()
+        """
+      And a file "src/calc.ts" with:
+        """
+        export const add = (a: number, b: number) => a + b
+        """
+      And the working tree is committed as "feat: add calculator"
+      And a file "TODO.md" with:
+        """
+        # Add subtract
+        """
+
+    Scenario: the landing that would pin it is refused
+      Then driving the process is refused with "naiveTest must be"

package/src/workflows/feature/one-step-land.feature

@@ -10,7 +10,6 @@ Feature: a naive pass the judge rules land is itself the implementation
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
     And a file "src/greeting.ts" with:

package/src/workflows/feature/refactor-absorbs.feature

@@ -10,7 +10,6 @@ Feature: a refactor that carried the whole feature still gets a quality lap over
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And an environment variable "GTD_REFACTORQUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAG_RISK_TIER" set to "0"

package/src/workflows/feature/refactor-first.feature

@@ -9,7 +9,6 @@ Feature: a refactor-first judgment walks one fixed path to the review gate
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_REFACTORQUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAG_RISK_TIER" set to "0"

package/src/workflows/feature/refactor-rebuild.feature

@@ -11,7 +11,6 @@ Feature: refactor-first writes a refactor note, refactors on its own, then rebui
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_REFACTORQUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAG_RISK_TIER" set to "0"

package/src/workflows/feature/refactor-review.feature

@@ -9,7 +9,6 @@ Feature: the refactor is reviewed on its own before the feature is implemented
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
 

package/src/workflows/feature/review-gate.feature

@@ -4,13 +4,12 @@ Feature: a feature process ends at the human review
   After the quality lap the process rests at the review gate,
   `.gtd/REVIEW.md`. A sign-off ends the process. A note asking for a change in
   behaviour starts a feedback lap — design, then implement with no new naive
-  pass or seam judge, the hands-on test, the quality lap — and the review
+  pass or seam judge, the quality lap — and the review
   again. Its design keeps a built criterion's ID and numbers
   new behaviour above every ID handed out.
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAGMODE" set to "false"
     And a file "src/calc.ts" with:

package/src/workflows/feature/reviewer-walkthrough.feature

@@ -10,7 +10,6 @@ Feature: a reviewer walks the human through the feature's code
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAGMODE" set to "false"
     And a file "src/calc.ts" with:

package/src/workflows/feature/seam-rejection.feature

@@ -9,7 +9,6 @@ Feature: rejected naive passes walk one fixed path through the steer gate to the
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAG_RISK_TIER" set to "0"
     And a file "src/calc.ts" with:

package/src/workflows/feature/seam.feature

@@ -7,7 +7,6 @@ Feature: the naive pass and seam judge decide how a feature is built
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And the gtd config ends with:
       """
       export const config = {

package/src/workflows/feature/seam.test.ts

@@ -403,8 +403,7 @@ describe("implement", () => {
     lastOptions = undefined
     installContext(
       fixtureContext(
-        // The hands-on test has its own scenarios.
-        { vars: { prototypeRounds: "0" } },
+        {},
         {
           step: (request: StepRequest) => {
             requests.push(request)

package/src/workflows/feature/seam.ts

@@ -3,6 +3,7 @@ import {
   agent,
   applyScript,
   changes,
+  changesSince,
   check,
   codeChanges,
   env,
@@ -14,6 +15,7 @@ import {
   read,
   refuse,
   removeScript,
+  restoreScript,
   run,
   scope,
   vars,
@@ -22,11 +24,10 @@ import {
   type DiffShapeResult,
   type KeptTip,
 } from "../../flows/index.js"
-import { coder, FEEDBACK, PROTOTYPE, REFACTOR_NOTE, REQUIREMENTS } from "../shared/steps.js"
+import { coder, FEEDBACK, NAIVE_TEST, REFACTOR_NOTE, REQUIREMENTS } from "../shared/steps.js"
 import * as t from "../shared/text.js"
 import { defaults } from "../shared/vars.js"
 import { green } from "./green.js"
-import { prototypeTest } from "./prototype.js"
 import { criterionIds, requireCriteria, requireCriteriaFrozen } from "./criteria.js"
 import {
   COMMENT,
@@ -36,7 +37,7 @@ import {
   reviewedRefactor,
 } from "./refactor.js"
 import { isCode } from "../shared/review.js"
-import { flagModeOn } from "../shared/options.js"
+import { flagModeOn, naiveTestOn } from "../shared/options.js"
 import type { RiskTier } from "./tier.js"
 
 /** Naive-pass retries after a `reject` or a red suite; the next one rests at `seam.steer`. */
@@ -53,7 +54,7 @@ export const judgeSeam = (tip: KeptTip): Promise<DiffShapeResult> =>
     exempt: tip.changes.filter((c) => c.status === "added").map((c) => c.path),
   })
 
-export const naivePass = (retry?: t.NaiveRetry): Promise<void> =>
+export const naivePass = (retry?: t.NaiveRetry | t.NaiveTested): Promise<void> =>
   t.agentWithSkills("naive", t.naivePassPrompt(retry), {
     label: retry === undefined ? "Writing the naive pass" : "Rewriting the naive pass",
     keep: true,
@@ -226,9 +227,8 @@ export const implementing = (options: ImplementOptions): Promise<readonly string
     if (built) await build(options)
     else requireCriteriaFrozen(REQUIREMENTS)
     await green()
-    await prototypeTest()
     const ids = criterionIds(read(REQUIREMENTS) ?? "")
-    await run("closing", removeScript([REQUIREMENTS, REFACTOR_NOTE, PROTOTYPE]), {
+    await run("closing", removeScript([REQUIREMENTS, REFACTOR_NOTE]), {
       label: "Closing out the implementation",
     })
     return ids
@@ -277,7 +277,7 @@ const budget = (): ((next: t.NaiveRetry) => Promise<Verdict>) => {
 }
 
 interface Vetting {
-  readonly again: ReturnType<typeof budget>
+  again: ReturnType<typeof budget>
   /** Set once a human overrules a test fault: the rule does not fit this change, so later passes skip it. */
   waived: boolean
 }
@@ -304,16 +304,62 @@ const ruled = async (tip: KeptTip, again: Vetting["again"]): Promise<Decision |
   return next.kind === "overruled" ? { reference: tip.hash, tip } : next
 }
 
+/** Back to `before`: every code path, and the notes file. `.gtd/` edits (the requirements) stay. */
+const untryScript = (before: string): string => {
+  const code = changesSince(before).filter((c) => isCode(c.path))
+  return restoreScript(
+    head(),
+    {
+      restore: code.filter((c) => c.status !== "added").map((c) => c.path),
+      remove: [...code.filter((c) => c.status === "added").map((c) => c.path), NAIVE_TEST],
+    },
+    before,
+  )
+}
+
+/**
+ * A person tries the green pass `tip` in the working tree. Resolves
+ * `undefined` on a clean landing (signed off), else what they sent back;
+ * either way the pass, their code edits and the notes file leave the tree.
+ */
+const tried = async (tip: KeptTip): Promise<t.NaiveTested | undefined> => {
+  const before = head()
+  await run("applying", applyScript(tip.hash, FEEDBACK, t.naiveApplyFailure(tip.hash), [".gtd"]), {
+    label: "Applying the naive pass to try it",
+  })
+  await human("try", {
+    message: t.naiveTryMessage(flagModeOn()),
+    label: "Try the naive pass",
+    file: NAIVE_TEST,
+    acceptClean: true,
+  })
+  const landed = changes()
+  const edits = landed.some((c) => isCode(c.path)) ? head() : undefined
+  const notes = read(NAIVE_TEST)?.trim() || undefined
+  if (landed.some((c) => c.path === REQUIREMENTS)) requireCriteria(REQUIREMENTS)
+  await run("restoring", untryScript(before), { label: "Taking the naive pass out again" })
+  return landed.length === 0 ? undefined : { tested: tip.hash, notes, edits }
+}
+
 const decide = (): Promise<Decision> =>
   scope("seam", async () => {
     const vetting: Vetting = { again: budget(), waived: false }
-    let retry: t.NaiveRetry | undefined
+    let retry: t.NaiveRetry | t.NaiveTested | undefined
     for (;;) {
       await naivePass(retry)
       const tip = kept("naive")!
+      const verdict = await vetted(tip, vetting)
+      if (verdict === undefined && naiveTestOn()) {
+        const sentBack = await tried(tip)
+        if (sentBack !== undefined) {
+          // A person's feedback is no failed attempt: the next pass gets a full retry budget.
+          vetting.again = budget()
+          retry = sentBack
+          continue
+        }
+      }
       const outcome =
-        (await vetted(tip, vetting)) ??
-        (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash, tip })
+        verdict ?? (flagModeOn() ? await ruled(tip, vetting.again) : { reference: tip.hash, tip })
       if (!("kind" in outcome)) return outcome
       retry = outcome.kind === "retry" ? outcome.retry : undefined
     }

package/src/workflows/feature/standards.feature

@@ -11,7 +11,6 @@ Feature: the review learns standards from the human's answers
 
   Background:
     Given the shipped workflows, as gtd install scaffolds them
-    And an environment variable "GTD_PROTOTYPEROUNDS" set to "0"
     And an environment variable "GTD_QUALITYREVIEWS" set to ""
     And an environment variable "GTD_FLAGMODE" set to "false"
     And a file "src/calc.ts" with:

package/src/workflows/shared/options.ts

@@ -24,11 +24,11 @@ export const ShippedOptions = Schema.Struct({
   seamAllow: setting,
   qualityReviews: setting,
   refactorQualityReviews: setting,
-  prototypeRounds: setting,
   testCommand: setting,
   plannerModel: setting,
   coderModel: setting,
   flagMode: Schema.optionalWith(Schema.Boolean, { exact: true }),
+  naiveTest: Schema.optionalWith(Schema.Boolean, { exact: true }),
 })
 
 export type ShippedOptions = Schema.Schema.Encoded<typeof ShippedOptions>
@@ -53,6 +53,14 @@ export const flagModeOn = (): boolean => {
   return value === "true"
 }
 
+/** The `naiveTest` setting, pinned at process start. Anything but true/false fails rather than guess. */
+export const naiveTestOn = (): boolean => {
+  const value = vars.naiveTest ?? defaults.naiveTest!
+  if (value !== "true" && value !== "false")
+    refuse(`gtd: naiveTest must be "true" or "false", got ${JSON.stringify(value)}`)
+  return value === "true"
+}
+
 /** A shipped flow as a factory: its options override the settings it declares, each in its own kind. */
 export const shipped = (
   flow: Flow,

package/src/workflows/shared/prose.ts

@@ -88,12 +88,6 @@ things when redirected — a failing check, or reviewer feedback. Stay
 strictly inside that task; never touch code outside it. Treat feedback as the
 diagnosis to act on; discard it, with reason, only when simply wrong.`
 
-export const testerPersona = `You are the hands-on tester in gtd's build pipeline: use what was just
-built the way a person would — run the real program, open the real
-page, call the real endpoint — and report exactly what you did and
-what you saw. Never fix anything yourself, and never pass a criterion
-you did not watch hold.`
-
 export const finisherPersona = `You are the closing identity in gtd's build pipeline — the last coder
 before it closes. Fix a late-breaking failing check after sign-off,
 focused and minimal. Every turn lands its own commit — nothing here

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

@@ -29,10 +29,6 @@ describe("the bundled workflow's skills export", () => {
         "implement",
         "implement.fix.suite",
         "implement.health",
-        "implement.prototype",
-        "implement.prototype.fix",
-        "implement.prototype.fix.suite",
-        "implement.prototype.health",
         "build.quality.correctness",
         "build.quality.owasp-security",
         "build.quality.ponytail-review",

package/src/workflows/shared/skills.ts

@@ -33,11 +33,6 @@ export const skills = (
     seam: ["incremental-implementation"],
     implement: ["test-driven-development", "incremental-implementation"],
     "implement.fix.suite": ["debugging-and-error-recovery"],
-    // The hands-on tester runs the program, never the suite: no TDD.
-    "implement.prototype": [],
-    "implement.prototype.fix": ["test-driven-development", "incremental-implementation"],
-    "implement.prototype.fix.suite": ["debugging-and-error-recovery"],
-    "implement.prototype.health": ["debugging-and-error-recovery"],
     // `health` is shared code reached from both `implement` and `build`.
     "implement.health": ["debugging-and-error-recovery"],
     ...lensScopes(

package/src/workflows/shared/steps.ts

@@ -14,7 +14,7 @@ export const REVIEW = ".gtd/REVIEW.md"
 export const REFACTOR = ".gtd/REFACTOR.md"
 export const REFACTOR_NOTE = ".gtd/REFACTOR-NOTE.md"
 export const QUALITY = ".gtd/QUALITY.md"
-export const PROTOTYPE = ".gtd/PROTOTYPE.md"
+export const NAIVE_TEST = ".gtd/NAIVE-TEST.md"
 
 export const planner = (): string => env.plannerModel ?? ""
 export const coder = (): string => env.coderModel ?? ""