@pmelab/gtd 29.3.1 → 30.1.0

package/src/workflows/shared/options.ts

@@ -5,6 +5,8 @@ import {
   type WorkflowBase,
   type WorkflowDoors,
   type WorkflowFactory,
+  refuse,
+  vars,
 } from "../../flows/index.js"
 import { defaultFlagRegistry, defaults, envDefaults } from "./vars.js"
 
@@ -23,18 +25,31 @@ export const ShippedOptions = Schema.Struct({
   testCommand: setting,
   plannerModel: setting,
   coderModel: setting,
+  flagMode: Schema.optionalWith(Schema.Boolean, { exact: true }),
 })
 
 export type ShippedOptions = Schema.Schema.Encoded<typeof ShippedOptions>
 
 const over = (
   base: Readonly<Record<string, string>>,
-  options: Readonly<Record<string, string>>,
+  options: Readonly<Record<string, string | boolean>>,
 ): Record<string, string> => ({
   ...base,
-  ...Object.fromEntries(Object.entries(options).filter(([name]) => Object.hasOwn(base, name))),
+  ...Object.fromEntries(
+    Object.entries(options)
+      .filter(([name]) => Object.hasOwn(base, name))
+      .map(([name, value]) => [name, String(value)]),
+  ),
 })
 
+/** The `flagMode` setting, pinned at process start. Anything but true/false fails rather than guess a side. */
+export const flagModeOn = (): boolean => {
+  const value = vars.flagMode ?? defaults.flagMode!
+  if (value !== "true" && value !== "false")
+    refuse(`gtd: flagMode 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

@@ -73,12 +73,6 @@ classified list of concerns, and hold the running product conversation
 with the human it depends on. You are read by that human — write
 plainly — not by a parser, except where a state says otherwise.`
 
-export const architectPersona = `You are the technical planning voice in gtd's build pipeline: take over
-once product concerns are settled, reading them cold, no carried
-conversation. Work out the *how* per concern — structure, data models,
-tech-stack choices, error handling — raise the technical open
-questions, then pin interfaces and tests in the architecture document.`
-
 export const reviewerPersona = `You are the independent reviewing mind in gtd's build pipeline —
 deliberately separate from whoever wrote the code, with no attachment
 to it. Write a structured review document grouping a diff into
@@ -88,11 +82,10 @@ and, when asked, fix the small nits the human flagged and the risks
 you marked yourself, each in one batch.
 Beyond that you never fix or build anything yourself.`
 
-export const builderPersona = `You are the TDD implementer in gtd's build pipeline: build one
-package's declared scope end to end, tests first, and come back to fix
+export const builderPersona = `You are the TDD implementer in gtd's build pipeline: build the
+task in front of you end to end, tests first, and come back to fix
 things when redirected — a failing check, or reviewer feedback. Stay
-strictly inside the package in front of you; never touch another
-package's files or code outside the task. Treat feedback as the
+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 finisherPersona = `You are the closing identity in gtd's build pipeline — the last coder
@@ -136,7 +129,7 @@ export const questionBar = `- The goal is shared understanding, not a quota or a
   settle it (treat an explicit \`.gtd/TODO.md\` directive, a committed
   hand-edit, or — on a loop-back lap — the human's own review-round
   edit/note as settled); or it would be expensive to undo once
-  packages are written
+  code is written
 - Where no gap in shared understanding exists, decide it yourself:
   record it under \`## Answered Questions\` as
   \`### <the point phrased as a question>\`

package/src/workflows/shared/reserved.ts

@@ -1,6 +1,6 @@
 import type { Summary } from "../../flows/index.js"
 import * as t from "./text.js"
-import { ARCHITECTURE, REQUIREMENTS, REVIEW } from "./steps.js"
+import { REQUIREMENTS, REVIEW } from "./steps.js"
 
 export { defaults, envDefaults } from "./vars.js"
 export { skills } from "./skills.js"
@@ -8,4 +8,4 @@ export { access } from "./access.js"
 
 export const summary: Summary = t.summaryPrompt
 
-export const steering = { [REQUIREMENTS]: "qa", [ARCHITECTURE]: "qa", [REVIEW]: "review" }
+export const steering = { [REQUIREMENTS]: "qa", [REVIEW]: "review" }

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

@@ -14,11 +14,6 @@ describe("the bundled workflow's skills export", () => {
     expect(Object.keys(bundled).sort()).toEqual(
       [
         "design",
-        "architecture",
-        "architecture.decompose",
-        "packages.item",
-        "packages.item.fix.suite",
-        "packages.item.health",
         "build",
         "build.health",
         "build.fix.quality",
@@ -54,7 +49,6 @@ describe("the bundled workflow's skills export", () => {
 
   it("keys no group scope or non-agent step", () => {
     for (const group of [
-      "packages.item.fix",
       "build.fix",
       "build.review.fix",
       "build.quality",
@@ -70,11 +64,6 @@ describe("the bundled workflow's skills export", () => {
   it("pins each scope's list", () => {
     expect(bundled).toMatchObject({
       design: ["spec-driven-development", "planning-and-task-breakdown"],
-      architecture: ["api-and-interface-design", "documentation-and-adrs", "ponytail"],
-      "architecture.decompose": ["incremental-implementation", "planning-and-task-breakdown"],
-      "packages.item": ["test-driven-development", "incremental-implementation"],
-      "packages.item.fix.suite": ["debugging-and-error-recovery"],
-      "packages.item.health": ["debugging-and-error-recovery"],
       build: ["debugging-and-error-recovery"],
       "build.health": ["debugging-and-error-recovery"],
       "build.fix.quality": ["incremental-implementation", "code-simplification"],

package/src/workflows/shared/skills.ts

@@ -4,7 +4,7 @@ import { lensesOf, lensScopes } from "../../workflow-kit/index.js"
 // The bundled workflow's default skills, one list per SCOPE, keyed by the
 // scope's full name — the same name a `config.skills` entry addresses. A
 // nested scope with no entry inherits its parent's; group scopes
-// (`packages.item.fix`, `build.fix`, `build.review.fix`, `build.quality`, `refactor.fix`) run
+// (`implement.fix`, `build.fix`, `build.review.fix`, `build.quality`, `refactor.fix`) run
 // no turn and carry no key. `build.quality.<lens>` is one key per
 // `qualityReviews` entry, so the export is a function of the vars.
 export const skills = (
@@ -20,12 +20,6 @@ export const skills = (
   }
   return {
     design: ["spec-driven-development", "planning-and-task-breakdown"],
-    architecture: ["api-and-interface-design", "documentation-and-adrs", "ponytail"],
-    "architecture.decompose": ["incremental-implementation", "planning-and-task-breakdown"],
-    "packages.item": ["test-driven-development", "incremental-implementation"],
-    "packages.item.fix.suite": ["debugging-and-error-recovery"],
-    // `health` is shared code reached from both `packages.item` and `build`.
-    "packages.item.health": ["debugging-and-error-recovery"],
     // `fix`'s turn over the notes a review handed on.
     notes: ["incremental-implementation", "code-simplification"],
     // The refactor's own turns load `ponytail`; `refactor.build.*` carry the `build.*` lists.
@@ -34,11 +28,10 @@ export const skills = (
     refactor: ["ponytail"],
     "refactor.fix.suite": ["ponytail", "debugging-and-error-recovery"],
     "refactor.health": ["ponytail", "debugging-and-error-recovery"],
-    // Declared whether or not `naive_pass` is on, so a config keyed on them keeps
-    // loading when the flag flips off.
     seam: ["incremental-implementation"],
     implement: ["test-driven-development", "incremental-implementation"],
     "implement.fix.suite": ["debugging-and-error-recovery"],
+    // `health` is shared code reached from both `implement` and `build`.
     "implement.health": ["debugging-and-error-recovery"],
     ...lensScopes(
       "build.quality",

package/src/workflows/shared/steps.ts

@@ -10,7 +10,6 @@ import * as t from "./text.js"
 export const FEEDBACK = ".gtd/FEEDBACK.md"
 export const ESCALATION = ".gtd/ESCALATION.md"
 export const REQUIREMENTS = ".gtd/REQUIREMENTS.md"
-export const ARCHITECTURE = ".gtd/ARCHITECTURE.md"
 export const REVIEW = ".gtd/REVIEW.md"
 export const REFACTOR = ".gtd/REFACTOR.md"
 export const QUALITY = ".gtd/QUALITY.md"

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

@@ -8,10 +8,6 @@ import {
   deferNotesScript,
   buildReviewReviewingPrompt,
   agentWithSkills,
-  architectureAuthorPrompt,
-  architectureDecomposePrompt,
-  packagesItemBuildingPrompt,
-  architectureGateAnswerMessage,
   buildFixPrompt,
   buildFixQualityPrompt,
   buildReviewFixNitsPrompt,
@@ -167,23 +163,6 @@ describe("the shared open-question instruction", () => {
     expect(prompt).toContain("one to four bullets, free-form")
     expect(prompt).toContain("labels, no fixed bullet count")
   })
-
-  it("is the identical block, full text, in both the design gate and the architecture gate", () => {
-    // Anchored at questionBar's own first and last lines (not a bullet
-    // partway in) so the whole ~3.4k-char block is compared — a divergence
-    // anywhere inside, including its opening bullets, fails this test the
-    // moment either gate's copy drifts from the shared source.
-    const start = "The goal is shared understanding, not a quota or an empty section"
-    const end = "Never tick a box yourself — the human ticks exactly one per question"
-    const sharedBlock = (prompt: string): string =>
-      prompt.slice(prompt.indexOf(start), prompt.indexOf(end) + end.length)
-
-    const designBlock = sharedBlock(renderText(() => designTriagePrompt("base")))
-    const architectureBlock = sharedBlock(renderText(() => architectureAuthorPrompt()))
-
-    expect(designBlock.length).toBeGreaterThan(3000)
-    expect(designBlock).toBe(architectureBlock)
-  })
 })
 
 describe("answered-entry footnote exception", () => {
@@ -196,32 +175,6 @@ describe("answered-entry footnote exception", () => {
     expect(prompt).not.toContain("never re-open a settled")
     expect(prompt).not.toContain("never re-open one")
   })
-
-  it("is in the architecture return lap and keeps the first-lap settled line", () => {
-    const prompt = renderText(() => architectureAuthorPrompt())
-    expect(prompt).toContain(`entry stays settled, except one ${exception}`)
-    expect(prompt).not.toContain("never re-open a settled")
-    expect(prompt).toMatch(/treat every decision[\s\S]*as settled — never re-open it/)
-  })
-})
-
-describe("architectureAuthorPrompt", () => {
-  it("qualifies the PERMISSIVE default with a settled-requirements exception", () => {
-    const prompt = renderText(() => architectureAuthorPrompt())
-    expect(prompt).toContain("is an open question, not a")
-  })
-  it("names the four content sections in order and the entry forms", () => {
-    const prompt = renderText(() => architectureAuthorPrompt())
-    const at = ["## Interfaces", "## Call Stacks", "## E2E Scenarios", "## Unit Tests"].map((h) =>
-      prompt.indexOf(h),
-    )
-    expect(at.every((i) => i >= 0)).toBe(true)
-    expect([...at].sort((a, b) => a - b)).toEqual(at)
-    expect(prompt).toContain("- unit: <path>")
-    expect(prompt).toContain("- e2e: <path>")
-    expect(prompt).toContain("- chore: <path>")
-    expect(prompt).toContain("No e2e change.")
-  })
 })
 
 describe("buildFixPrompt", () => {
@@ -688,16 +641,11 @@ Print the closing message and stop — this writes nothing itself.
   it("treats a flag-on process with no tier mark as high", () => {
     const prompt = summaryPrompt({
       ...base,
-      vars: { flag_risk_tier: "1", flag_naive_pass: "1" },
+      vars: { flag_risk_tier: "1" },
     })
     expect(prompt).toContain("Risk tier: high")
   })
 
-  it("marks no tier when the risk-tier flag is on without naive-pass", () => {
-    const prompt = summaryPrompt({ ...base, vars: { flag_risk_tier: "1", flag_naive_pass: "0" } })
-    expect(prompt).not.toContain("Risk tier")
-  })
-
   it("says the human left no comment or edit this process when humanCommits is empty", () => {
     expect(summaryPrompt(base)).toContain(
       "The human left no comment or edit this process —\nevery commit is machine-authored.",
@@ -812,10 +760,9 @@ describe("buildReviewCollectingPrompt without a refactor", () => {
 })
 
 describe("the thread rules", () => {
-  it("are in all three answering prompts and no longer say a footnote is human input only", () => {
+  it("are in both answering prompts and no longer say a footnote is human input only", () => {
     const prompts = renderText(() => [
       designTriagePrompt("base"),
-      architectureAuthorPrompt(),
       buildReviewCollectingPrompt("capture"),
     ])
     for (const prompt of prompts) {
@@ -837,13 +784,9 @@ describe("code threads in prompts", () => {
     { path: "src/b.ts", line: 9, waitingOn: "human", first: "done", faults: [] },
   ] as const
 
-  it("lists the code threads waiting on the agent in the three gates", () => {
+  it("lists the code threads waiting on the agent in both gates", () => {
     const prompts = renderText(
-      () => [
-        designTriagePrompt("base"),
-        architectureAuthorPrompt(),
-        buildReviewCollectingPrompt("capture"),
-      ],
+      () => [designTriagePrompt("base"), buildReviewCollectingPrompt("capture")],
       { codeThreads: waiting },
     )
     for (const prompt of prompts) {
@@ -866,7 +809,6 @@ describe("code threads in prompts", () => {
   it("teaches the syntax once in the footnote rules", () => {
     for (const message of renderText(() => [
       designGateAnswerMessage(),
-      architectureGateAnswerMessage(),
       buildReviewAwaitReviewMessage("base"),
     ])) {
       expect(message).toContain("gtd check --open-threads")
@@ -1048,6 +990,22 @@ describe("the seam phase's texts", () => {
     expect(prompt).toContain("Implement them properly")
   })
 
+  it("flag mode off asks for the naive version and no release flag, whatever the tier or lap", () => {
+    for (const [tier, amend] of [
+      ["high", false],
+      ["low", false],
+      ["high", true],
+    ] as const) {
+      const prompt = renderText(() => implementBuildingPrompt(undefined, tier, amend, false, false))
+      expect(prompt).toContain("Add no release flag — this project ships without release flags")
+      expect(prompt).not.toContain("new release flag")
+      expect(prompt).not.toContain("low risk tier")
+    }
+    expect(
+      renderText(() => implementBuildingPrompt(undefined, "high", false, false, false)),
+    ).toContain("the quickest way that works")
+  })
+
   it("keeps a fix turn to the feedback file's rules", () => {
     expect(renderText(() => implementFixPrompt())).toContain(".gtd/FEEDBACK.md")
   })
@@ -1306,45 +1264,3 @@ it("asks the refactor review, and only it, to flag a test-file hunk that is more
   expect(refactor).toContain("give any test-file hunk its own chunk")
   expect(first).not.toContain("give any test-file hunk its own chunk")
 })
-
-describe("architectureDecomposePrompt tests rule", () => {
-  it("states one rule: write-or-change, relied-on marked (unchanged), no other untouched", () => {
-    const prompt = renderText(() => architectureDecomposePrompt()).replace(/\s+/g, " ")
-    expect(prompt).toContain("List every test the package writes or changes")
-    expect(prompt).toContain("also list an existing test a criterion relies on")
-    expect(prompt).toContain("list no other untouched test")
-    expect(prompt).toContain("- unit: \\`<path>\\` (unchanged)")
-    expect(prompt).toContain("- e2e: \\`<path>\\` (unchanged)")
-    expect(prompt).toContain("only decompose places the marker")
-  })
-})
-
-describe("packagesItemBuildingPrompt", () => {
-  const prompt = renderText(() => packagesItemBuildingPrompt(".gtd/packages/01-a.md")).replace(
-    /\s+/g,
-    " ",
-  )
-  it("carries the evidence kinds and the already-done check", () => {
-    for (const w of [
-      "evidence per criterion",
-      "commit, file, symbol, issue URL, or command output — and change nothing else",
-      "it was not already done",
-      "via `gh`",
-    ])
-      expect(prompt).toContain(w)
-  })
-  it("states the already-met, no-tests out-of-tree and implement-normally rules flat", () => {
-    expect(prompt).toContain("Every criterion already met in the tree")
-    expect(prompt).toContain("No `## Tests` and work outside the tree")
-    expect(prompt).toContain(
-      "Any other package**: implement normally, write no `.gtd/SATISFIED.md`",
-    )
-  })
-  it("says an (unchanged) line must exist and stay untouched", () => {
-    expect(prompt).toContain("(unchanged)")
-    expect(prompt).toContain("stay untouched")
-    expect(prompt).toContain("creating, editing or deleting it refuses the turn")
-    expect(prompt).toContain("must exist before the turn")
-    expect(prompt).toContain("stop without creating it")
-  })
-})