do-better 1.0.0

package/do-better/references/scoring.md

@@ -0,0 +1,98 @@
+# Roadmap Scoring & Sequencing — D3 Rubric
+
+The frontier model **proposes** per-finding attributes; deterministic code
+**computes** scores and order. Judgment supplies inputs; arithmetic is never
+delegated to a model.
+
+## Per-finding attributes (frontier proposes)
+
+For every verified finding, the model assigns:
+
+| Attribute | Values | Meaning |
+|---|---|---|
+| `impact` | S / M / L / XL | how much better the system gets if addressed |
+| `effort` | S / M / L / XL | cost to address, including verification |
+| `confidence` | 0..1 | how sure we are the fix delivers the impact |
+| `dependsOn` | finding ids | what must land first |
+| `railsNeeded` | true/false | whether characterization rails must exist before touching it |
+| `declineReason` | string (optional) | why this should NOT be done (conflicts with charter intent/constraints) |
+
+Reconciliation is **by id**: findings the model omits get conservative defaults
+`impact: M, effort: M, confidence: 0.5` — never dropped. Nothing silently
+disappears between findings and roadmap.
+
+## T-shirt tables
+
+| Size | Impact value | Effort value |
+|---|---|---|
+| S | 1 | 1 |
+| M | 2 | 2 |
+| L | 3 | 3 |
+| XL | 5 | 5 |
+
+## The score
+
+```
+score = impact × confidence ÷ effort
+```
+
+then weighted by the approved charter (D0):
+
+```
+weighted = score × (charterWeight[dimension] / 3)
+```
+
+A weight of 3 is neutral; the floor guarantees every dimension has weight ≥ 1,
+so no dimension can be zeroed out of the roadmap — only de-emphasized.
+
+Worked example: a `high` security finding, impact L (3), confidence 0.8,
+effort M (2), security charter weight 5:
+`3 × 0.8 ÷ 2 = 1.2`, weighted `1.2 × (5/3) = 2.0`.
+
+## Thresholds (deterministic)
+
+| Rule | Threshold |
+|---|---|
+| Quick win (front-loaded into Now) | weighted score ≥ 1.5 AND effort = S |
+| Declined (listed, never silently dropped) | weighted score < 0.3, or explicit `declineReason` |
+| Phase bands | Now / Next / Later by descending score, subject to dependency feasibility |
+
+## Sequencing rules (deterministic)
+
+1. **Topological order** on `dependsOn` — an item never appears before its
+   prerequisites.
+2. **Rails-first Phase 0**: environment-fix items (preflight red → "make it
+   runnable") and rail-prerequisite items (`railsNeeded` ancestors) come before
+   everything. You don't refactor what you can't run, and you don't change what
+   you can't pin.
+3. **Quick wins forward**: qualifying items lead the Now phase — early visible
+   value buys trust for the long items.
+4. **Score bands** fill Now → Next → Later, demoting items whose dependencies
+   sit in a later band.
+5. **Cycles**: break the lowest-weighted-score edge in the cycle and warn. A
+   cycle is a planning bug, not a reason to halt.
+
+## Declined items (D6)
+
+Every finding that does not become a roadmap item appears in the roadmap's
+`## Declined` section with its reason **and a risk-of-inaction line**. A
+stakeholder must be able to see what was consciously not done and what that
+choice costs. Silent omission is the failure mode this section exists to kill.
+
+## Ticket derivation
+
+Each Now and Next item becomes one ADLC-P2-shaped ticket
+([templates/ticket-template.md](./templates/ticket-template.md)): self-contained
+body, motivation linking back to `findings/F-*.md`, machine-verifiable
+acceptance criteria each naming its verification method, scope globs, rails
+paths, dependency edges with contract files. Tickets are **cold-start tested**
+(D6 gate): a fresh agent with only the ticket must be able to execute it. Gaps
+are repaired up to 2 rounds; a ticket still gapped is demoted to Later — and if
+any Now/Next ticket remains gapped, the roadmap gate fails (exit 2).
+
+## What scoring refuses to optimize
+
+Findings count, roadmap length, and artifact volume are vanity metrics (D11).
+The score exists to maximize **ticket survival rate** — items accepted into
+execution without rework — and to keep retained functionality intact. A shorter
+roadmap with higher ticket survival beats a longer one every time.

package/do-better/references/taxonomy.md

@@ -0,0 +1,136 @@
+# The Fixed Taxonomy Floor (D5)
+
+Eight dimensions of "better," in canonical order. This is the **floor**, not a
+menu: every engagement charter MUST carry a weight (1–5) for every dimension
+below. The charter interview (D0) may *weight* dimensions and *add*
+engagement-specific ones, but it may never drop one — the floor exists to
+prevent charter blind spots ("nobody asked about security, so nobody looked").
+A synthesized charter missing a dimension is corrected to weight 1 with a
+`(floor)` note, never dropped.
+
+Weight also governs **D2 finder-pool width**: with `--n` as the ceiling, a
+weight 4–5 dimension fans the full `--n` distinct-lens finders per pass, weight
+2–3 fans `max(1, floor(--n / 2))`, and weight 1 runs a single finder (no
+pooling). So a heavily-weighted dimension is searched both first (descending
+weight order) and wider. See the flag tables in `SKILL.md` / `README.md`.
+
+Each section below is the **finder charter** for that dimension: what a
+D2 finder chartered on this dimension hunts for, and what counts as concrete
+evidence. Finders operate under the refutation doctrine in
+[refute-charter.md](./refute-charter.md) — they are told to *disprove* the
+claim that the codebase is acceptable on the dimension, with file:line
+citations for every claim.
+
+Canonical ids (used in charter weights, finding ids, and ticket categories):
+`correctness`, `security`, `maintainability`, `performance`, `operability`,
+`test-quality`, `dependency-health`, `dx`.
+
+## Correctness risk
+
+`id: correctness`
+
+Hunt for code that can silently produce wrong results: unhandled error paths,
+swallowed exceptions, race conditions and unsynchronized shared state, off-by-one
+and boundary errors, implicit type coercions at trust boundaries, null/undefined
+dereferences on optional data, time-zone and floating-point hazards, partial
+writes without transactions or rollback, retry logic that double-applies effects,
+and logic that contradicts the documented or evident intent (comments, names,
+tests asserting one thing while code does another). Evidence is the exact
+file:line where the wrong result can be produced, plus the input or sequence that
+triggers it. The strongest correctness findings come with a runnable
+reproduction; propose one whenever the claim is mechanically checkable.
+
+## Security
+
+`id: security`
+
+Hunt for ways an attacker — external or internal — gains capability they should
+not have: injection (SQL, shell, template, path traversal), missing or bypassable
+authentication/authorization checks, secrets in source or config committed to the
+repo, unvalidated input crossing a trust boundary, unsafe deserialization,
+`eval`/dynamic-require on tainted data, child processes built from string
+concatenation, permissive CORS, missing rate limits on state-changing endpoints,
+sensitive data in logs or error messages, and outdated crypto or homegrown
+crypto. Cite the exact sink and the path tainted data takes to reach it. Severity
+tracks exploitability × blast radius, not theoretical purity.
+
+## Maintainability / debt
+
+`id: maintainability`
+
+Hunt for structures that make every future change slower or riskier: god files
+and god functions, copy-paste clones that must be changed in lockstep, cyclic
+dependencies, dead code that still has to be read, abstraction layers that leak
+or that exist for exactly one caller, configuration scattered across hardcoded
+literals, naming that lies, TODO/FIXME/HACK clusters that mark known unfinished
+surgery, and modules whose churn history shows repeated bug-fix commits (hot,
+fragile code). Evidence is structural and locational — name the files, the line
+ranges, and where possible the churn or clone counterpart that proves the cost
+recurs.
+
+## Performance
+
+`id: performance`
+
+Hunt for work the system does that it does not need to do, at the moments it can
+least afford it: N+1 query patterns, unbounded result sets, synchronous I/O on
+hot paths, O(n²) loops over data that grows, missing indexes implied by query
+shapes, per-request recomputation of invariants, oversized payloads, chatty
+service calls inside loops, memory retained beyond its useful life, and absent
+caching where reads dwarf writes (or caching with no invalidation where writes
+matter). Claims must name the code path and the scaling variable that makes it
+hurt; "this could be slow" without a growth factor is not a finding.
+
+## Operability
+
+`id: operability`
+
+Hunt for everything that makes the system hard to run, observe, and recover:
+missing or useless logging at failure points, no health/readiness signals,
+swallowed errors that turn outages into mysteries, absent timeouts and circuit
+breakers on outbound calls, no graceful shutdown, configuration that only works
+on one machine, deploy and migration steps that exist only in someone's head,
+unbounded queues and retries that amplify incidents, and startup that fails
+late instead of failing fast on missing prerequisites. Evidence cites where the
+signal is missing (the catch block that drops the error, the fetch with no
+timeout) — absence is locational too.
+
+## Test quality
+
+`id: test-quality`
+
+Hunt for the gap between what the test suite appears to guarantee and what it
+actually guarantees: load-bearing behaviors with no test at all (cross-check the
+behavior inventory and rails map), tests with no assertions or assertions that
+cannot fail, tests that mock the very thing under test, snapshot tests nobody
+reads, flaky patterns (sleeps, ordering dependence, shared mutable fixtures),
+test code that swallows errors, and suites that pass with the implementation
+deleted (hollowness). Evidence cites the test file and line, and names the
+production behavior left unguarded. Coverage percentage alone is never evidence.
+
+## Dependency health
+
+`id: dependency-health`
+
+Hunt for risk imported through the dependency graph: dependencies past
+end-of-life or unmaintained, known-vulnerable version ranges, lockfile drift or
+absence, duplicate dependencies solving the same problem, deep coupling to a
+dependency's internals (imports from `dist/` or private paths), licenses
+incompatible with the engagement's constraints, and single points of failure
+(one maintainer, one registry). Flag what can be verified from manifests and
+lockfiles deterministically; mark CVE/EOL claims that require network
+verification as "needs verification" rather than asserting them — see
+[verification.md](./verification.md).
+
+## Developer experience
+
+`id: dx`
+
+Hunt for friction that taxes every contributor on every change: setup that takes
+hours or requires tribal knowledge, build/test cycles measured in tens of
+minutes, incantations that exist only in CI config or shell history, missing or
+lying README instructions, inconsistent formatting with no enforcement, error
+messages that don't say what to do, slow or noisy CI that trains people to
+ignore it, and onboarding gaps the glossary and codemap expose. Evidence is the
+concrete command, file, or absence — "DX is bad" is vibes; "`npm test` takes 14
+minutes because X (file:line)" is a finding.

package/do-better/references/templates/charter-template.md

@@ -0,0 +1,71 @@
+# Charter Template — `.dobetter/charter.md` (D0 output)
+
+Fill every placeholder. The frontmatter keys and shapes below are a contract:
+`parseCharter` validates them, and the taxonomy floor (D5) requires **all 8
+dimension ids present with weight 1–5** — a dimension the interview didn't
+prioritize gets weight 1 with a `(floor)` note in the rationale, never removed.
+
+Frontmatter uses the zero-dependency subset: flat scalars, inline arrays of
+scalars, one level of nesting. Each `extraDimensions` entry is a single
+pipe-delimited scalar string `id|Label|weight` (e.g. `ci-reliability|CI
+reliability|4`); the list is empty when the engagement adds none.
+
+```markdown
+---
+approved: false
+headSha: <40-hex sha the interview facts were drawn from>
+generatedAt: <ISO 8601 timestamp>
+intent: <stabilize | scale | extend | handoff>
+weights:
+  correctness: <1-5>
+  security: <1-5>
+  maintainability: <1-5>
+  performance: <1-5>
+  operability: <1-5>
+  test-quality: <1-5>
+  dependency-health: <1-5>
+  dx: <1-5>
+extraDimensions: [<id|Label|weight>, ...]
+---
+
+# Engagement Charter — <repo name>
+
+## Pain
+
+<What hurts today, in the stakeholder's words. One bullet per pain point, each
+tied where possible to a scan fact that evidences it
+(`path/to/file.js:123@a1b2c3d`).>
+
+## Intent
+
+<The 12-month intent — stabilize, scale, extend, or hand off — and what that
+implies for prioritization. One short paragraph.>
+
+## Constraints
+
+<Hard constraints the roadmap must respect: freeze windows, compliance,
+budgets, no-touch areas, team capacity. One bullet each. "None stated" is a
+valid entry — absence must be explicit.>
+
+## Dimension weights
+
+<One bullet per taxonomy dimension, in canonical order: the weight, and one
+sentence of rationale citing the interview answer or scan fact that justifies
+it. Floor-corrected dimensions read: "1 (floor) — not prioritized by
+stakeholder; retained per taxonomy floor.">
+
+## Established from the codebase
+
+<Questions answered deterministically from D-1 scan facts instead of asked —
+each as "Q → answer, evidence: <citation or scan fact>". Empty section allowed
+but must be present.>
+
+## Engagement dimensions
+
+<One bullet per extra dimension: id, label, weight, and why this engagement
+needs it beyond the fixed taxonomy. "None" if extraDimensions is empty.>
+```
+
+Approval: a human reviews and edits this file, then approves (interactively at
+the end of the interview, or later via `do-better charter --approve`). Approval
+hashes the file; the hash is the anchor every downstream phase trusts.

package/do-better/references/templates/finding-template.md

@@ -0,0 +1,56 @@
+# Finding Template — `.dobetter/findings/F-<DIM>-NNNN.md` (D2 output)
+
+One file per **verified** finding. Unverified candidates are killed, never
+written — if a file exists in `findings/`, it survived reproduce-or-kill
+([../verification.md](../verification.md)). The id embeds the dimension
+(first 4 letters, uppercase) and a zero-padded sequence: `F-SEC-0003`,
+`F-CORR-0012`.
+
+Frontmatter shapes are a contract (`readFindings` parses them). `evidence` is
+an inline array of canonical citation strings `path:line@sha`; `reproduction`
+is one level of nesting; `stale` is written `false` here and only ever flipped
+by `refresh`, never by identify.
+
+```markdown
+---
+id: F-<DIM>-NNNN
+dimension: <correctness|security|maintainability|performance|operability|test-quality|dependency-health|dx|<extra-dimension-id>>
+title: <short imperative summary>
+severity: <critical|high|medium|low>
+confidence: <0..1>
+evidence: [<path/to/file.js:123@a1b2c3d>, ...]
+reproduction:
+  method: <command|reread|static>
+  record: <command + captured output, or blind-reread verdict rationale; single line, escaped>
+  exitCode: <integer or null>
+status: verified
+foundAt: <ISO 8601 timestamp>
+headSha: <40-hex repo HEAD at verification time>
+stale: false
+---
+
+# <title>
+
+## Claim
+
+<One paragraph: what is wrong, why it matters on this dimension, what triggers
+it. Plain language a stakeholder can read.>
+
+## Evidence
+
+<One bullet per citation: the citation (`path/to/file.js:123@a1b2c3d`) plus a
+one-line quote or description of what that location shows. Every bullet's
+citation must verify deterministically — file exists, line in range.>
+
+## Reproduction record
+
+<The full reproduction: for `command`, the exact command, its stdout/stderr,
+and exit code; for `reread`, the blind verifier's CONFIRM rationale; for
+`static`, the deterministic check and its result. This record is what refresh
+re-runs to decide resolved-vs-still-present.>
+
+## Impact
+
+<What happens if nothing is done — the risk-of-inaction in concrete terms.
+Feeds the roadmap's risk-of-inaction line.>
+```

package/do-better/references/templates/rail-template.md

@@ -0,0 +1,74 @@
+# Rail Template — Characterization-Test Authoring (D4)
+
+A **rail** is a characterization test that pins a behavior exactly as it is
+today, so execution work can prove it broke nothing. Rails are authored in a
+**fresh context** that sees ONLY: the behavior-inventory entry, the boundary
+I/O shape, and this template — never implementation internals (P3
+separate-context doctrine). A rail written by someone who read the
+implementation tests the implementation's opinion of itself.
+
+## Where rails live
+
+- File: `<repo>/test/dobetter-rails/<behaviorId>.rail.test.js` (or the repo's
+  idiomatic test directory if one is detected — rails run under the repo's own
+  runner or `node --test`).
+- Pointers only in `.dobetter/rails/manifest.md`; the tests live in the repo's
+  test tree and ship with it.
+
+## Authoring rules
+
+1. **Boundary-level golden-master style.** Capture the behavior at its
+   observable surface, by kind:
+   - `route` — start the app locally, hit it with builtin `fetch`, assert
+     status + headers that matter + body (normalized for timestamps/ids).
+   - `cli` — spawn the command (`spawnSync`, no shell), assert exit code,
+     stdout, stderr.
+   - `job`/`event` — invoke the entry, assert emitted effects.
+   - `db-write` — snapshot relevant rows before, run, assert the after-state
+     delta.
+2. **Bug-compatible pinning.** Assert the *current actual* output, even when it
+   is odd or known-wrong. Annotate, don't fix:
+
+   ```js
+   // pinned current behavior, possibly a bug: see F-CORR-0007
+   assert.equal(res.status, 200); // (spec says 404; current code returns 200)
+   ```
+
+   Rails preserve behavior; the roadmap changes it. A rail that asserts the
+   *desired* behavior is red on arrival and useless as a rail.
+3. **Deterministic.** Normalize or freeze time, ids, ordering, and environment.
+   A flaky rail is worse than no rail — it trains people to ignore red.
+4. **One behavior per rail file.** Named by behavior id (`B-014.rail.test.js`),
+   header comment citing the inventory entry and its citation
+   (`path:line@sha`).
+5. **Self-contained setup.** The rail starts/seeds what it needs and tears it
+   down; it must pass on a fresh clone where preflight is green.
+
+## Quality gates the rail must survive
+
+- **Green on current code** — any rail red after 2 fix rounds is deleted and
+  the behavior recorded as `gap: could not pin`. Never ship a red rail.
+- **Hollow-test audit** — mutants in the rail's assertions must be killed. A
+  rail that passes with its assertions mutated is fog, not glass; survivors get
+  one fix round, then the rail is deleted and the gap recorded. When
+  hollow-test is unavailable: deletion spot-check (comment out the behavior's
+  entry line; the rail must go red).
+- **Frozen** — once green and audited, the rail path is appended to every
+  backlog ticket's `rails` array so ADLC rails-guard freezes it mechanically.
+  Execution agents may not edit rails; a rail change is a human decision.
+
+## Manifest row shape — `.dobetter/rails/manifest.md`
+
+One table row per authored rail:
+
+```markdown
+| behavior | rail file | style | pinned-at SHA | audit | frozen |
+|---|---|---|---|---|---|
+| B-014 | test/dobetter-rails/B-014.rail.test.js | http golden-master | a1b2c3d | hollow: killed 4/4 | yes |
+| B-021 | test/dobetter-rails/B-021.rail.test.js | cli golden-master | a1b2c3d | spot-check | yes |
+```
+
+`audit` values: `hollow: killed n/n` · `spot-check` · `unaudited (hollow-test
+absent)`. Below the table, a `## Gaps` section lists every targeted behavior
+without a green rail and why (`could not pin`, `env not runnable`, `vacuous —
+deleted`). A gap declared is a known risk; a gap omitted is a lie.

package/do-better/references/templates/roadmap-template.md

@@ -0,0 +1,67 @@
+# Roadmap Template — `.dobetter/ROADMAP.md` (D3 output)
+
+The executive deliverable. Dual artifact, one source of truth: every item here
+maps to verified findings (`findings/F-*.md`) and Now/Next items map to backlog
+tickets. It is a **living document** — idempotent re-runs reconcile prior state
+and move items into Done / Regressed rather than regenerating from scratch.
+
+```markdown
+---
+generatedAt: <ISO 8601 timestamp>
+headSha: <40-hex repo HEAD this roadmap was generated against>
+basedOnFindings: <count of verified findings consumed>
+approved: false
+---
+
+# Technical Roadmap — <repo name>
+
+## Executive summary
+
+<3–6 sentences: the state of the codebase against the charter, the top risks,
+what Now buys, and what was consciously declined. No item lists here —
+judgment, written for a stakeholder who reads nothing else.>
+
+## Phase 0 — Rails & runnability
+
+<Items that must precede all change: environment fixes (preflight red →
+"Make the environment runnable"), and characterization-rail prerequisites.
+Empty phase must say "None required — environment runnable, rails in place.">
+
+<!-- Item shape, used in every phase section: -->
+- **<title>** (T<id> · score <weighted score> · <severity>)
+  - Evidence: <links to findings files, e.g. [F-SEC-0003](findings/F-SEC-0003.md)>
+  - Risk of inaction: <one concrete sentence>
+
+## Now
+
+<Quick wins first (score ≥ 1.5, effort S), then highest-scored
+dependency-feasible items. Each item: title, finding links, score,
+risk-of-inaction.>
+
+## Next
+
+<Same item shape. Items here have tickets too; items demoted by coldstart
+failures land in Later, flagged.>
+
+## Later
+
+<Same item shape, lighter detail allowed. Includes coldstart-demoted tickets,
+flagged `coldstart: failed`.>
+
+## Done / Regressed
+
+<Living-document ledger. `✅ done — <title> (resolved @ <sha>)` for items whose
+findings no longer reproduce; `⚠ regressed — <title> (re-verified @ <sha>)` for
+previously-done items whose finding came back, and for retained behaviors that
+changed with no roadmap item claiming the change. Empty on first run.>
+
+## Declined
+
+<Every finding that did not become a roadmap item: title, finding link, reason
+(explicit declineReason or score < 0.3), and a risk-of-inaction line. Nothing
+is silently dropped — an empty section must state "Nothing declined.">
+```
+
+Approval: human gate 2. Review this file and `backlog/`, edit freely (edits are
+re-hashed, not rejected), then `do-better roadmap --approve`. Approval requires
+the coldstart gate clean.

package/do-better/references/templates/ticket-template.md

@@ -0,0 +1,78 @@
+# Ticket Template — `.dobetter/backlog/<id>.md` (D3 output)
+
+One markdown file per Now/Next roadmap item, **plus** the machine mirror
+`backlog/tickets.json` in the exact ADLC `.adlc/tickets.json` schema
+(`{ "tickets": [ { id, title, body, scope, rails, edges, duration, category,
+budget? } ] }`). The JSON is the source of truth consumed by `coldstart
+--tickets .dobetter/backlog/tickets.json` and ADLC P3/P4 intake; the markdown
+is the human-review surface. The two are written together and must agree.
+
+A ticket must be **self-contained**: a fresh agent with only this ticket (and
+the repo) can execute it. That is what the coldstart gate tests. Embed data
+shapes, contracts, and file paths — never reference "the discussion" or "as
+mentioned above."
+
+```markdown
+---
+id: T<n>
+title: <short imperative title>
+category: <dimension id of the driving finding>
+duration: <relative build-time estimate, positive number>
+scope: [<glob>, ...]
+rails: [<path>, ...]
+---
+
+# T<n> — <title>
+
+## Motivation
+
+<Why this work exists, linking every driving finding:
+[F-SEC-0003](../findings/F-SEC-0003.md). Quote the risk-of-inaction. A ticket
+whose motivation cites no finding is not a do-better ticket.>
+
+## Acceptance criteria
+
+<Each criterion is machine-verifiable and NAMES its verification method (F1
+defense). One bullet per criterion, exactly one method each:>
+- <criterion> — verified by: <a test to be written at `<path>`>
+- <criterion> — verified by: <a command whose output is asserted: `<command>` → <expected>>
+- <criterion> — verified by: <a behavior demonstrated: <observable before/after>>
+
+## Scope
+
+<The declared file globs this ticket may touch, one per line, matching the
+frontmatter `scope` array. Work outside scope is escalation, not improvisation.>
+
+## Rails
+
+<The characterization rails that must stay green while executing this ticket
+(paths matching the frontmatter `rails` array — frozen, hollow-audited; see
+rails/manifest.md). D4 appends authored rail paths here mechanically.>
+
+## Dependencies
+
+<One line per edge: `T<m> — contract: <path/to/contract/file>` meaning this
+ticket must complete before T<m>, with the named file as the interface between
+them. "None" if independent. Mirrors `edges` in tickets.json.>
+
+## Partition hints
+
+<How to split execution contexts if the ticket is run by parallel agents: which
+files group together, what must be sequential. Optional but recommended.>
+
+## Suppression allowances
+
+<Optional `allow-suppression: <marker>` lines, one per allowed lint/test
+suppression marker this ticket may legitimately introduce. Omit the section if
+none — absence means zero suppressions allowed.>
+
+## Coldstart
+
+<Gate record: `clean` (round N) or `failed — demoted to Later`, with the gap
+list from the coldstart run. Written by the tool, kept current on re-runs.>
+```
+
+Validation (mirrors aidlc `validateTicket`, applied before writing): string
+`id` and `title` required; `scope`/`rails` arrays; every `edges[].to` a string
+naming a known ticket id; `duration` a positive number. An invalid ticket gets
+one repair round, then is demoted to Later with a warning.