@pmelab/gtd 50.0.0 → 51.0.1

package/src/edge/Edge.ts

@@ -37,6 +37,7 @@ import {
   isRecordableApproval,
   parseCommitMessage,
   replay,
+  scopeRunStart,
   sliceRanges,
   treeFromRecord,
   type EpisodeCommit,
@@ -791,36 +792,6 @@ const stepDefOf = (step: ReachedStep): StepDef => {
   }
 }
 
-/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
-const inScope = (name: string, scope: string): boolean =>
-  scope === "" || name === scope || name.startsWith(`${scope}.`)
-
-/**
- * Where the current unbroken run of rests inside `scope`'s subtree began —
- * a dip into a descendant scope does not break it, a sibling or ancestor
- * does, and so does a fresh `scope()` call of the same scope.
- */
-const scopeRunStart = (trace: readonly ReachedStep[], scope: string): number => {
-  let start = -1
-  for (let k = 0; k < trace.length; k++) {
-    if (!inScope(trace[k]!.memoryScope, scope)) continue
-    const previous = trace[k - 1]
-    const unbroken =
-      previous !== undefined &&
-      inScope(previous.memoryScope, scope) &&
-      scopeCallOf(previous, scope) === scopeCallOf(trace[k]!, scope)
-    if (!unbroken) start = k
-  }
-  return start
-}
-
-/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
-const scopeCallOf = (step: ReachedStep, scope: string): number | undefined => {
-  let call: number | undefined
-  for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call
-  return call
-}
-
 // Shown for the root scope, which has no name of its own.
 const ROOT_MEMORY_SCOPE_NAME = "root"
 

package/src/replay/Replay.test.ts

@@ -940,7 +940,7 @@ describe("replay: skills resolution", () => {
     expect(await wireSkills(inScope({ name: "a" }, step), { skills: { a: [] } })).toBeUndefined()
   })
 
-  it("fails two agent steps in one memory scope with different lists", async () => {
+  it("runs two scope() calls of one memory scope with different lists as two conversations", async () => {
     const flow: Flow = async () => {
       await scope({ name: "a", skills: ["one"] }, async () => {
         await agent("first", "prompt")
@@ -959,9 +959,7 @@ describe("replay: skills resolution", () => {
       start: hashOf(0),
       budgetBytes: 1024,
     })
-    expect(outcome.kind === "failed" && outcome.message).toContain(
-      "different model, system prompt, skills or file access",
-    )
+    expect(outcome.kind).toBe("rest")
   })
 })
 
@@ -1084,7 +1082,7 @@ describe("replay: access resolution", () => {
     expect(outcome.rest.access).toEqual({ read: null, write: ["src/a.ts"] })
   })
 
-  it("fails two agent steps in one memory scope with different scope access", async () => {
+  it("runs two scope() calls of one memory scope with different access as two conversations", async () => {
     const flow: Flow = async () => {
       await scope({ name: "a", access: { write: ["one"] } }, () => agent("first", "prompt"))
       await scope({ name: "a", access: { write: ["two"] } }, () => agent("second", "prompt"))
@@ -1092,9 +1090,7 @@ describe("replay: access resolution", () => {
     const history = new History()
     history.land("agent", "a.first", 1, "a.second", { "x.txt": "x" })
     const outcome = await restOf(flow, {}, history)
-    expect(outcome.kind === "failed" && outcome.message).toContain(
-      "different model, system prompt, skills or file access",
-    )
+    expect(outcome.kind).toBe("rest")
   })
 
   it("does not conflict two steps that differ only in steering file", async () => {

package/src/replay/Replay.ts

@@ -139,6 +139,36 @@ const memoryScopeOf = (name: string): string => {
   return dot === -1 ? "" : name.slice(0, dot)
 }
 
+/** Is `name` inside `scope`'s subtree? The root scope `""` holds everything. */
+const inScope = (name: string, scope: string): boolean =>
+  scope === "" || name === scope || name.startsWith(`${scope}.`)
+
+/**
+ * Where the current unbroken run of rests inside `scope`'s subtree began —
+ * a dip into a descendant scope does not break it, a sibling or ancestor
+ * does, and so does a fresh `scope()` call of the same scope.
+ */
+export const scopeRunStart = (trace: readonly ReachedStep[], scope: string): number => {
+  let start = -1
+  for (let k = 0; k < trace.length; k++) {
+    if (!inScope(trace[k]!.memoryScope, scope)) continue
+    const previous = trace[k - 1]
+    const unbroken =
+      previous !== undefined &&
+      inScope(previous.memoryScope, scope) &&
+      scopeCallOf(previous, scope) === scopeCallOf(trace[k]!, scope)
+    if (!unbroken) start = k
+  }
+  return start
+}
+
+/** The innermost `scope()` call enclosing `scope` at `step` — a new call is a new conversation. */
+const scopeCallOf = (step: ReachedStep, scope: string): number | undefined => {
+  let call: number | undefined
+  for (const entry of step.scopeCalls) if (inScope(scope, entry.prefix)) call = entry.call
+  return call
+}
+
 class Stop extends Error {}
 
 const short = (hash: string): string => hash.slice(0, 7)
@@ -505,14 +535,16 @@ export const replay = async (input: ReplayInput): Promise<ReplayOutcome> => {
       skills: step.skills,
       access: unfoldedAccess.get(step),
     }
-    const seen = personas.get(step.memoryScope)
+    // Keyed like the memory key: a fresh scope() call is a fresh conversation, free to differ.
+    const conversation = `${step.memoryScope}#${scopeRunStart(trace, step.memoryScope)}`
+    const seen = personas.get(conversation)
     if (seen === undefined) {
-      personas.set(step.memoryScope, identity)
+      personas.set(conversation, identity)
       return undefined
     }
     return samePersona(seen, identity)
       ? undefined
-      : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in memory scope "${step.memoryScope || "root"}" — one scope is one conversation, and a conversation has one identity`
+      : `gtd: "${step.name}" runs with a different model, system prompt, skills or file access than an earlier agent step in its conversation in memory scope "${step.memoryScope || "root"}" — a conversation has one identity`
   }
 
   const DIVERGED = "the workflow changed under this process; run `gtd abandon` to start over"

package/src/replay/index.ts

@@ -1,4 +1,10 @@
-export { replay, type EpisodeCommit, type ReachedStep, type ReplayOutcome } from "./Replay.js"
+export {
+  replay,
+  scopeRunStart,
+  type EpisodeCommit,
+  type ReachedStep,
+  type ReplayOutcome,
+} from "./Replay.js"
 export { treeFromRecord, type TreeView } from "./Tree.js"
 export {
   formatCommitMessage,

package/src/workflows/feature/coverage.feature

@@ -9,6 +9,7 @@ Feature: a feature is done only when every acceptance criterion has a passing te
 
   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/fast-path.feature

@@ -8,6 +8,7 @@ Feature: a trivial change takes the same few beats at either risk tier
 
   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 "1"
     And a file "src/greeting.ts" with:

package/src/workflows/feature/feature.ts

@@ -28,6 +28,7 @@ import {
 } from "./criteria.js"
 import { design } from "./planning.js"
 import { buildTail, humanReview, isCode, reUnwind, type ReviewOutcome } from "../shared/review.js"
+import { prototypeRounds } from "./prototype.js"
 import { implement, implementing, seamBuild } from "./seam.js"
 import { sliceCap, sliceCriteria, slicing } from "./slicing.js"
 import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
@@ -36,7 +37,8 @@ import { recordRisk, riskTierOn, type RiskTier } from "./tier.js"
 // `unwind` reverts the sketch (its intent survives in history) → a
 // green-baseline gate → design → per slice of the criteria, a naive pass,
 // judged with `flagMode` on: it lands as the implementation, or (refactoring
-// first when the judge asks) is built fresh from → the health loop → the
+// 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, whose leftovers are carried on → after the last slice,
 // a reviewer's walkthrough of the whole change, every slice's findings
 // among its chunks, for the human, which
@@ -227,6 +229,7 @@ export const ordinaryStart = async (): Promise<void> => {
   // Read right after idle, so a bad value refuses the landing that would pin it.
   flagModeOn()
   sliceCap()
+  prototypeRounds()
   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 })
+      export default feature({ flagMode: false, prototypeRounds: "0" })
       """
     And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
     And a file "src/calc.ts" with:

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

@@ -12,6 +12,7 @@ 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

@@ -9,6 +9,7 @@ Feature: the quality lap's findings are triaged before the review
 
   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/one-step-land.feature

@@ -10,6 +10,7 @@ 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/prototype-rounds.feature

@@ -0,0 +1,152 @@
+@inmem
+Feature: past its round cap the hands-on test rests at a person's gate
+
+  `prototypeRounds` caps the fix turns a slice's hands-on test gets. Once they
+  are spent and the report still has open items, the process rests at
+  implement.prototype.open naming them; a person's fix there is tested again
+  with a fresh budget.
+
+  Background:
+    Given the shipped workflows, as gtd install scaffolds them
+    And an environment variable "GTD_QUALITYREVIEWS" set to "correctness"
+    And an environment variable "GTD_FLAGMODE" set to "false"
+    And an environment variable "GTD_PROTOTYPEROUNDS" set to "1"
+    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
+
+      ## Acceptance Criteria
+
+      - AC-1: subtract(a, b) returns a - b.
+      - AC-2: add is unchanged.
+      """
+    And step "design.gate.answer" changes nothing
+    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.naive" writes "src/calc.test.ts" with:
+      """
+      it("[AC-1] subtracts", () => expect(subtract(3, 1)).toBe(2))
+      it("[AC-2] adds", () => expect(add(1, 1)).toBe(2))
+      """
+    And step "seam.check" changes nothing
+    And step "implement.applying" runs its script
+    And step "implement.health.check" changes nothing
+    And judge step "implement.coverage" answers:
+      """
+      [{"id":"AC-1","answer":"yes","p":0.9},{"id":"AC-2","answer":"yes","p":0.9}]
+      """
+    And step "implement.closing" runs its script
+
+  Scenario: past the round cap a person is asked, naming the open items
+    Given step "implement.prototype.testing", when prompted with "Find how this project", writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: fail
+
+      `subtract(3, 1)` printed 4. Expected 2.
+
+      ## AC-2: pass
+
+      Printed 2.
+      """
+    And step "implement.prototype.testing", when prompted with "This is a re-test", writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: fail
+
+      Re-tested: `subtract(3, 1)` printed -2. Expected 2.
+
+      ## AC-2: pass
+
+      Printed 2.
+      """
+    And step "implement.prototype.fix.fixing" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => b - a
+      """
+    And step "implement.prototype.health.check" changes nothing
+    When the process is driven
+    Then the process rests at "implement.prototype.open"
+    And the resting step's content contains "- AC-1: fail"
+    And the resting step's content contains "after 1 fix round"
+    And the resting step's content does not contain "AC-2"
+
+  Scenario: a person's change at the gate is tested again
+    Given step "implement.prototype.testing", when prompted with "Find how this project", writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: blocked
+
+      `subtract` is not exported from any entry point I could run.
+
+      ## AC-2: pass
+
+      Printed 2.
+      """
+    And step "implement.prototype.open" 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 "implement.prototype.health.check" changes nothing
+    And step "implement.prototype.testing", when prompted with "This is a re-test", writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: pass
+
+      `subtract(3, 1)` printed 2.
+
+      ## AC-2: pass
+
+      Printed 2.
+      """
+    When the process is driven
+    Then the process rests at "build.quality.correctness.reviewing"
+    And the commit subjects end with:
+      """
+      gtd(agent): implement.prototype.testing → implement.prototype.open
+      gtd(human): implement.prototype.open → implement.prototype.health.check
+      gtd(check): implement.prototype.health.check → implement.prototype.testing
+      gtd(agent): implement.prototype.testing → implement.closing
+      gtd(check): implement.closing → build.quality.correctness.reviewing
+      """
+
+  Scenario: a re-test that sees exactly what the last round saw still ends the round
+    Given step "implement.prototype.testing" writes ".gtd/PROTOTYPE.md" with:
+      """
+      ## AC-1: fail
+
+      `subtract(3, 1)` printed 4. Expected 2.
+
+      ## AC-2: pass
+
+      Printed 2.
+      """
+    And step "implement.prototype.fix.fixing" writes "src/calc.ts" with:
+      """
+      export const add = (a: number, b: number) => a + b
+      export const subtract = (a: number, b: number) => b - a
+      """
+    And step "implement.prototype.health.check" changes nothing
+    When the process is driven
+    Then the process rests at "implement.prototype.open"
+    And the commit subjects end with:
+      """
+      gtd(agent): implement.prototype.testing → implement.prototype.fix.fixing
+      gtd(agent): implement.prototype.fix.fixing → implement.prototype.health.check
+      gtd(check): implement.prototype.health.check → implement.prototype.testing
+      gtd(agent): implement.prototype.testing → implement.prototype.open
+      """