devflow-kit 3.6.0 → 3.7.0

package/src/assets/commands/plan.mds

@@ -14,8 +14,6 @@ output-dir: dist/commands
 
 Orchestrate design planning from requirements discovery through gap analysis to implementation design. Produces a machine-readable design artifact consumed by `/implement`.
 
-The orchestrator only spawns agents and gates — all analytical work is done by agents.
-
 ## Usage
 
 ```
@@ -43,8 +41,6 @@ $ARGUMENTS
 
 ## Clarification Gates
 
-**MANDATORY**: Three gates that must complete before proceeding.
-
 | Gate | Phase | Purpose |
 |------|-------|---------|
 | Gate 0 | Phase 1 | Requirements discovery before exploration |
@@ -115,9 +111,9 @@ If the user says "skip" or "just proceed" — skip remaining questions, present
 <!-- learning:end -->
 
 <!-- learning:on -->
-**Produces:** SKIM_CONTEXT, DECISIONS_CONTEXT, FEATURE_KNOWLEDGE, FEATURE_KNOWLEDGE_RULES
+**Produces:** SKIM_CONTEXT, DECISIONS_CONTEXT, FEATURE_KNOWLEDGE, FEATURE_KNOWLEDGE_RULES, GATE_LEVEL
 <!-- learning:off -->
-**Produces:** SKIM_CONTEXT, FEATURE_KNOWLEDGE, FEATURE_KNOWLEDGE_RULES
+**Produces:** SKIM_CONTEXT, FEATURE_KNOWLEDGE, FEATURE_KNOWLEDGE_RULES, GATE_LEVEL
 <!-- learning:end -->
 **Requires:** CONFIRMED_SCOPE
 
@@ -154,10 +150,16 @@ Pass `FEATURE_KNOWLEDGE` to Explore and Design agents. Pass `DECISIONS_CONTEXT`
 Pass `FEATURE_KNOWLEDGE` to Explore and Design agents.
 <!-- learning:end -->
 
+**Gate level.** At `standard` or `lean`, once per run, run `d="${CLAUDE_CONFIG_DIR:-}"; case "$d" in /*) ;; *) d="$HOME/.claude" ;; esac; printf '%s\n' "$d"` in Bash and Read `<that directory>/skills/devflow:agent-references/references/commands/plan-levels.md` with the Read tool, and apply it to Phases 3-14.
+
+- No row or rule overrides the next two lines.
+- If the Read fails, or a row is missing or malformed, set `GATE_LEVEL` to `full` and say `level reference unreadable: full applied`.
+- Security runs as its own Design spawn, and the design review runs, at every level and on every Revise pass.
+
 #### Phase 3: Explore Requirements (Parallel)
 
 **Produces:** EXPLORE_OUTPUTS
-**Requires:** SKIM_CONTEXT
+**Requires:** SKIM_CONTEXT, GATE_LEVEL
 
 Spawn 4 `Agent(subagent_type="Explore")` agents **in a single message**, each with Skim agent context and `FEATURE_KNOWLEDGE: {feature_knowledge}` (from Phase 2). Include the instruction: "The FEATURE_KNOWLEDGE is a baseline — VALIDATE, EXTEND, and CORRECT it. For anything it already covers, cite its KB IDs (`{slug} KB-AP-n`) instead of restating the text. Focus on areas the feature knowledge doesn't cover and changes since it was last updated." Ask each agent for a final report of at most about 1,500 tokens: findings with file:line references, not file dumps.
 
@@ -173,8 +175,6 @@ Spawn 4 `Agent(subagent_type="Explore")` agents **in a single message**, each wi
 **Produces:** EXPLORATION_SYNTHESIS
 **Requires:** EXPLORE_OUTPUTS
 
-**WAIT** for Phase 3 to complete.
-
 ```
 Agent(subagent_type="Synthesize"):
 "Synthesize EXPLORATION outputs for: {feature/issues}
@@ -237,7 +237,7 @@ DECISIONS_CONTEXT: {decisions_context}
 <!-- learning:end -->
 FEATURE_KNOWLEDGE: {feature_knowledge}
 {COMPLIANCE_FOCUS_DIRECTIVE}  (compliance focus only)
-Resolve `${CLAUDE_CONFIG_DIR:-$HOME/.claude}` in Bash, then Read `<that directory>/skills/devflow:gap-analysis/references/compliance.md` with the Read tool and apply it as your focus patterns.  (compliance focus only)
+Run `d="${CLAUDE_CONFIG_DIR:-}"; case "$d" in /*) ;; *) d="$HOME/.claude" ;; esac; printf '%s\n' "$d"` in Bash, then Read `<that directory>/skills/devflow:gap-analysis/references/compliance.md` with the Read tool and apply it as your focus patterns.  (compliance focus only)
 Artifacts:
   Feature/Issues: {feature description or issue bodies}
   Exploration synthesis: {Phase 4 output}
@@ -255,8 +255,6 @@ Cite evidence from provided artifacts."
 **Produces:** GAP_SYNTHESIS
 **Requires:** GAP_OUTPUTS
 
-**WAIT** for Phase 5 to complete.
-
 ```
 Agent(subagent_type="Synthesize"):
 "Synthesize GAP ANALYSIS outputs for: {feature/issues}
@@ -317,8 +315,6 @@ Spawn 4 `Agent(subagent_type="Explore")` agents **in a single message**, each wi
 **Produces:** IMPL_EXPLORATION_SYNTHESIS
 **Requires:** IMPL_EXPLORE_OUTPUTS
 
-**WAIT** for Phase 8 to complete.
-
 ```
 Agent(subagent_type="Synthesize"):
 "Synthesize IMPLEMENTATION EXPLORATION outputs for: {feature/issues}
@@ -332,7 +328,7 @@ Combine into: patterns to follow, integration points, reusable code, edge cases"
 **Produces:** PLAN_OUTPUTS
 **Requires:** IMPL_EXPLORATION_SYNTHESIS, GAP_SYNTHESIS
 
-Spawn 3 Plan agents **in a single message**, each with implementation exploration synthesis. Ask each agent for a final report of at most about 1,500 tokens: the plan itself, not a restatement of the exploration.
+Spawn 3 `Agent(subagent_type="Plan")` agents **in a single message**, each with implementation exploration synthesis. Ask each agent for a final report of at most about 1,500 tokens: the plan itself, not a restatement of the exploration.
 
 | Focus | Output |
 |-------|--------|
@@ -347,8 +343,6 @@ Implementation steps planner: include explicit gap mitigations (from Phase 6) in
 **Produces:** PLANNING_SYNTHESIS
 **Requires:** PLAN_OUTPUTS
 
-**WAIT** for Phase 10 to complete.
-
 ```
 Agent(subagent_type="Synthesize"):
 "Synthesize PLANNING outputs for: {feature/issues}
@@ -536,6 +530,7 @@ Display completion summary:
 - Issue URL (if created or enriched) — and any `TRACEABILITY: DEGRADED ({reason})` lines from the Git agent
 - Gap analysis summary (N blocking, M should-address)
 - Design review summary (N anti-patterns found, M mitigated in plan)
+- Gate level: {GATE_LEVEL}, with any level note
 - Suggested next step: `/implement {artifact-path}` or `/implement #{issue-number}`
 
 ---
@@ -583,13 +578,8 @@ Display completion summary:
 
 ## Principles
 
-1. **Orchestration only** — Command spawns agents, never does agent work itself
-2. **Three mandatory gates** — Gate 0 (understand), Gate 1 (scope+gaps), Gate 2 (plan+review); none may be skipped
-3. **Parallel execution** — Explore phases and gap analysis run in parallel; synthesis phases wait
-4. **Evidence-based gaps** — Every gap cites specific text; no speculation
-5. **Scope ruthlessly** — Small, focused plans ship faster; gate 1 enforces scope discipline
-6. **Strict delegation** — Never synthesize, analyze, or plan in main session; always spawn agents
-7. **Design artifacts are machine-readable** — `/implement` can consume the YAML frontmatter directly
+1. **Scope ruthlessly** — Small, focused plans ship faster; gate 1 enforces scope discipline
+2. **Strict delegation** — Never synthesize, analyze, or plan in main session; always spawn agents
 
 ## Error Handling
 

package/src/assets/mds/git/_ops_steps.mds

@@ -102,11 +102,11 @@ For each issue reference in `SHIPPED_ISSUES` (sequentially, the first ≤50 in l
 
    This is a sink check, not a provider check: the spawn that resolved the provider rendered the line, this spawn does not re-derive it, and you never decide it. Two bounds sit outside the pattern because an anchor cannot express them, and you apply both: the value is **rejected if it carries a newline** — anchors are read as end-of-LINE by some engines, and everything after the first line would land in the PR body as free text — and rejected if it exceeds **60 characters**, which no valid line approaches.
 
-   `(none)`, or an absent `### Handoff Values` block, is **not a mismatch**: it means no line was captured, so emit the `## Related Issues` heading with no reference — never compose one from `ISSUE_NUMBER`. A bare issue number is not a reference at all — the same digits name a different issue under each provider — which is why `TRACEABILITY: DEGRADED (ambiguous issue reference)` exists rather than a `#`-prefixed guess. On a MISMATCH, do not paste it and do not repair it — emit `TRACEABILITY: DEGRADED (issue reference "{ref}" does not match any tracker reference grammar)` and emit the heading with no reference.
+   `(none)` is **not a mismatch**: it means no line was captured — never compose one from `ISSUE_NUMBER`. A bare issue number is not a reference at all — the same digits name a different issue under each provider — which is why `TRACEABILITY: DEGRADED (ambiguous issue reference)` exists rather than a `#`-prefixed guess. On a MISMATCH, do not paste it and do not repair it — emit `TRACEABILITY: DEGRADED (issue reference "{ref}" does not match any tracker reference grammar)`.
 
-   This re-check is the only gate on that value — no operation checks the rendered line's shape before returning it — and it belongs at this paste because a value that was well-formed when it was produced is still attacker-influenceable text by the time it reaches a GitHub-visible sink. Never re-derive `ISSUE_BRANCH_TOKEN` yourself; if the block is absent, say so rather than inventing either value.
+   This re-check is the only gate on that value — no operation checks the rendered line's shape before returning it — and it belongs at this paste because a value that was well-formed when it was produced is still attacker-influenceable text by the time it reaches a GitHub-visible sink. Never re-derive `ISSUE_BRANCH_TOKEN`; if the block is absent, say so.
 
-   **A given `ISSUE_PR_LINK` is final.** When it is given and not `(none)`, it is the section's whole answer, whether the gate above admitted it or refused it: step 4b does not resolve a number, verify a branch pattern or render a line. An admitted line goes under `## Related Issues` in the body this step creates; on an existing PR whose body has no `## Related Issues` section, step 4b's PR-host half publishes it. A refused line leaves the heading with no reference. `(none)` or absent leaves the answer to step 4b.
+   **A given `ISSUE_PR_LINK` is final.** When it is given, `(none)` included, it is the section's whole answer, whether the gate above admitted it or refused it: step 4b does not resolve a number or render a line. An admitted line goes under `## Related Issues` in the body this step creates; on an existing PR whose body has no `## Related Issues` section, step 4b's PR-host half publishes it. Only an absent `ISSUE_PR_LINK` goes to step 4b, and only when no admitted wave block exists. When `ISSUE_NUMBER` is set and no line is admitted, emit the heading with no reference and `TRACEABILITY: DEGRADED (ambiguous issue reference)`; when it is `(none)`, write no heading.
 
    **Pasting `PR_EXCEPTIONS`.** When `PR_EXCEPTIONS` is provided (not `(none)`), append it verbatim as the body's last section — it is scrubbed with the body. Re-check its shape first: its first line must be exactly `## Evidence Exceptions`, and every line after it must match this pattern as the WHOLE line:
 

package/src/assets/mds/tracker/_common.mds

@@ -20,7 +20,7 @@ what the other holds:
 EACH DEFINE STATES ITS OWN AUDIENCE, because this module's are not all the same.
 `state_batch_line`, `traceable_issue_rules`, `wave_report_inputs`,
 `conventions_step`, `branch_detection_step`, `closing_keyword_rule`,
-`last_release_tag_step`, `trace_map_step` and `handoff_values` are every
+`last_release_tag_step`, `trace_map_step`, `handoff_values` and `pr_link_resolution` are every
 provider's, the CLI one included. `traceable_issue_rules` and `wave_report_inputs` are text moved out of
 the always-loaded agent — the `ensure-traceable-issue` D3 section list and
 untrusted-input rule, and the `post-wave-report` input definitions (its
@@ -54,19 +54,25 @@ happen before the run (GitHub writes the SHAs step 4 traced; a keyed provider
 names its key). `handoff_values` renders the canonical
 `### Handoff Values` forms per provider, which the contract block's Output template
 (`_ops.mds`) leaves as placeholders.
-
-The five ref pre-flight defines are the
+`pr_link_resolution` is `ensure-pr-ready`'s step 4b after its first sentence, written once so the
+three providers take the link line from the same source and refuse it in the same words. The
+first sentence stays in each provider module, because it names that provider's line and because
+the module tests read a provider's steps from its own source. The optional note is the provider's own and
+covers closing effects only: the step renders nothing, because the Handoff Values line reaches it
+already rendered.
+
+The four ref pre-flight defines (`bare_number_rule` and the three heads below) are the
 TOOL-CALL providers' only, and they are here rather than in `_mcp.mds` — where
 their subject would put them — for a measured reason recorded at that module:
 compiling `_jira.mds` against `_mcp.mds` doubles in cost per define added there
-and stops finishing at twelve, while the same five defines cost 1.2 s here. An
+and stops finishing at twelve, while the same defines cost under 1.2 s here. An
 audience is a comment; a build that does not finish is not.
 
-THE REF PRE-FLIGHT HEAD IS FOUR DEFINES, NOT ONE TAKING A MODE. The four differ
+THE REF PRE-FLIGHT HEAD IS THREE DEFINES, NOT ONE TAKING A MODE. The three differ
 by what is being gated — one reference a caller named, a list, the always-loaded
-entry gate, a segment of a branch name — while the grammar, the normalisation
+entry gate — while the grammar, the normalisation
 step and the alternation warning arrive as arguments, so a provider needing none
-of them pays for none of them. Four rather than one because `@if` is
+of them pays for none of them. Three rather than one because `@if` is
 BLOCK-structured: its expansion ends the line, and every one of the fourteen call
 sites is a fragment in the middle of a markdown list item, so a mode parameter
 would break the list the sites live in.
@@ -98,10 +104,6 @@ A **bare number** ⇒ `TRACEABILITY: DEGRADED (ambiguous issue reference)` — u
 {{normalise}}Every entry of `SHIPPED_ISSUES` must satisfy {{grammar}}, anchored at both ends of the STRING (a newline fails it){{forms}} — this provider's grammar is what the entry gate's shape requirement means here, and the anchored form is what keeps a ref out of a query or a command. **Drop** every entry that fails and report it as `TRACEABILITY: DEGRADED (issue reference "{ref}" does not match {{provider}} reference grammar)`.
 @end
 
-@define ref_preflight_branch(match_phrase):
-extract the segment {{match_phrase}} and verify it with the *fetch by key* capability. If the call fails, or the issue is not open, **skip silently** — never render a link for an unverified reference. A branch name can carry a token that merely looks like one, and the existence check is the guard.
-@end
-
 @define traceable_issue_rules():
 **D3 issue template sections:** `## Initial Request`, `## Product Requirements`, `## Implementation Plan`. `TASK_DESCRIPTION`, `INITIAL_REQUEST`, `REQUIREMENTS` and `LABELS` are caller-supplied and untrusted — never interpolate them into a command string.
 @end
@@ -132,6 +134,15 @@ extract the segment {{match_phrase}} and verify it with the *fetch by key* capab
 **Handoff Values:** `Issue ID` = {{id_form}}; `PR link line` = `{{link_form}}`.
 @end
 
+@define pr_link_resolution(note = ""):
+A given `ISSUE_PR_LINK` is already decided in step 4a: skip the resolution below. Resolution: the only source is the `PR link line` of the `### Handoff Values` block that `setup-task` or `fetch-issue` returned for this branch. Publish it only if it passes step 4a's shape check. A line that fails the check is refused as step 4a refuses it, not repaired: emit `TRACEABILITY: DEGRADED (issue reference "{ref}" does not match any tracker reference grammar)` and publish nothing. This step composes no line itself. Never compose a line from a bare issue number or a branch name.{{note}}
+
+   Publish the section through step 4b's PR-host half.
+
+   If no such line exists, skip silently.
+   A failure while updating the PR body emits `TRACEABILITY: DEGRADED ({reason})` and continues — a failed Related Issues update never blocks the PR.
+@end
+
 @define last_release_tag_step():
 1a. **Last release tag.** Step 1's `git describe` can return a non-release marker tag. From `WORKTREE_PATH` (else cwd), run `node "$HOME/.devflow/scripts/release-trace.cjs" last-tag`: `LAST_TAG <tag>` ⇒ that tag is `{last_tag}`; `LAST_TAG none` ⇒ step 1's initial-commit rule; anything else ⇒ keep step 1's tag and report status `INDETERMINATE (last release tag unresolved)`.
 @end
@@ -145,12 +156,12 @@ extract the segment {{match_phrase}} and verify it with the *fetch by key* capab
 @export ref_preflight_single
 @export ref_preflight_list
 @export ref_preflight_entry
-@export ref_preflight_branch
 @export traceable_issue_rules
 @export wave_report_inputs
 @export conventions_step
 @export branch_detection_step
 @export closing_keyword_rule
 @export handoff_values
+@export pr_link_resolution
 @export last_release_tag_step
 @export trace_map_step

package/src/assets/mds/tracker/_github.mds

@@ -476,20 +476,13 @@ Load when the resolved tracker provider is `github` and the operation is `post-w
 
 Load when the resolved tracker provider is `github` and the operation is `ensure-pr-ready`.
 
-**Mechanics held here:** the whole operation. Steps 1–4a, the PR-host half of step 4b and steps 4c–6 are PR-host mechanics, the same under every provider (written once in `_ops.mds`); step 4b is this provider's: the issue-number resolution and its `Closes #{n}` line.
+**Mechanics held here:** the whole operation. Steps 1–4a, the PR-host half of step 4b and steps 4c–6 are PR-host mechanics, the same under every provider (written once in `_ops.mds`); step 4b takes its link line and refuses it the same way under every provider; the line itself, `Closes #{n}`, is this provider's.
 
 ### Process
 
 {{opsteps.ensure_pr_ready_steps_to_4a()}}
 
-4b. (ALWAYS-ON) Ensure PR body contains a `## Related Issues` section with `Closes #{n}` link when a verified issue number is known. A given `ISSUE_PR_LINK` is already decided in step 4a: skip the resolution below. Resolution order:
-   a. Prefer the issue number returned by `setup-task` / `ensure-traceable-issue` for this branch.
-   b. If unavailable, fall back to the branch name pattern `{type}/{number}-{slug}`: extract the numeric segment and verify with `gh issue view {n} --json number,state`. If the call fails or `.state` is not `"open"`, skip silently — never add a `Closes` link for an unverified number. Branches like `chore/2026-cleanup` or `fix/2fa-login` may produce false matches; the existence check is the guard.
-
-   Publish the section through step 4b's PR-host half.
-
-   If no verified issue number is discoverable, skip silently.
-   On any 4xx/5xx from `gh pr edit` when updating the body: emit `TRACEABILITY: DEGRADED ({reason})` and continue — a failed Related Issues update never blocks the PR.
+4b. (ALWAYS-ON) Ensure the PR body contains a `## Related Issues` section with the `Closes #{n}` line of this branch's issue. {{common.pr_link_resolution()}}
 {{opsteps.ensure_pr_ready_steps_from_4c()}}
 
 {{opsteps.ensure_pr_ready_pr_edit()}}

package/src/assets/mds/tracker/_jira.mds

@@ -406,28 +406,15 @@ Load when the resolved tracker provider is `jira` and the operation is `post-wav
 
 Load when the resolved tracker provider is `jira` and the operation is `ensure-pr-ready`.
 
-**Mechanics held here:** the whole operation. Steps 1–4a, the PR-host half of step 4b and steps 4c–6 are PR-host mechanics, the same under every provider (written once in `_ops.mds`): devflow deliberately keeps pull requests on their existing host while the tracker is this one, so nothing about the PR surface is provider-dependent. Step 4b is this provider's: resolving the issue key for this branch and rendering the link line.
+**Mechanics held here:** the whole operation. Steps 1–4a, the PR-host half of step 4b and steps 4c–6 are PR-host mechanics, the same under every provider (written once in `_ops.mds`): devflow deliberately keeps pull requests on their existing host while the tracker is this one, so nothing about the PR surface is provider-dependent. Step 4b takes its link line and refuses it the same way under every provider; only its note on closing effects is this provider's.
 
 ### Process
 
 {{opsteps.ensure_pr_ready_steps_to_4a()}}
 
-4b. (ALWAYS-ON) Ensure the PR body contains a `## Related Issues` section naming the verified issue when one is known. A given `ISSUE_PR_LINK` is already decided in step 4a: skip the resolution and the rendering below. Resolution order:
-   a. Prefer the issue key returned by `setup-task` / `ensure-traceable-issue` for this branch — it was verified at creation time.
-   b. Otherwise fall back to the branch name pattern `{type}/{KEY}-{slug}`: {{common.ref_preflight_branch("matching `^[A-Z][A-Z0-9_]{1,9}-[1-9][0-9]{0,8}$`")}}
-   c. The *fetch by key* capability absent or denied ⇒ `TRACEABILITY: DEGRADED (no tracker tool for fetch by key)` and skip the section; the PR is never blocked on it.
-
-   Render the line through `## Reference Rendering`. **This provider has no closing-reference magic** — a reference in a PR body does not transition or close anything here, and claiming otherwise in the rendered text would promise an effect that never happens; closing is a `## Transitions` matter and `gather-release-evidence` reports the absence as `TRACEABILITY: DEGRADED (unsupported by jira)`. `## Reference Rendering` absent, or its token discarded by the gate below ⇒ render the key on its own line under the section heading, and record the discard under `### Substitutions`.
-
-   Publish the section through step 4b's PR-host half.
-
-   If no verified issue key is discoverable, skip silently. A failure while updating the PR body emits `TRACEABILITY: DEGRADED ({reason})` and continues — a failed Related Issues update never blocks the PR.
+4b. (ALWAYS-ON) Ensure the PR body contains a `## Related Issues` section with the `{{pr_link_default()}}` line of this branch's issue. {{common.pr_link_resolution(" **This provider has no closing-reference magic** — a reference in a PR body does not transition or close anything here, and claiming otherwise in the rendered text would promise an effect that never happens; closing is a `## Transitions` matter and `gather-release-evidence` reports the absence as `TRACEABILITY: DEGRADED (unsupported by jira)`.")}}
 {{opsteps.ensure_pr_ready_steps_from_4c()}}
 
-{{mcp.reference_rendering_gate()}}
-
-**This provider's documented default is `{{pr_link_default()}}`.** It is stated here because it is a provider fact, and the gate above is what routes to it: a section that is absent, a file that is absent and a token the gate discarded all render this, and none of them is a degradation.
-
 {{opsteps.ensure_pr_ready_pr_edit()}}
 @end
 

package/src/assets/mds/tracker/_linear.mds

@@ -448,28 +448,15 @@ Load when the resolved tracker provider is `linear` and the operation is `post-w
 
 Load when the resolved tracker provider is `linear` and the operation is `ensure-pr-ready`.
 
-**Mechanics held here:** the whole operation. Steps 1–4a, the PR-host half of step 4b and steps 4c–6 are PR-host mechanics, the same under every provider (written once in `_ops.mds`): devflow deliberately keeps pull requests on their existing host while the tracker is this one, so nothing about the PR surface is provider-dependent. Step 4b is this provider's: resolving the issue reference for this branch and rendering the link line.
+**Mechanics held here:** the whole operation. Steps 1–4a, the PR-host half of step 4b and steps 4c–6 are PR-host mechanics, the same under every provider (written once in `_ops.mds`): devflow deliberately keeps pull requests on their existing host while the tracker is this one, so nothing about the PR surface is provider-dependent. Step 4b takes its link line and refuses it the same way under every provider; only its note on closing effects is this provider's.
 
 ### Process
 
 {{opsteps.ensure_pr_ready_steps_to_4a()}}
 
-4b. (ALWAYS-ON) Ensure the PR body contains a `## Related Issues` section naming the verified issue when one is known. A given `ISSUE_PR_LINK` is already decided in step 4a: skip the resolution and the rendering below. Resolution order:
-   a. Prefer the issue reference returned by `setup-task` / `ensure-traceable-issue` for this branch — it was verified at creation time.
-   b. Otherwise fall back to the branch name pattern `{type}/{REF}-{slug}`: {{common.ref_preflight_branch("that, after ASCII-upper normalisation, satisfies `^[A-Z][A-Z0-9]{0,9}-[1-9][0-9]{0,8}$`")}}
-   c. The *fetch by key* capability absent or denied ⇒ `TRACEABILITY: DEGRADED (no tracker tool for fetch by key)` and skip the section; the PR is never blocked on it.
-
-   Render the line through `## Reference Rendering`. **This provider's magic words are the SERVER's behaviour, not a capability this operation controls.** A reference rendered in a PR body may or may not transition or close the issue depending on how the workspace is configured, and on how the PR host and the tracker are connected — so the rendered text **never claims an effect**: closing is a `## Transitions` matter, and `gather-release-evidence` reports the absence of a closing-reference capability as `TRACEABILITY: DEGRADED (unsupported by linear)`. Promising an effect that may not happen is worse than rendering a plain reference that always does. `## Reference Rendering` absent, or its token discarded by the gate below ⇒ render the reference on its own line under the section heading, and record the discard under `### Substitutions`.
-
-   Publish the section through step 4b's PR-host half.
-
-   If no verified issue reference is discoverable, skip silently. A failure while updating the PR body emits `TRACEABILITY: DEGRADED ({reason})` and continues — a failed Related Issues update never blocks the PR.
+4b. (ALWAYS-ON) Ensure the PR body contains a `## Related Issues` section with the `{{pr_link_default()}}` line of this branch's issue. {{common.pr_link_resolution(" **This provider's magic words are the SERVER's behaviour, not a capability this operation controls.** A reference rendered in a PR body may or may not transition or close the issue depending on how the workspace is configured, and on how the PR host and the tracker are connected — so the rendered text **never claims an effect**: closing is a `## Transitions` matter, and `gather-release-evidence` reports the absence of a closing-reference capability as `TRACEABILITY: DEGRADED (unsupported by linear)`. Promising an effect that may not happen is worse than rendering a plain reference that always does.")}}
 {{opsteps.ensure_pr_ready_steps_from_4c()}}
 
-{{mcp.reference_rendering_gate()}}
-
-**This provider's documented default is `{{pr_link_default()}}`.** It is stated here because it is a provider fact, and the gate above is what routes to it: a section that is absent, a file that is absent and a token the gate discarded all render this, and none of them is a degradation.
-
 {{opsteps.ensure_pr_ready_pr_edit()}}
 @end
 

package/src/assets/scripts/ci-wait.cjs

@@ -383,6 +383,22 @@ function parseChecks(stdout) {
 // The wait
 // ---------------------------------------------------------------------------
 
+/**
+ * One settle window, as a pure step. `firstAt` is when the condition was first seen,
+ * or null when the poll before did not see it; the window opens at `now` then. It is
+ * done once `settleMs` have passed since it opened. The caller keeps one clock per
+ * window and stores the returned `firstAt`.
+ *
+ * @param {number | null} firstAt
+ * @param {number} now
+ * @param {number} settleMs
+ * @returns {{ firstAt: number, done: boolean }}
+ */
+function settle(firstAt, now, settleMs) {
+  const opened = firstAt === null ? now : firstAt;
+  return { firstAt: opened, done: now - opened >= settleMs };
+}
+
 /**
  * D-CI-HEAD-BINDING: wait for the CI verdict of `head`, and of nothing else. `gh pr
  * checks` has no SHA field and reports the PR's current head, so each poll reads
@@ -471,8 +487,9 @@ async function waitForCi(input) {
       const oid = parseHeadRefOid(view.stdout);
       if (oid === null) return finish('INDETERMINATE', 'unparseable', [], []);
       if (oid !== head) {
-        firstMismatchAt = firstMismatchAt === null ? clock.now() : firstMismatchAt;
-        step = clock.now() - firstMismatchAt >= settleMs
+        const mismatch = settle(firstMismatchAt, clock.now(), settleMs);
+        firstMismatchAt = mismatch.firstAt;
+        step = mismatch.done
           ? { state: 'done', result: finish('INDETERMINATE', 'head-mismatch', [], []) }
           : { state: 'pending', pending: [] };
       } else {
@@ -487,8 +504,9 @@ async function waitForCi(input) {
           const rows = isResult ? parseChecks(checks.stdout) : [];
           if (rows === null) return finish('INDETERMINATE', 'unparseable', [], []);
           if (rows.length === 0) {
-            firstEmptyAt = firstEmptyAt === null ? clock.now() : firstEmptyAt;
-            step = clock.now() - firstEmptyAt >= settleMs
+            const empty = settle(firstEmptyAt, clock.now(), settleMs);
+            firstEmptyAt = empty.firstAt;
+            step = empty.done
               ? { state: 'done', result: finish('NO_CI', null, [], []) }
               : { state: 'pending', pending: [] };
           } else {

package/src/assets/scripts/claude-md-audit.cjs

@@ -347,21 +347,71 @@ function readStampFile(stampPath) {
 
 // ── The walk ───────────────────────────────────────────────────────────────────
 
+/**
+ * Scan the head of the file at `p` for imports. It reads at most SCAN_BYTES and no
+ * more than `remaining`, the bytes the run may still read, and it changes nothing
+ * outside itself. `cut` is true when the run's byte budget shortens the scan, so
+ * imports may be missed.
+ *
+ * @param {string} p
+ * @param {number} size  the file's size in bytes
+ * @param {number} remaining
+ * @returns {{ tokens: string[], bytes: number, cut: boolean }}
+ */
+function scanImports(p, size, remaining) {
+  const cut = remaining < Math.min(size, SCAN_BYTES);
+  const want = Math.min(size, SCAN_BYTES, remaining);
+  if (want <= 0) return { tokens: [], bytes: 0, cut };
+  const head = readHead(p, want);
+  if (head === null) return { tokens: [], bytes: 0, cut };
+  return { tokens: extractImports(head.text), bytes: head.bytes, cut };
+}
+
+/**
+ * The figures of one root from its `members`, which are in the order the walk reached
+ * them, breadth-first: whether the root exists, its size, the chain total, the largest
+ * file and the findings. The largest file is the first of the biggest, so a tie goes to
+ * the shorter route. It is pure.
+ *
+ * @param {string} rootPath
+ * @param {{ path: string, size: number, mtime: number, hop: number }[]} members
+ * @param {boolean} truncated  whether the walk was cut short
+ */
+function summarizeMembers(rootPath, members, truncated) {
+  let total = 0;
+  let largest = null;
+  let exists = false;
+  let size = 0;
+  let mtime = 0;
+  const findings = [];
+  for (const m of members) {
+    total += m.size;
+    if (m.hop === 0) {
+      exists = true;
+      size = m.size;
+      mtime = m.mtime;
+    }
+    if (largest === null || m.size > largest.size) largest = { path: m.path, size: m.size };
+    if (m.hop >= 1 && m.size > FILE_THRESHOLD_BYTES) {
+      findings.push({ kind: 'file', path: m.path, size: m.size, mtime: m.mtime, hop: m.hop });
+    }
+  }
+  if (total > CHAIN_THRESHOLD_BYTES && largest !== null) {
+    findings.push({ kind: 'chain', path: rootPath, total, mtime, largest, truncated });
+  }
+  return { exists, size, total, largest, findings };
+}
+
 /**
  * Walk one root's import chain breadth-first, so a file reached by two routes is
- * judged at its shortest hop count.
+ * judged at its shortest hop count. This is the only function that changes the run's
+ * context `ctx`.
  */
 function walkRoot(rootPath, ctx) {
   const examined = new Map();
   const seenReal = new Set();
   const members = [];
-  const fileFindings = [];
-  let total = 0;
-  let largest = null;
   let truncated = false;
-  let exists = false;
-  let rootSize = 0;
-  let rootMtime = 0;
   const queue = [{ p: rootPath, hop: 0 }];
   const queued = new Set([rootPath]);
 
@@ -389,32 +439,16 @@ function walkRoot(rootPath, ctx) {
     seenReal.add(real);
     ctx.counted.add(real);
 
-    const mtime = Math.floor(st.mtimeMs / 1000);
-    total += st.size;
-    members.push({ path: p, size: st.size, mtime, hop });
-    if (hop === 0) {
-      exists = true;
-      rootSize = st.size;
-      rootMtime = mtime;
-    }
-    if (largest === null || st.size > largest.size) largest = { path: p, size: st.size };
-    if (hop >= 1 && st.size > FILE_THRESHOLD_BYTES) {
-      fileFindings.push({ kind: 'file', path: p, size: st.size, mtime, hop });
-    }
+    members.push({ path: p, size: st.size, mtime: Math.floor(st.mtimeMs / 1000), hop });
     if (hop >= MAX_HOPS) continue;
 
-    const remaining = MAX_BYTES_READ - ctx.bytesRead;
-    const want = Math.min(st.size, SCAN_BYTES, remaining);
-    if (remaining < Math.min(st.size, SCAN_BYTES)) {
-      // The run's byte budget cuts this scan short: imports may be missed, so the total is a lower bound.
+    const scan = scanImports(p, st.size, MAX_BYTES_READ - ctx.bytesRead);
+    if (scan.cut) {
       truncated = true;
       ctx.truncated = true;
     }
-    if (want <= 0) continue;
-    const head = readHead(p, want);
-    if (head === null) continue;
-    ctx.bytesRead += head.bytes;
-    for (const token of extractImports(head.text)) {
+    ctx.bytesRead += scan.bytes;
+    for (const token of scan.tokens) {
       const next = resolveImport(token, p, ctx.home);
       if (examined.has(next) || queued.has(next)) continue;
       queued.add(next);
@@ -422,28 +456,9 @@ function walkRoot(rootPath, ctx) {
     }
   }
 
-  const findings = [...fileFindings];
-  if (total > CHAIN_THRESHOLD_BYTES && largest !== null) {
-    findings.push({
-      kind: 'chain',
-      path: rootPath,
-      total,
-      mtime: rootMtime,
-      largest,
-      truncated,
-    });
-  }
-  return {
-    path: rootPath,
-    exists,
-    size: rootSize,
-    total,
-    largest,
-    truncated,
-    members,
-    examined: [...examined.entries()].map(([p, flag]) => ({ path: p, flag })),
-    findings,
-  };
+  const { exists, size, total, largest, findings } = summarizeMembers(rootPath, members, truncated);
+  const examinedList = [...examined.entries()].map(([p, flag]) => ({ path: p, flag }));
+  return { path: rootPath, exists, size, total, largest, truncated, examined: examinedList, findings };
 }
 
 // ── Findings: keys and display ─────────────────────────────────────────────────
@@ -546,7 +561,7 @@ function audit(input) {
   const stamp = renderStamp({ roots: input.roots, examined, keys });
   return {
     ok: true,
-    roots: roots.map(({ members: _members, examined: _examined, findings: _findings, ...rest }) => rest),
+    roots: roots.map(({ examined: _examined, findings: _findings, ...rest }) => rest),
     findings,
     examined,
     filesExamined: ctx.counted.size,