refactor: shrink backlog-doctor.js and setup-dev-backlog.js to the surviving guards (#446)

.dev-backlog/sprints/_context.md

@@ -34,7 +34,6 @@
 - Relationship edges in the triage report are advisory context. A `merged-pr-link` mention is evidence, not a close by itself — close still needs an Obsolete Candidate plus an accepted apply checkbox.
 - Backlog triage reports must protect issues referenced in the active sprint Plan or Running Context from close / close-duplicate proposals.
 - `gh issue create` does not support `--json`; a `create --json ... || create -b "fallback"` chain fails the first call at flag parsing and posts the fallback placeholder as the real issue body (BACK-243 incident, 2026-07-05). Capture the URL from stdout instead.
-- Reassess signal counting is date-granular: sprints closed on the same day as (or after) the latest `.dev-backlog/triage/YYYY-MM-DD-reassess.md` all count, so several small same-day closes can re-trigger the recommendation right after a reassess (observed 2026-07-04). Judgment call at close time; tune the threshold/rule if it keeps nagging (PRD listed thresholds as dogfood-tunable).
 - `references/spec-fallback.md` is consumption-side only, ~1 page hard cap: it says how dev-backlog/backlog-triage BEHAVE when the spec axis is thin/absent, never authors spec semantics (that lives in craftkit). Guard against it drifting into a second spec-axis authority — that was the 2026-06/07 silent-fork failure mode (#253)
 - The smoke test is fully offline since #445: `status.sh` no longer lists Issues and `sprint-init.js` no longer reads milestones, so a smoke failure is a real regression, not a network flake.
 - v1.0.0 is reserved and is not a cleanup cut: do not delete completed sprint files.

CHANGELOG.md

@@ -8,6 +8,7 @@ Each entry links the GitHub issue (the canonical spec) and the merge PR (the shi
 
 ### Changed
 
+- **Doctor and setup shrunk to the surviving guards** — `backlog-doctor.js` keeps `active_sprint`, `sprint_shape`, `in_flight_trace`, `in_flight_staleness`, `context_bloat` and drops the reassess-signal counter, its `--close-summary` / `--closing-sprint` / `--reassess-threshold` flags, and the `legacy_execution_root` check (795 → 490 lines); `sprint-close.sh` runs the doctor read-only and no longer prints a reassess summary; `setup-dev-backlog.js` is create-root + legacy migration only, with the GitHub-evidence probe and `--project-name` removed (374 → 150 lines). Decided by charter rev 19. Closes [#446](https://github.com/sungjunlee/dev-backlog/issues/446).
 - **Tracker abstraction deleted; GitHub-only (G1, BREAKING for `.tracker=files`)** — `tracker.js`, `github-tracker.js`, `files-tracker.js`, `task-ref.js`, capability/status helpers, the `backlog` fake, and `references/adapter-ports.md` are gone (1,845 script lines, 2,514 test lines); Plan refs are `#N`; `sprint-init.js` no longer seeds from a milestone; `status.sh` drops the Tracker Tasks listing; `.dev-backlog/.tracker` is neither written nor read. The `files` adapter and the ports contract are retrievable at tag `v0.11.0`. dev-relay's `sprint-state` schema v2 is unchanged (verified against `../dev-relay`). Closes [#445](https://github.com/sungjunlee/dev-backlog/issues/445).
 - **backlog-triage pipeline deleted; the report is written by the session** — `triage-collect.js`, `triage-relate.js`, `triage-stale.js`, `triage-report.js`, `triage-github.js` and four references are gone (2,366 script lines, 2,226 test lines); `SKILL.md` is the 33-line scripts-less contract (`gh` reads, fixed eight-section shape, anchor grammar); `triage-apply.js` stays as the human gate. Decided by the fixture-backed real A/B in `docs/conformance/2026-09-17-cc/433/`. Closes [#433](https://github.com/sungjunlee/dev-backlog/issues/433).
 - **`effective-task-spec.js` deleted; the Work rail is a `gh` read** — the session reads `gh issue view N --json body,comments` (newest `## Agent Brief` comment over body, `spec_ref:` over both) and stops fail-closed on a failed read; the resolver's digest had no consumer. 624 script lines, 615 test lines removed. Decided by charter rev 19. Closes [#443](https://github.com/sungjunlee/dev-backlog/issues/443).

docs/conformance/2026-09-17-cc/astra-batch3-post446.md

@@ -0,0 +1,45 @@
+All actions below are hypothetical. Scripts resolve from the installed skill’s `scripts/` directory and run from the target repo root. Referenced documents were not supplied; I do not assume their contents.
+
+1. **ACTIONS:** Read `_context.md` and the active sprint; run `status.sh --json` and `next.sh --json`; read the next Issue live with `gh issue view N --json body,comments`; report Plan state and next actionable batch.
+   **MUTATIONS:** None.
+   **STOP/ASK:** No routine confirmation; if GitHub reads fail, report the limitation and stop task execution.
+
+2. **ACTIONS:** Read context and the existing active sprint; compare scope. `sprint-init.js` must refuse the overlapping track; evaluate incorporating admitted work into the existing Plan or deferring it.
+   **MUTATIONS:** No second overlapping sprint; update the existing Plan and Progress only if the requested scope clearly authorizes incorporation.
+   **STOP/ASK:** Ask if incorporation versus deferral is ambiguous; never bypass the overlap guard.
+
+3. **ACTIONS:** Read `_context.md` and both active sprints; run portfolio `status.sh --json` and `next.sh --json`; use `--track auth` and `--track billing` for detail; verify candidate Issues live.
+   **MUTATIONS:** None; preserve both disjoint active tracks.
+   **STOP/ASK:** No; report each track’s state and next actionable batch without arbitrarily combining them.
+
+4. **ACTIONS:** Read the three Issues live and resolve specification precedence; ordered multi-Issue work qualifies for admission. Run `setup-dev-backlog.js`, then `sprint-init.js "topic"`; write Goal, estimates, and three sequential batches; verify with `status.sh --json` / `next.sh --json`.
+   **MUTATIONS:** Create `.dev-backlog/` and the active sprint with complete `#N` checkbox references; no tracker changes or invented spec files.
+   **STOP/ASK:** No, assuming Issues provide sufficient requirements; missing spec skills do not block the core cycle.
+
+5. **ACTIONS:** Read the live Issue and effective specification; implement directly, verify every AC, create a PR, then complete the authorized merge/closure workflow.
+   **MUTATIONS:** Implementation files, deliberate Issue AC/lifecycle updates, and PR; no sprint, local task files, or required `.dev-backlog/` bootstrap.
+   **STOP/ASK:** No; neither missing Relay nor missing spec infrastructure requires a sprint.
+
+6. **ACTIONS:** Read existing sprint/context if present; run `gh issue view 42 --json body,comments`; apply `spec_ref:` over newest `## Agent Brief` over body; implement and verify all three AC against the effective specification.
+   **MUTATIONS:** Code and verified Issue AC; if already admitted, mark Plan `[~]` with branch/PR pointer and update Progress, then `[x]` after verified completion.
+   **STOP/ASK:** No local task files needed; stop execution if the live read fails, and ask only for material specification ambiguity.
+
+7. **ACTIONS:** Read `_context.md` and active sprints if present; run `status.sh --json` / `next.sh --json`; use live GitHub reads to identify and inspect the next Issue.
+   **MUTATIONS:** None during orientation; absence of local task files does not trigger bootstrap or sprint creation.
+   **STOP/ASK:** No routine question; report the next Issue/batch or a justified sprint-planning need. Fail closed if live GitHub reads fail.
+
+8. **ACTIONS:** Read available repo context and sprint files; summarize only recorded local state. Diagnose unavailable GitHub access; do not treat local Plan entries as a current task specification.
+   **MUTATIONS:** None; no implementation, AC, or lifecycle changes.
+   **STOP/ASK:** Stop task execution until live GitHub reads succeed; request restored access if user intervention is needed.
+
+9. **ACTIONS:** Read context and sprint; re-read planned Issues live and verify current AC/completion. Resolve unfinished tasks first; run `sprint-close.sh` (with `--track` if needed); after success, promote project-level Running Context into `_context.md`.
+   **MUTATIONS:** Any justified task closure/Plan updates; script sets `status: completed` and final Progress; update `_context.md`, preserving the closed sprint as immutable history.
+   **STOP/ASK:** No routine confirmation; stop closure for incomplete work, failed live reads, or script/doctor blockers. Local task files are unnecessary.
+
+10. **ACTIONS:** Re-read `gh issue view N --json body,comments`; resolve current specification precedence; compare changes with implementation and reverify every affected AC before completion.
+    **MUTATIONS:** Adjust implementation and deliberate AC updates to current requirements; update admitted sprint context/progress and Plan when warranted. Never overwrite newer requirements with stale text.
+    **STOP/ASK:** Ask if changes introduce conflicting or materially ambiguous scope; otherwise continue. A failed live read stops execution and lifecycle changes.
+
+11. **ACTIONS:** Inspect legacy `_context.md` if present and the active sprint; run `setup-dev-backlog.js` to migrate the recognized layout; read migrated context/sprint, then run `status.sh --json` / `next.sh --json` and verify the next Issue live.
+    **MUTATIONS:** Migrate legacy sprints, config, and triage into `.dev-backlog/`; leave `backlog/tasks/`, `docs/`, and `completed/` in place; no tracker changes or duplicate sprint.
+    **STOP/ASK:** No routine confirmation for the prescribed migration; stop for migration conflicts or failed live Issue reads before execution.

docs/conformance/2026-09-17-cc/fable-batch3-post446.md

@@ -0,0 +1,56 @@
+# Batch 3c answers (Fable)
+
+1. **Orient, one active sprint, partial Plan**
+ACTIONS: Read `.dev-backlog/sprints/_context.md`, then the active sprint file (Goal, Plan markers, Running Context, Progress). Run `scripts/status.sh --json` and `scripts/next.sh --json` from the project root to get the next actionable batch. Confirm each `[~]`/next-batch Issue is still open via `gh issue view N --json state,body` (fail-closed if `gh` fails). Report: sprint state, next batch, next live Issue.
+MUTATIONS: none.
+STOP/ASK: no; orient is read-only. Only stop if `gh` fails (then diagnose, do not proceed to work).
+
+2. **Plan a sprint overlapping an active track**
+ACTIONS: Read `_context.md` and the active sprint file to learn its `component:`/`scope:`. Run `scripts/sprint-init.js "topic" --component|--scope ...`; it refuses because `scopesOverlap` detects the collision. Do not hand-write a second file to bypass it. Options to present: add the work as a later batch of the existing track, narrow the new scope to a disjoint one, or wait for the existing track to close.
+MUTATIONS: none (init refused; no sprint file written).
+STOP/ASK: yes; ask the user which option they want, since concurrent overlapping tracks are forbidden and re-scoping is a judgment call.
+
+3. **Orient with two disjoint active tracks**
+ACTIONS: Read `_context.md` and both sprint files (`auth` with `scope: ["src/auth/**"]`, `billing` with `scope: ["src/billing/**"]`). Run `scripts/status.sh --json` for the portfolio view, then `scripts/next.sh --track auth` and `scripts/next.sh --track billing` for per-track next batches. Verify the next Issues live via `gh issue view`. Report per-track state and next batch; note both scopes are disjoint so they coexist.
+MUTATIONS: none.
+STOP/ASK: no; if the user did not say which track they will work, ask before entering `work`.
+
+4. **No spec axis, three ordered Issues, reach first active sprint**
+ACTIONS: `gh issue view` each of the three Issues (body, AC) to confirm they are live and ordered; ordered multi-Issue batches satisfy Sprint Admission. Run `scripts/setup-dev-backlog.js` to create `.dev-backlog/` (no legacy layout to migrate). Run `scripts/sprint-init.js "topic"` (optionally `--milestone`, `--component`/`--scope` only if the user names one). Write Goal and a Plan with three batches, one Issue per batch (dependent order), plus estimates; per `references/spec-fallback.md`, `objectives:` stays empty and no charter is invented. Run `scripts/status.sh` to confirm the track is active.
+MUTATIONS: local: new `.dev-backlog/` tree, `_context.md`, sprint file `status: active`. GitHub: none.
+STOP/ASK: no for setup/init; ask only if batch order or scope axis is ambiguous. I would not run `spec-charter` (not installed) or amend `spec/*`.
+
+5. **No spec axis, one self-contained Issue, no Relay**
+ACTIONS: `gh issue view N --json body,comments` (Agent Brief / `spec_ref:` override rules). Sprint Admission says default path is sprint-free Issue → implementation → PR → close; a single Issue does not admit a sprint. Implement directly, verify each AC, open a PR, then `gh issue close N` after merge.
+MUTATIONS: GitHub: AC checkboxes ticked and Issue closed after verification, PR created. Local: no `.dev-backlog/`, no sprint file created.
+STOP/ASK: no, unless the AC are unreadable or `gh` fails.
+
+6. **Work #42, no local task files, three live AC**
+ACTIONS: `gh issue view 42 --json body,comments`; apply override order (newest `## Agent Brief` comment > body; `spec_ref:` > both). If a sprint is active and #42 is on the Plan, mark it `[~]` with branch/PR pointer. Implement, verify AC items one by one, tick each checkbox on the Issue via `gh issue edit` only after verification, open PR, add Progress entry if admitted.
+MUTATIONS: GitHub: AC checkboxes, PR; sprint file `[~]` + Progress if admitted. No local task files are created (none are required).
+STOP/ASK: no; stop if the `gh` read fails (diagnose, no execution).
+
+7. **Fresh online session, no local task files**
+ACTIONS: Read `_context.md` and any active sprint file if `.dev-backlog/` exists; run `scripts/status.sh --json` / `next.sh --json`. If no sprint, `gh issue list --state open` (plus milestone/labels) to name the next live Issue. Treat GitHub as sole truth; local task files are not needed.
+MUTATIONS: none.
+STOP/ASK: no; ask what to work on only if no sprint and no obvious next Issue.
+
+8. **Fresh session, repo files only, no GitHub access**
+ACTIONS: Read `_context.md` and active sprint file for the picture; run `scripts/status.sh` (local view). Attempt `gh issue view` for the next item; it fails, so diagnose (`gh auth status`, network) and report.
+MUTATIONS: none. Never fall back to sprint text or local copies as task authority.
+STOP/ASK: yes; stop before any implementation or AC/lifecycle change until a live `gh` read succeeds (Hard Constraint).
+
+9. **Close sprint with reusable Running Context, no local task files**
+ACTIONS: For each Plan item, re-read the live Issue with `gh issue view`, verify AC, confirm merged/closed (`gh issue close` if verified but still open); set `[x]`. Run `scripts/sprint-close.sh` (or `--track <slug>` if multiple tracks); it runs `backlog-doctor.js`, flips `status: completed`, appends final Progress. Then promote project-level Running Context into `_context.md`; leave the sprint file as immutable record.
+MUTATIONS: GitHub: any remaining Issue closures. Local: sprint `status: completed`, Progress entry, `_context.md` updated.
+STOP/ASK: ask if any Plan item is not verifiably done (the sprint stays open until Plan is done); otherwise no.
+
+10. **GitHub Issue changed during work**
+ACTIONS: Re-read `gh issue view N --json body,comments`; apply override rules (newest `## Agent Brief`, `spec_ref:`). Diff against what I implemented; adjust work to the current AC; verify each current AC before ticking. Note the change in sprint Running Context/Progress if admitted.
+MUTATIONS: Local sprint Progress note; GitHub AC only after verification against the new spec. No edits to the Issue body itself.
+STOP/ASK: ask if the change contradicts work already merged or alters scope materially; otherwise continue under the live spec.
+
+11. **Legacy `backlog/` layout, orient**
+ACTIONS: Orient is read-only, so read `backlog/sprints/` active sprint and `backlog/config.yml` for context and run `gh` for live Issues, but report that the layout is legacy. Migration is via `scripts/setup-dev-backlog.js` (moves sprints/config/triage into `.dev-backlog/`, leaves `backlog/tasks/`, `docs/`, `completed/`); it belongs to `plan`, not orient.
+MUTATIONS: none during orient.
+STOP/ASK: yes; propose running `setup-dev-backlog.js` and wait for the user before migrating, since it moves files.

docs/conformance/2026-09-17-core-competence.md

@@ -39,3 +39,5 @@ SKILL.md from PR #453 (157 lines / never-only-must 5): "GitHub Issues" plainly,
 | astra × batch3 | 11/11 | 0 | 0 | 0 | 1 | Plan fold offered in 2 (every Astra run); 11 names the migration path, orients read-only |
 
 No new PARTIAL or FAIL against Batch 2; every stop held; no run named a deleted module, a `.tracker` file, or a non-GitHub tracker. Wire contract: dev-relay's `sprint-state` consumer tests 84/84 and its full sweep 712/713 with this branch (the one failure is dev-relay's own wall-clock flake, reproduced on unmodified main). Raw: `2026-09-17-cc/fable-batch3.md`, `astra-batch3.md`, `prompt-batch3.md`. Astra tokens (stderr): 26.0k.
+
+After #446 (doctor and setup shrunk; SKILL.md 157 lines, no reassess mention): one run per model, eleven scenarios — fable 11/11, astra 11/11, same flag profile as Batch 3; no run mentioned a reassess signal, `config.yml`, or a removed setup flag. Raw: `2026-09-17-cc/fable-batch3-post446.md`, `astra-batch3-post446.md`. Astra tokens (stderr): 12.8k.

skills/dev-backlog/SKILL.md

@@ -113,7 +113,7 @@ admitted, sprint progress.
 
 Goal: nothing stale left behind.
 Rail, per task: re-read the live Issue and verify every AC against the current specification, then merge or commit and close it with `gh issue close`. Plan item `[x]` and Progress too when a sprint is admitted. Done for the task when the Issue is closed with every AC verified; the sprint stays open until its Plan is done.
-Rail, per sprint: `sprint-close.sh` runs `backlog-doctor.js`, flips `status: completed`, appends the final Progress entry, and prints any reassess recommendation; after it succeeds, promote project-level Running Context to `_context.md` and leave the sprint file as the permanent record.
+Rail, per sprint: `sprint-close.sh` runs `backlog-doctor.js`, flips `status: completed`, appends the final Progress entry, and prints the doctor verdicts; after it succeeds, promote project-level Running Context to `_context.md` and leave the sprint file as the permanent record.
 Done when there is no stale active sprint or rediscovery-prone context trapped in the closed sprint.
 
 ### Next
@@ -146,8 +146,8 @@ Core scripts:
 - `scripts/setup-dev-backlog.js` — bootstrap `.dev-backlog/`.
 - `scripts/sprint-init.js` — create an active sprint file (`--milestone`, `--component` | `--scope`).
 - `scripts/next.sh` / `scripts/status.sh` — next actionable batch and sprint state; portfolio view for N disjoint tracks, `--track <slug>` for one.
-- `scripts/sprint-close.sh` — close the active sprint (`--track <slug>` when multiple tracks are active); prints the doctor/reassess summary.
-- `scripts/backlog-doctor.js` — aggregate health checks; JSON includes `reassess_signal`.
+- `scripts/sprint-close.sh` — close the active sprint (`--track <slug>` when multiple tracks are active); prints the pre-close doctor summary.
+- `scripts/backlog-doctor.js` — aggregate health checks; `--json` is the machine surface.
 
 ## References
 

skills/dev-backlog/references/file-format.md

@@ -136,8 +136,8 @@ Backlog.md config or the ownership is ambiguous, leave it under `backlog/`.
 `.dev-backlog/` is absent and at least one skill-owned name still sits under
 `backlog/`. That path is not `git mv`, takes no backup, and is not atomic.
 If `.dev-backlog/` already exists, auto-migrate skips (`destination-exists`)
-and does not retry: leftover skill names stay under `backlog/` and
-`backlog-doctor.js` warns. They are not a second active root.
+and does not retry: leftover skill names stay under `backlog/`. They are not a
+second active root.
 
 A lone `backlog/config.yml` with no `sprints/`, `triage/`, or
 `triage-config.yml` is left in place (Backlog.md or ambiguous). `config.yml`