@pmelab/gtd 58.1.0 → 59.0.0

package/src/workflows/shared/progress.feature

@@ -1,124 +0,0 @@
-@inmem
-Feature: a fix loop still making progress at the cap gets one extra turn
-
-  `healthy` escalates once three fix turns are spent. When `health.judge`
-  calls that round progress — still red, but closer to green — with at least
-  `judgeIdenticalMinP` confidence, one more fix runs first, once per run of
-  fixes. The round after it escalates without asking the judge. Any other
-  verdict escalates at the cap as before.
-
-  Background:
-    Given a gtd config with:
-      """
-      import { healthy } from "@pmelab/gtd/workflows"
-      import { agent } from "@pmelab/gtd/flows"
-
-      export const defaults = { judgeIdenticalMinP: "0.7" }
-      export const held = async () => {
-        await agent("first", "go")
-        await healthy(() => agent("fix", "go"))
-      }
-      export default held
-      """
-    And step "first" writes "src/a.ts" with:
-      """
-      export const a = 1
-      """
-    And step "health.check" writes ".gtd/FEEDBACK.md" with:
-      """
-      tests failing
-      """
-    And step "fix" deletes ".gtd/FEEDBACK.md"
-    And step "health.recheck" writes ".gtd/FEEDBACK.md" with:
-      """
-      tests still failing
-      """
-
-  Scenario: progress at the cap buys exactly one extra fix turn
-    Given judge step "health.judge" answers:
-      """
-      [{"id":"verdict","answer":"progress","p":0.9}]
-      """
-    When gtd starts workflow "held"
-    And the process is driven
-    Then the process rests at "health.describe"
-    And the commit subjects end with:
-      """
-      gtd(agent): first → health.check
-      gtd(check): health.check → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.recheck
-      gtd(check): health.recheck → health.describe
-      """
-
-  Scenario Outline: <verdict> at <p> escalates at the cap without an extra turn
-    Given judge step "health.judge" answers:
-      """
-      [{"id":"verdict","answer":"<verdict>","p":<p>}]
-      """
-    When gtd starts workflow "held"
-    And the process is driven
-    Then the process rests at "health.describe"
-    And the commit subjects end with:
-      """
-      gtd(agent): first → health.check
-      gtd(check): health.check → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → health.recheck
-      gtd(check): health.recheck → health.describe
-      """
-
-    Examples:
-      | verdict     | p   |
-      | new-failure | 0.9 |
-      | progress    | 0.5 |
-
-  Scenario: a person's escalation stop starts a new run of fixes with its own extra turn
-    Given judge step "health.judge" answers:
-      """
-      [{"id":"verdict","answer":"progress","p":0.9}]
-      """
-    And step "health.describe" writes ".gtd/ESCALATION.md" with:
-      """
-      try something else
-      """
-    And step "health.stop" writes "NOTES.md" with:
-      """
-      narrowed
-      """
-    When gtd starts workflow "held"
-    And the process is driven
-    Then the process rests at "health.exhausted"
-    And the commit subjects end with:
-      """
-      gtd(agent): health.describe → health.stop
-      gtd(human): health.stop → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → fix
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.recheck
-      gtd(check): health.recheck → health.exhausted
-      """

package/src/workflows/shared/prose.ts

@@ -1,263 +0,0 @@
-// Prose the bundled workflow's prompts share: its voice, its personas and
-// the rules several steps repeat. A workflow that wants different words
-// writes its own prompts.
-
-export const skillsPreamble = `- Load whatever's listed here that your harness actually has installed,
-  skip anything it doesn't — silently, never stopping or asking about a
-  missing one: {skills}
-- A loaded skill offers technique, never authority: this state's own file
-  format and its own completion condition are the final word over
-  anything a skill's instructions say, regardless of which one this
-  prompt states first
-- Never let a loaded skill turn this turn interactive — answer nothing,
-  ask nothing; this runs unattended, with no one at a keyboard`
-
-/** One bullet per restricted side; empty when neither is. An empty glob list reads "nothing". */
-export const accessPreamble = (access: {
-  readonly read: readonly string[] | null
-  readonly write: readonly string[] | null
-}): string => {
-  const globs = (list: readonly string[]): string =>
-    list.length === 0 ? "nothing" : list.join(", ")
-  return [
-    ...(access.read === null ? [] : [`- This turn may read only: ${globs(access.read)}`]),
-    ...(access.write === null
-      ? []
-      : [
-          `- This turn may write only: ${globs(access.write)} — anything else is refused when the turn lands`,
-        ]),
-  ].join("\n")
-}
-
-export const styleBlock = `- A deliverable, not a chat reply — size follows the work; cut padding
-- Lead with the answer; never circle back to restate it
-- Flat, commanding sentences — commit to the claim, never hedge
-- Everyday words; define an unavoidable term in five words or fewer, on
-  first use
-- Bold carries the load: bold the claim, not the sentence around it —
-  the bold text alone must yield the full point and every risk
-- **Never trim a risk, a number, a threshold, or a scoped condition to
-  save space — this outranks every other rule here**
-- Ship the artifact bare — no lead-in, no sign-off
-- Compressing is not dropping: three load-bearing parts ship as three,
-  each shorter, never as two
-- One idea per block; break when the idea shifts
-- Flag risk in one blunt line, never hedged prose; never narrate — do it`
-
-export const styleFormatContract = `- Machine-read: its format contract outranks every style rule above —
-  keep every \`##\`/\`###\` heading, checkbox row, and marker line exactly
-  as specified. Never renumber or rename a heading; a parser reads
-  these literally and a violation refuses the turn
-- Voice rules above govern only the prose between these elements`
-
-export const agentConduct = `- You have shell and file tools — bash, read, write, edit — use them
-  without asking first; this runs unattended, no one grants permission
-- Investigate with real commands rather than assuming a file's, a
-  commit's, or a decision's status — then act on what you find
-- No injected status block — no cwd, no branch, no history, no tree
-  state — orient yourself first with \`git status\`, \`git log\`, \`ls\`
-- The turn's message names a commit, a range, or a file to go inspect
-  yourself — never a diff or summary inlined into the conversation
-- Across turns one conversation may span, work from what you already
-  read and settled, unless told this is a fresh, cold pass
-- Your turn ends when you return, and nothing you leave running survives
-  it in any useful way — never detach or background work you intend to
-  act on, never end a turn planning to "check back": no later turn
-  inherits your intent. Run it in the foreground and wait, however long
-  it takes. If it genuinely cannot finish inside one turn, write down
-  where it stands and what to resume, so the tree carries the state`
-
-export const designPersona = `You are the product-facing planning voice in gtd's build pipeline: turn
-a raw sketch — a hand-edit, a scratch note, or both — into an ordered,
-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 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
-chunks; classify a round of the human's feedback as actionable or
-just approving; answer the human's questions inline in the review;
-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 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 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
-before it closes. Fix a late-breaking failing check after sign-off,
-focused and minimal. Every turn lands its own commit — nothing here
-gets squashed away.`
-
-export const escalationPersona = `You are the diagnosing voice in gtd's build pipeline, called in once a
-check has stayed red past repeated fix attempts. Read the failing
-output, the previous round's, and the code those attempts touched, then
-write down what is failing, why the earlier attempts didn't resolve it,
-and concrete approaches worth trying next. Never fix the code yourself —
-naming the problem precisely enough for the next fix turn is the whole
-job.`
-
-export const stateFileRules = `- You are an autonomous coding agent
-- This workflow's own state files are its private scratchpad, never
-  project code or documentation`
-
-export const questionBar = `- The goal is shared understanding, not a quota or an empty section: a
-  question exists to close a gap between what the human wants and
-  what the agent is about to build. Ask whenever that gap is open —
-  even when the point looks cheap to undo, settled-looking, or
-  narrow. This goal outranks what follows; the conditions below are
-  signals a gap is real, strong evidence to ask, never permission
-  withheld
-- Before writing \`## Open Questions\`, walk every concern you grouped and
-  collect every point above the bar into that ONE section — a question
-  held back for a later lap is a bug. One lap is the target; a second is
-  the exception
-- Raise first, narrow second: only once every concern above the bar is
-  raised into \`## Open Questions\`, walk that same set once more and
-  answer the ones a confident default settles, moving each into
-  \`## Answered Questions\` with its answer. This pass narrows what's
-  already raised — it is never license to raise less, and skipping the
-  raise to answer straight through is the same bug as holding a
-  question back for a later lap
-- Treat each of these as strong evidence a gap is real: it's a genuine
-  fork with divergent outcomes (user-visible for product, materially
-  different builds for technical); the diff and history don't already
-  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
-  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>\`
-  plus a one-line rationale in prose, no checkboxes. That heading
-  always comes last, after every other \`##\` section
-- Above the bar, write it under \`## Open Questions\` — always the first
-  \`##\` section — as \`### <question>\` plus a body plus a checkbox list.
-  The count of concrete options is your call, taken from how many
-  genuinely distinct answers the fork has — never padded to a fixed
-  number. A floor still applies: at least two real options plus the
-  free-text slot, or the question is not a fork
-- The heading is followed by one or two lines of body naming the fork
-  and what actually differs, THEN the option list. The body frames the
-  fork; each option's own content carries that option's impacts — they
-  never repeat each other. A body that lists the options back is
-  padding, and an option line that restates the fork is padding too
-- Each option is one short line plus its own impacts nested under it as
-  a bullet list: one to four bullets, free-form — what it costs, what
-  it buys, how it differs from the others. Write the dimensions this
-  fork actually has and skip the ones it does not; no \`Costs:\`/\`Buys:\`/
-  \`Differs:\` labels, no fixed bullet count. The free-text slot is last,
-  mandatory, identified by position rather than by label:
-
-      ### <the question>
-
-      <one or two lines: what the fork is, what actually differs>
-
-      - [ ] <first option — a short line>
-        - <impact>
-        - <impact>
-      - [ ] <second option — a short line>
-        - <impact>
-      - [ ] <third option — a short line>
-        - <impact>
-        - <impact>
-        - <impact>
-      - [ ] _your answer_
-
-- Never tick a box yourself — the human ticks exactly one per question`
-
-export const questionBarReturn = `- This lap continues the same goal as the first: close the gap
-  between what the human wants and what gets built. Folding in
-  answers and deciding what's left is that same goal continued, not
-  a different job
-- The human answered — a ticked box, a free-text answer in place of
-  \`_your answer_\`, a deleted question, or a deleted \`## Open Questions\`
-  section are all answers. Fold each resolved answer into its concern's
-  prose, then move the question into \`## Answered Questions\` as
-  \`### <question>\` with the resolved answer in plain prose — no
-  checkboxes
-- \`## Answered Questions\` is always the last \`##\` section — a moved
-  question lands there, never wherever \`## Open Questions\` used to sit
-- Never re-raise a deleted question. A settled \`## Answered Questions\`
-  entry stays settled, except one carrying a human footnote on its
-  \`### \` heading: that is the only entry that may change. Fold the note
-  in, then either rewrite the recorded answer in place (still under
-  \`## Answered Questions\`) or, when the note leaves the point genuinely
-  open, move it back to \`## Open Questions\` as a fresh fork with
-  options and the \`_your answer_\` slot. A note that only asks a
-  question follows the footnote rule: one \`- A:\` reply, answer unchanged
-- An answer may earn a follow-up: if it opens a genuinely new fork above
-  the bar — one the answer itself created — raise it as a fresh \`##
-  Open Questions\` entry on this same lap. Never restate a question
-  already asked, and never treat this as licence to re-open a question
-  already settled under \`## Answered Questions\` that carries no
-  footnote on its heading
-- Recognise a silent lap from \`## Open Questions\` still present with
-  nothing ticked and nothing else changed — the human's way of saying
-  the gap is already closed. That lap ends the questions, whatever the
-  goal says: decide every remaining question yourself, move each to
-  \`## Answered Questions\` with a one-line rationale, raise nothing new,
-  and leave no \`## Open Questions\` section behind`
-
-export const fixFeedbackPrompt = `- The only state file this turn writes is \`.gtd/FEEDBACK.md\` — no other
-  files for notes or output
-- Read \`.gtd/FEEDBACK.md\` (the failing test output) and fix the code so
-  the suite passes
-- When \`.gtd/ESCALATION.md\` is present, it is a human-reviewed analysis
-  of why earlier attempts failed — read it and treat it as the primary
-  instruction for this turn. Never edit or delete it yourself, even once
-  you believe you've resolved it: only a genuinely green check retires
-  it, so an attempt that turns out to be wrong still leaves the next
-  turn's instruction in place. Its absence is the ordinary case: an
-  unremarkable red round with nothing to escalate yet
-- Delete \`.gtd/FEEDBACK.md\` either way — once the suite passes, or once
-  you have established the feedback was wrong; leaving it in place is
-  never the right end state, the next check writes its own`
-
-export const footnoteRules = `- Leave a footnote anywhere: mark the exact spot with \`[^name]\` (any
-  name, no whitespace or \`]\`), then define it below as \`[^name]:
-  explain what you mean\` — indent continuation lines by 4 spaces or
-  more. (A newly seeded definition starts with an empty body — a
-  definition whose body is still empty or whitespace-only is flagged
-  as unfilled, so write your own words there; words left under-indented
-  are flagged separately, naming the indent as the fix)
-- A footnote is a comment on that exact spot — the hunk, line, or
-  paragraph it marks — never a whole-file remark
-- \`name\` is yours to pick; only a definition's name must be unique in
-  this document — the same name may mark more than one spot
-- To start a conversation, open the definition with a list: \`[^name]:\`
-  then an indented \`- H: <your question>\`. The agent answers with
-  \`- A: <reply>\`. Reply with a new \`- H:\` entry to continue; to
-  close the thread, reply with a conclusion (the agent folds it in and
-  deletes the thread) or delete the thread yourself. Entries alternate
-  \`H:\`/\`A:\` and the agent never starts a thread
-- While a thread's last entry is the agent's, it is open and moving on
-  is refused: reply with a conclusion, or delete it
-- The same conversation works as \`// H: <question>\` comment lines in a
-  file changed in this process (\`#\`, \`--\` or \`;\` by language); the phone UI does not show them,
-  and \`gtd check --open-threads\` lists the open ones`
-
-export const footnoteAnchor = `- A footnote (\`[^name]\` plus its \`[^name]:\` definition) is a comment on
-  its exact anchor — fold it in as a mandatory concern described
-  against that anchor's hunk or paragraph, never flattened into a
-  whole-file remark
-`
-
-export const footnoteFoldIn = `${footnoteAnchor}- A one-shot footnote needs no reply: fold it in and DELETE it in this
-  same turn — marker and definition together. Never re-read a footnote
-  already acted on. A one-shot footnote that asks a question becomes a
-  thread instead: rewrite its definition as \`- H: <its body>\` then
-  \`- A: <your reply>\`, keeping the marker
-- A thread is a definition whose body is a list of \`- H:\`/\`- A:\`
-  entries. Handle each by its last entry:
-  - last is \`- H:\` and asks something — reply with exactly one
-    \`- A: <reply>\` entry and change nothing else for it
-  - last concludes or advises — fold it in like a one-shot footnote,
-    then delete marker and definition
-  - last is \`- A:\` — it waits on the human; leave it alone
-- Never start a thread yourself, and never leave a thread whose last
-  entry is \`- H:\` — a turn that does is refused`

package/src/workflows/shared/recheck.feature

@@ -1,60 +0,0 @@
-@inmem
-Feature: a red check is re-run once before it reaches a person
-
-  Before the fix loop escalates, `healthy` re-runs the suite as
-  `health.recheck`. Green there ends the loop as if the check had passed, and
-  the re-check's landing records `Gtd-Mark: flaky=health.check`. Red again
-  escalates as before.
-
-  Background:
-    Given a gtd config with:
-      """
-      import { healthy } from "@pmelab/gtd/workflows"
-      import { agent, human } from "@pmelab/gtd/flows"
-
-      export const held = async () => {
-        await agent("first", "go")
-        await healthy(() => agent("fix", "go"))
-        await human("done")
-      }
-      export default held
-      """
-    And step "first" writes "src/a.ts" with:
-      """
-      export const a = 1
-      """
-    And step "health.check" writes ".gtd/FEEDBACK.md" with:
-      """
-      1 test failing
-      """
-    And step "fix" deletes ".gtd/FEEDBACK.md"
-    And judge step "health.judge" answers:
-      """
-      [{"id":"verdict","answer":"progress","p":0.9}]
-      """
-
-  Scenario: a re-check that passes ends the loop without a person, recorded as flaky
-    Given step "health.recheck" deletes ".gtd/FEEDBACK.md"
-    When gtd starts workflow "held"
-    And the process is driven
-    Then the process rests at "done"
-    And the commit subjects end with:
-      """
-      gtd(agent): fix → health.check
-      gtd(check): health.check → health.judge
-      gtd(judge): health.judge → health.recheck
-      gtd(check): health.recheck → done
-      """
-    And the last commit body contains "Gtd-Mark: flaky=health.check"
-    And ".gtd/FEEDBACK.md" does not exist
-
-  Scenario: a re-check that stays red escalates, with nothing recorded as flaky
-    Given step "health.recheck" writes ".gtd/FEEDBACK.md" with:
-      """
-      1 test still failing
-      """
-    When gtd starts workflow "held"
-    And the process is driven
-    Then the process rests at "health.describe"
-    And the last commit subject is "gtd(check): health.recheck → health.describe"
-    And no commit body contains "Gtd-Mark: flaky="