From cedef97c99905e2156ece05e21084675b20110b2 Mon Sep 17 00:00:00 2001 From: Frank Date: Sun, 18 Oct 2026 18:58:23 -0700 Subject: [PATCH 1/6] feat(grilling): omp-aware interview redesign, absorb ask-etiquette law Rewritten per grilling-on-grilling (2026-10-18, all branches settled via ask rounds): ask tool is the default round vehicle (one artefact per question, recommended:0 = bare-yes semantics, hybrid boundary ask-default / prose-exception); todo as visible decision tree (phase=branch, blocked reasons) + durable local://grilling-state.md ledger surviving the Esc-aborts-the-run path; scout=environment facts (spawn-before-ask, exclusive concurrency), web_search=world facts, inline=cheap lookups; completion gate = summary + one closing ask, then distilled decisions land in omp-docs/log.md via branch -> PR. Absorbs managed skill one-decision-per-ask-question (Frank's choice; reworded: ideas heavily encouraged via own atomic question, ban is on smuggling into option text only). Managed skill deleted here; heartbeat drops it from the live tree. --- .../one-decision-per-ask-question/SKILL.md | 27 ------------- agent/skills/grilling/SKILL.md | 38 ++++++++++++------- 2 files changed, 24 insertions(+), 41 deletions(-) delete mode 100644 agent/managed-skills/one-decision-per-ask-question/SKILL.md diff --git a/agent/managed-skills/one-decision-per-ask-question/SKILL.md b/agent/managed-skills/one-decision-per-ask-question/SKILL.md deleted file mode 100644 index abc17d2..0000000 --- a/agent/managed-skills/one-decision-per-ask-question/SKILL.md +++ /dev/null @@ -1,27 +0,0 @@ ---- -name: one-decision-per-ask-question -description: "Use when putting decisions to Frank via the ask tool or a grilling round — exactly one work item per question, rounds may group many single-item questions." ---- - -# One Decision, One Work Item, One Question - -Friction-earned rule (corrected twice on 2026-10-18, during the voice/TTS planning). - -## Rules - -- Each question addresses **exactly one work item**. A round may contain many questions covering different work items; a question may not. -- Never merge two artefacts into one option because they share an implementation dependency. Sharing an endpoint, a service, or a build step is NOT grounds for one question. (`frank-tts` serving both a podcast and an audiobook generator produced exactly this bug.) -- Never offer something Frank did not ask for inside another question's option text. If an idea is mine, it gets its own question or stays out of the plan; it never rides along as "…and also X" in an option label or preview. -- Do not derive option wording from my own scaffolding (todo text, my table row labels, my runbook headings). Derive it from his stated goal. -- Mark the recommended option; a bare "yes" must accept it. -- Facts are mine to fetch (subagent/scout), never a question for him. Only decisions go to him. -- A question whose answer depends on an unsettled fact or another open question belongs to a **later round**, not this one. - -## Anti-patterns that triggered this - -- One option: "Audiobook/podcast factory — open-notebook + EPUB→narration builder." Two products, one shared dependency, zero requests for the second one. He answered "I never asked for audiobook generation." -- One question: "Is the deliverable the podcast, or the platform (harness voice + OpenWebUI + alerts)?" Four work items in one question. Rejected: "You're lumping multiple asks into one question. Ask me per item." - -## Check before sending - -For each question: can I name the single artefact it decides? If two names come to mind, split it. diff --git a/agent/skills/grilling/SKILL.md b/agent/skills/grilling/SKILL.md index 6696902..4b06c12 100644 --- a/agent/skills/grilling/SKILL.md +++ b/agent/skills/grilling/SKILL.md @@ -3,30 +3,40 @@ name: grilling description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases. --- -> **Authored override.** Extracted 2026-10-18 from `mattpocock/skills` (identical to upstream at extraction) into the command-center repo so Frank can customize it. Removed from the `skills` CLI global store (`~/.agents/.skill-lock.json` pruned) so `skills update -g` never resurrects a duplicate. Edits to this file are repo prose: branch → PR → Frank OK. +> **Authored override.** Extracted 2026-10-18 from `mattpocock/skills` (identical to upstream at extraction) into the command-center repo so Frank can customize it. Removed from the `skills` CLI global store (`~/.agents/.skill-lock.json` pruned) so `skills update -g` never resurrects a duplicate. omp-aware redesign same day; absorbed the `one-decision-per-ask-question` managed skill. Edits to this file are repo prose: branch → PR → Frank OK. Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it. -Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled: the questions you can ask _now_ without guessing at answers you haven't heard yet. Ask the whole frontier in one round: number each question and give your recommended answer. Then wait for the user's answers before the next round. +Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled. A question whose answer depends on an unsettled fact or another open question belongs to a _later_ round, not this one. Ask the whole frontier in one round, then wait. -Format a round like so: +## The round: `ask` is the default vehicle -``` -❓ **Q1** - ****: +Every frontier decision that fits 2–5 options goes through the `ask` tool - one question per decision, `recommended: 0` (the recommended answer is always option 0; the user's single Enter is the bare "yes" that accepts it). Prose in chat is the exception, reserved for genuinely open narrative ("walk me through the deploy flow") - never as buttons. -➡️ +Per-question discipline (absorbed law, was the `one-decision-per-ask-question` managed skill): ---- +- One question decides exactly **one artefact**. Name it before sending; two names → split. A round may carry many single-artefact questions; a question may not. +- Shared plumbing is not grounds for merging: two products sharing an endpoint, service, or build step are still two questions. +- Ideas are **heavily encouraged** - the interviewer's own idea gets its own atomic question like any other. What is banned is smuggling an unasked-for artefact into another question's option text ("...and also X" in a label or preview). +- Option wording derives from the user's stated goal, never from your scaffolding (todo text, table rows, runbook headings). +- `multi: true` for pick-many; `preview` for code/config evidence (renders as markdown); `header` for the branch chip. -❓ **Q2** - ****: +Fallback: a harness without `ask` degrades to the classic text round - `❓ **Q1** - **title**: body` / `➡️ recommendation`, worded so a bare "yes" accepts every recommendation. -➡️ -``` +Dialog mechanics you must respect: `ask` is exclusive - spawn scouts **before** the `ask` call in the same message or they stall behind the dialog. The dialog cannot be interrupted by arriving facts; results land between rounds. Esc **aborts the whole run** with no post-cancel turn - the durable ledger is the safety net. Questions are spoken aloud when speech is enabled. -Word each question so "yes" accepts your recommended answer. +## The ledger: `todo` is the tree, `local://` is the save-file -Each round the user answers reshapes the tree: settled decisions push the frontier outward and unblock questions that depended on them. Recompute the frontier and ask the next round. A question whose answer depends on another question still open in this round belongs to a _later_ round, not this one. +- `todo`: **phase = design-tree branch**, task text = the decision (`" - via: "` carries the edge; todo has no edges). `pending` = frontier, `block` with a one-line reason = waiting on a fact or an open decision (the HUD stays visible while anything is blocked), `done` = settled. `unblock` the moment its prerequisite settles. +- `write local://grilling-state.md` at the end of **every round**: the tree with each decision's verdict + one-line rationale. This is the only thing that survives an Esc-abort - keep it current. -Finding _facts_ is your job, never the user's. When a frontier question needs a fact from the environment (filesystem, tools, etc.), dispatch a sub-agent to find it; don't ask the user for anything you could look up yourself. Don't block on it: a running exploration is an unsettled prerequisite, so only the questions downstream of it wait for the sub-agent to report; ask the rest of the frontier now. The _decisions_ are the user's: put each to them and wait. +## Facts are yours; decisions are the user's -The session is done when the frontier is empty: every branch of the design tree visited, nothing left silently assumed. Do not act on it until the user confirms you have reached a shared understanding. +- Environment facts (filesystem, repo, live config): `task` + `scout`, one batch, one scout per fact-cluster; on this box at most 3 run at once, so cluster rather than spray. +- Outside-world facts: call `web_search` directly - no spawn hop. +- Cheap lookups: `read`/`grep` inline. +- Only the main session may ask; every spawn carries the exact facts to return. + +## Completion + +Frontier empty and nothing blocked → write the settled-decisions summary from the ledger, then **one closing `ask`**: "Shared understanding reached - proceed?" Nothing executes before that yes. After it: distill the settled decisions into an `omp-docs/log.md` work-log entry through the normal branch → PR path, and refresh the ledger file to final form. -- 2.54.0 From fe039a0b730708939b131101879d64c7b084502f Mon Sep 17 00:00:00 2001 From: Frank Date: Sun, 18 Oct 2026 19:09:04 -0700 Subject: [PATCH 2/6] fix(grilling): strip history and box-specific prose per review (Refs #20) - drop provenance blockquote and the absorbed-law attribution: the skill is instructions, not a history - 'concurrency is capped' replaces the 3-scout figure of one machine - completion distillate: project's knowledge base or a log markdown file, not a command-center-specific path (skill travels outside this repo) --- agent/skills/grilling/SKILL.md | 10 +++------- 1 file changed, 3 insertions(+), 7 deletions(-) diff --git a/agent/skills/grilling/SKILL.md b/agent/skills/grilling/SKILL.md index 4b06c12..e901c22 100644 --- a/agent/skills/grilling/SKILL.md +++ b/agent/skills/grilling/SKILL.md @@ -3,17 +3,13 @@ name: grilling description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases. --- -> **Authored override.** Extracted 2026-10-18 from `mattpocock/skills` (identical to upstream at extraction) into the command-center repo so Frank can customize it. Removed from the `skills` CLI global store (`~/.agents/.skill-lock.json` pruned) so `skills update -g` never resurrects a duplicate. omp-aware redesign same day; absorbed the `one-decision-per-ask-question` managed skill. Edits to this file are repo prose: branch → PR → Frank OK. - Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it. Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled. A question whose answer depends on an unsettled fact or another open question belongs to a _later_ round, not this one. Ask the whole frontier in one round, then wait. ## The round: `ask` is the default vehicle -Every frontier decision that fits 2–5 options goes through the `ask` tool - one question per decision, `recommended: 0` (the recommended answer is always option 0; the user's single Enter is the bare "yes" that accepts it). Prose in chat is the exception, reserved for genuinely open narrative ("walk me through the deploy flow") - never as buttons. - -Per-question discipline (absorbed law, was the `one-decision-per-ask-question` managed skill): +Per-question discipline: - One question decides exactly **one artefact**. Name it before sending; two names → split. A round may carry many single-artefact questions; a question may not. - Shared plumbing is not grounds for merging: two products sharing an endpoint, service, or build step are still two questions. @@ -32,11 +28,11 @@ Dialog mechanics you must respect: `ask` is exclusive - spawn scouts **before** ## Facts are yours; decisions are the user's -- Environment facts (filesystem, repo, live config): `task` + `scout`, one batch, one scout per fact-cluster; on this box at most 3 run at once, so cluster rather than spray. +- Environment facts (filesystem, repo, live config): `task` + `scout`, one batch, one scout per fact-cluster; concurrency is capped, so cluster rather than spray. - Outside-world facts: call `web_search` directly - no spawn hop. - Cheap lookups: `read`/`grep` inline. - Only the main session may ask; every spawn carries the exact facts to return. ## Completion -Frontier empty and nothing blocked → write the settled-decisions summary from the ledger, then **one closing `ask`**: "Shared understanding reached - proceed?" Nothing executes before that yes. After it: distill the settled decisions into an `omp-docs/log.md` work-log entry through the normal branch → PR path, and refresh the ledger file to final form. +Frontier empty and nothing blocked → write the settled-decisions summary from the ledger, then **one closing `ask`**: "Shared understanding reached - proceed?" Nothing executes before that yes. After it: distill the settled decisions into the project's knowledge base, or a log markdown file, and refresh the ledger file to final form. -- 2.54.0 From 3fa0242f564b30faae1a653f15d26a4ebfb34af2 Mon Sep 17 00:00:00 2001 From: Frank Date: Sun, 18 Oct 2026 19:15:14 -0700 Subject: [PATCH 3/6] style(grilling): rewrite in the mattpocock corpus voice (Refs #20) Read all 36 upstream skills, then rewrote to their house style per writing-for-agents' own levers: leading words as tokens (frontier, brief, ledger, artefact, scout), vocabulary-first and used exactly, positive phrasing with prohibitions kept only as hard guardrails, completion criteria sharpened to checkable+exhaustive ('counted before sending', 'frontier empty and nothing sits blocked'), zero history, gotchas the environment cannot confess kept inline. All settled behaviour from the grilling-on-grilling session survives intact. --- agent/skills/grilling/SKILL.md | 48 ++++++++++++++++++++-------------- 1 file changed, 28 insertions(+), 20 deletions(-) diff --git a/agent/skills/grilling/SKILL.md b/agent/skills/grilling/SKILL.md index e901c22..ce7d4cd 100644 --- a/agent/skills/grilling/SKILL.md +++ b/agent/skills/grilling/SKILL.md @@ -3,36 +3,44 @@ name: grilling description: Grill the user relentlessly about a plan, decision, or idea. Use when the user wants to stress-test their thinking, or uses any 'grill' trigger phrases. --- -Interview the user relentlessly until you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it. +# Grilling -Work the tree in **rounds**. The **frontier** is every decision whose prerequisites are already settled. A question whose answer depends on an unsettled fact or another open question belongs to a _later_ round, not this one. Ask the whole frontier in one round, then wait. +Interview the user relentlessly until nothing is silently assumed. The subject is a **design tree**: every decision branches into the decisions that hang off it. -## The round: `ask` is the default vehicle +A decision is **frontier** when it can be asked now, without an answer you haven't heard yet. The interview is done when the frontier is empty: every branch of the tree visited. -Per-question discipline: +## Rounds -- One question decides exactly **one artefact**. Name it before sending; two names → split. A round may carry many single-artefact questions; a question may not. -- Shared plumbing is not grounds for merging: two products sharing an endpoint, service, or build step are still two questions. -- Ideas are **heavily encouraged** - the interviewer's own idea gets its own atomic question like any other. What is banned is smuggling an unasked-for artefact into another question's option text ("...and also X" in a label or preview). -- Option wording derives from the user's stated goal, never from your scaffolding (todo text, table rows, runbook headings). -- `multi: true` for pick-many; `preview` for code/config evidence (renders as markdown); `header` for the branch chip. +Work the tree in **rounds**: ask the whole frontier at once, then wait. A decision whose answer hangs on an open question or an unfetched fact joins a later round. -Fallback: a harness without `ask` degrades to the classic text round - `❓ **Q1** - **title**: body` / `➡️ recommendation`, worded so a bare "yes" accepts every recommendation. +Ask each closed decision - anything expressible as 2–5 options - through the `ask` tool: -Dialog mechanics you must respect: `ask` is exclusive - spawn scouts **before** the `ask` call in the same message or they stall behind the dialog. The dialog cannot be interrupted by arriving facts; results land between rounds. Esc **aborts the whole run** with no post-cancel turn - the durable ledger is the safety net. Questions are spoken aloud when speech is enabled. +- **One artefact per question**, counted before sending. Name the artefact each question decides; two names means two questions. Shared plumbing (an endpoint, a service, a build step) still leaves two artefacts. +- Recommended answer first, marked `recommended: 0`: the user's single Enter accepts it. +- Options quote the user's goal. Their words, their stated goal, ground the wording; your todo text and table rows stay out of it. +- Your own idea is welcome: it gets its own recommended question. Attach it to its own question, so it rides there on its merits. +- `multi: true` for pick-many, `header` for the branch chip, `preview` when the decision needs code or config in front of the user. -## The ledger: `todo` is the tree, `local://` is the save-file +Open narrative - "walk me through the deploy flow" - has no options to offer; ask it as prose in chat. Without an `ask` tool the whole round degrades to text: `❓ **Q1 — title**: body`, then `➡️ recommendation`, phrased so one bare "yes" accepts every recommendation. -- `todo`: **phase = design-tree branch**, task text = the decision (`" - via: "` carries the edge; todo has no edges). `pending` = frontier, `block` with a one-line reason = waiting on a fact or an open decision (the HUD stays visible while anything is blocked), `done` = settled. `unblock` the moment its prerequisite settles. -- `write local://grilling-state.md` at the end of **every round**: the tree with each decision's verdict + one-line rationale. This is the only thing that survives an Esc-abort - keep it current. +Dialog mechanics, the gotchas no doc confesses: the dialog is exclusive, so dispatch scouts before the `ask` call in the same message and expect their results between rounds. Esc cancels the whole run with no closing turn; the ledger below is what survives it. -## Facts are yours; decisions are the user's +## The ledger -- Environment facts (filesystem, repo, live config): `task` + `scout`, one batch, one scout per fact-cluster; concurrency is capped, so cluster rather than spray. -- Outside-world facts: call `web_search` directly - no spawn hop. +The tree lives in the `todo` list while the interview runs, so the user watches it fall: + +- One task per decision, filed under the phase for its branch; `via: ` in the task text carries the edge. +- `pending` is the frontier; `block` with a one-line reason waits on a fact or an open decision; `done` is settled. Unblock the moment the dependency settles. + +Write `local://grilling-state.md` at the end of every round: the tree, each decision's verdict and one-line rationale. It is the durable copy of the interview; keep it current so an Esc costs one round. + +## Facts are yours, decisions are theirs + +- Environment facts (filesystem, repo, live config): dispatch a **scout** per fact-cluster, batched into one `task` call, before the round's `ask`. Cluster tightly; spawns are the expensive route. +- Outside-world facts: call `web_search` directly. - Cheap lookups: `read`/`grep` inline. -- Only the main session may ask; every spawn carries the exact facts to return. +- The main session is where questions happen: every spawn carries the exact facts to return, and comes back into the next round. -## Completion +## Done -Frontier empty and nothing blocked → write the settled-decisions summary from the ledger, then **one closing `ask`**: "Shared understanding reached - proceed?" Nothing executes before that yes. After it: distill the settled decisions into the project's knowledge base, or a log markdown file, and refresh the ledger file to final form. +The frontier is empty and nothing sits blocked. Distil the ledger into a **brief**: one line per decision, verdict plus rationale, grouped by branch. Put it in chat, then one closing `ask`: "Proceed on this brief?" Nothing executes before that yes. After it, fold the brief into the project's knowledge base, or a log markdown file, wherever the project keeps its decisions. -- 2.54.0 From ca8b46241eb6c6e94aa5090c45cde91d378a8b2f Mon Sep 17 00:00:00 2001 From: Frank Date: Sun, 18 Oct 2026 19:24:51 -0700 Subject: [PATCH 4/6] fix(grilling): round-two review notes (Refs #20) - opening restores 'shared understanding' alongside 'nothing is silently assumed', and 'Map this as a design tree' - cluster rationale restated: tight clusters keep each scout aware of possible adjacencies - web_search: explicit 'do not delegate to a subagent' - 'Done' heading -> 'Definition of Done' --- agent/skills/grilling/SKILL.md | 8 ++++---- 1 file changed, 4 insertions(+), 4 deletions(-) diff --git a/agent/skills/grilling/SKILL.md b/agent/skills/grilling/SKILL.md index ce7d4cd..fb0a9a6 100644 --- a/agent/skills/grilling/SKILL.md +++ b/agent/skills/grilling/SKILL.md @@ -5,7 +5,7 @@ description: Grill the user relentlessly about a plan, decision, or idea. Use wh # Grilling -Interview the user relentlessly until nothing is silently assumed. The subject is a **design tree**: every decision branches into the decisions that hang off it. +Interview the user relentlessly until nothing is silently assumed and you reach a shared understanding. Map this as a **design tree**: every decision branches into the decisions that hang off it. A decision is **frontier** when it can be asked now, without an answer you haven't heard yet. The interview is done when the frontier is empty: every branch of the tree visited. @@ -36,11 +36,11 @@ Write `local://grilling-state.md` at the end of every round: the tree, each deci ## Facts are yours, decisions are theirs -- Environment facts (filesystem, repo, live config): dispatch a **scout** per fact-cluster, batched into one `task` call, before the round's `ask`. Cluster tightly; spawns are the expensive route. -- Outside-world facts: call `web_search` directly. +- Environment facts (filesystem, repo, live config): dispatch a **scout** per fact-cluster, batched into one `task` call, before the round's `ask`. Cluster tightly; doing so keeps each scout more aware of possible adjacencies. +- Outside-world facts: call `web_search` directly, do not delegate to a subagent. - Cheap lookups: `read`/`grep` inline. - The main session is where questions happen: every spawn carries the exact facts to return, and comes back into the next round. -## Done +## Definition of Done The frontier is empty and nothing sits blocked. Distil the ledger into a **brief**: one line per decision, verdict plus rationale, grouped by branch. Put it in chat, then one closing `ask`: "Proceed on this brief?" Nothing executes before that yes. After it, fold the brief into the project's knowledge base, or a log markdown file, wherever the project keeps its decisions. -- 2.54.0 From c379d168582c672bf453cc54d1438525db8758f1 Mon Sep 17 00:00:00 2001 From: Frank Date: Sun, 18 Oct 2026 19:25:44 -0700 Subject: [PATCH 5/6] fix(grilling): correct ask-tool acceptance semantics (Refs #20) The ask tool's recommended flag only labels option 0; the reply always names the selected options, so 'the user's single Enter accepts it' overclaimed a default-accept mechanic that does not exist. Stated truthfully: the label invites one-glance acceptance, the reply is self-documenting. --- agent/skills/grilling/SKILL.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/agent/skills/grilling/SKILL.md b/agent/skills/grilling/SKILL.md index fb0a9a6..5b3122e 100644 --- a/agent/skills/grilling/SKILL.md +++ b/agent/skills/grilling/SKILL.md @@ -16,7 +16,7 @@ Work the tree in **rounds**: ask the whole frontier at once, then wait. A decisi Ask each closed decision - anything expressible as 2–5 options - through the `ask` tool: - **One artefact per question**, counted before sending. Name the artefact each question decides; two names means two questions. Shared plumbing (an endpoint, a service, a build step) still leaves two artefacts. -- Recommended answer first, marked `recommended: 0`: the user's single Enter accepts it. +- Recommended answer first, marked `recommended: 0`, which labels it "(Recommended)" for one-glance acceptance. Every reply names what was picked, so the record is unambiguous. - Options quote the user's goal. Their words, their stated goal, ground the wording; your todo text and table rows stay out of it. - Your own idea is welcome: it gets its own recommended question. Attach it to its own question, so it rides there on its merits. - `multi: true` for pick-many, `header` for the branch chip, `preview` when the decision needs code or config in front of the user. -- 2.54.0 From 6134e1168e68ac83443972be469703a4ef7e5fc2 Mon Sep 17 00:00:00 2001 From: Frank Date: Sun, 18 Oct 2026 19:31:32 -0700 Subject: [PATCH 6/6] fix(grilling): plain-mechanics rephrase of the dialog line (Refs #20) 'Too Claudish': drop the aside ('the gotchas no doc confesses') and the simile ('watches it fall'); lead with the constraint itself. Facts unchanged: exclusive dialog, scouts before ask, Esc ends the run, the ledger survives. --- agent/skills/grilling/SKILL.md | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/agent/skills/grilling/SKILL.md b/agent/skills/grilling/SKILL.md index 5b3122e..9319d6d 100644 --- a/agent/skills/grilling/SKILL.md +++ b/agent/skills/grilling/SKILL.md @@ -23,7 +23,7 @@ Ask each closed decision - anything expressible as 2–5 options - through the ` Open narrative - "walk me through the deploy flow" - has no options to offer; ask it as prose in chat. Without an `ask` tool the whole round degrades to text: `❓ **Q1 — title**: body`, then `➡️ recommendation`, phrased so one bare "yes" accepts every recommendation. -Dialog mechanics, the gotchas no doc confesses: the dialog is exclusive, so dispatch scouts before the `ask` call in the same message and expect their results between rounds. Esc cancels the whole run with no closing turn; the ledger below is what survives it. +The dialog is exclusive: dispatch scouts before the `ask` call in the same message, or they wait behind it; their results land between rounds. Esc ends the run outright, with no turn to wrap up, so the ledger is what survives it. ## The ledger -- 2.54.0