devflow-kit 3.5.0 → 3.7.0

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/git/_pr.mds

@@ -260,6 +260,8 @@ Load for `check-merge-readiness` under every tracker provider.
 
 ### Process
 
+Run the script from `WORKTREE_PATH` (else cwd) and print its stdout, nothing else: `node "$HOME/.devflow/scripts/verify-evidence.cjs" readiness --pr {PR_NUMBER}; echo "exit=$?"`, adding `--require-non-author-approval {REQUIRE_NON_AUTHOR_APPROVAL}` only when that is `true` or `false`, with the Bash `timeout` at 180000. On exit 0 or 2 its stdout is the `## Merge Readiness` block (exit 2: `DEGRADED`, closed by a `TRACEABILITY: DEGRADED ({reason})` line); any other exit, or empty stdout, is `TRACEABILITY: DEGRADED (readiness unavailable)`. The script makes the reads and applies the ladder below, so the steps are its specification: run none of them yourself.
+
 1. Fetch unresolved review threads via GraphQL: `reviewThreads(first: 100) { nodes { isResolved } totalCount }`. Count unresolved from nodes (`isResolved == false`). If `totalCount > 100`, report the unresolved count as approximate: prefix with `>` and note `(count approximate — PR has more than 100 threads)`.
 2. Fetch PR review decision: `gh pr view {PR_NUMBER} --json reviewDecision --jq '.reviewDecision'`
    - Values: `APPROVED`, `CHANGES_REQUESTED`, `REVIEW_REQUIRED`, or null
@@ -289,16 +291,14 @@ Never take action on the PR — report READY or NOT_READY, always with the speci
 
 Load for `update-pr-evidence` under every tracker provider.
 
-**PR mechanics held here:** the evidence script run, the compare-and-swap body edit and the append-only evidence comment. The script owns every marker, grammar and state rule; nothing here restates one.
+**PR mechanics held here:** the one script run. `verify-evidence.cjs publish` owns every step, marker, grammar and state rule, and scrubs (D11) each body before it posts one; nothing here restates any of them.
 
 ### Process
 
-Run steps 1–4 as ONE Bash invocation from `WORKTREE_PATH` (else cwd) — the trap removes `$S` and the temp files when it exits — with `V="$HOME/.devflow/scripts"`.
+1. From `WORKTREE_PATH` (else cwd), run `node "$HOME/.devflow/scripts/verify-evidence.cjs" publish --pr {PR_NUMBER}; echo "exit=$?"`, adding `--publication {REVIEW_PUBLICATION}` only when that is `auto`, `full`, `off` or `stub`, and `--evidence "{EVIDENCE_FILE}"` when given — only a value matching `^[A-Za-z0-9._/-]{1,255}$` reaches the shell; any other is a failed run. Set the Bash `timeout` to 180000.
+2. Print the script's stdout and nothing else. On exit 0 it is the `## PR Evidence` block: the heading, the line `EVIDENCE pr:<n> head:<sha> total:<n> VERIFIED-CI:<n> ATTESTED-LOCAL:<n> UNVERIFIED:<n> STALE:<n> FAILED:<n> INDETERMINATE:<n> stale:<ids|none> exceptions:<kinds|none> approval:<yes|no|unchecked> key:<hex> posted:<yes|no|n/a> body:<same|changed>`, and the `**Body**:` / `**Comment**:` line, then one `TRACEABILITY: DEGRADED ({reason})` line for each part that degraded, such as `DEGRADED (concurrent edit)` (the body edit then reads `SKIPPED`), `DEGRADED (body read-back mismatch)` or `DEGRADED (redaction unavailable)`: a body the script cannot scrub is never posted. On exit 2 it is `TRACEABILITY: DEGRADED (evidence unavailable)`. Any other exit, or empty stdout, is a failed run: emit that same line.
 
-1. **Verify.** Set `S=`, arm the D11 trap with `[ -n "$S" ] && { rm -- "$S/base" "$S/base.sha256"; rmdir -- "$S"; } 2>/dev/null` added before its `exit`, then the four `mktemp`s and `S="$(mktemp -d)"`. Run `node "$V/verify-evidence.cjs" verify --pr {PR_NUMBER} --state "$S" --block-out "$DEVFLOW_NOTES_RAW" --comment-out "$DEVFLOW_BODY_RAW"`, adding `--publication {REVIEW_PUBLICATION}` only when that is `auto`, `full`, `off` or `stub`, and `--evidence "{EVIDENCE_FILE}"` when given — only a value matching `^[A-Za-z0-9._/-]{1,255}$` reaches the shell; any other is a failed run. Continue only on exit 0 with stdout exactly one line, `EVIDENCE pr:<n> head:<sha> total:<n> VERIFIED-CI:<n> ATTESTED-LOCAL:<n> UNVERIFIED:<n> STALE:<n> FAILED:<n> INDETERMINATE:<n> stale:<ids|none> exceptions:<kinds|none> approval:<yes|no|unchecked> key:<hex> posted:<yes|no|n/a> body:<same|changed>`; otherwise emit `TRACEABILITY: DEGRADED (evidence unavailable)` and stop. The script makes this op's one `gh pr view` read and prints nothing it read from the PR; never read the PR another way.
-2. **Body**, only on `body:changed` (else `UNCHANGED`): `node "$V/redact-secrets.cjs" "$DEVFLOW_NOTES_RAW" "$DEVFLOW_NOTES" && node "$V/verify-evidence.cjs" splice --pr {PR_NUMBER} --state "$S" --block "$DEVFLOW_NOTES" --out "$DEVFLOW_BODY" && gh pr edit {PR_NUMBER} --body-file "$DEVFLOW_BODY"`. Only the composed block is scrubbed (D11); every byte outside its markers is the PR's own and stays identical. `splice` re-reads the body: unchanged since step 1 → it writes; changed → it splices once onto the fresh body and re-reads; changed again → `SPLICE conflict`: `SKIPPED` and `TRACEABILITY: DEGRADED (concurrent edit)`. Any other non-zero → `DEGRADED ({reason})`, naming a printed `SPLICE` token. No edit either way; go to step 4.
-3. **Read back** after an edit: `node "$V/verify-evidence.cjs" readback --pr {PR_NUMBER} --expect "$DEVFLOW_BODY"`; anything but `READBACK ok` → `TRACEABILITY: DEGRADED (body read-back mismatch)`, else `EDITED`. GitHub has no conditional body edit: a human edit landing between the last re-read and `gh pr edit` is overwritten (it stays in the PR's edit history), and the read-back proves only that these bytes landed.
-4. **Comment.** `posted:yes` → `SKIPPED`; `posted:n/a` → `OFF`. Otherwise apply the Comment-sink scrub (D11): `node "$V/redact-secrets.cjs" "$DEVFLOW_BODY_RAW" "$DEVFLOW_BODY" && gh pr comment {PR_NUMBER} --body-file "$DEVFLOW_BODY"` → `POSTED`. Never edit or delete an evidence comment. On 5xx retry once; still 5xx → `DEGRADED ({reason})`.
+Run nothing else: the script makes the one PR read, the compare-and-swap body edit, its read-back and the append-only comment itself, and posts nothing it could not scrub.
 @end
 
 <!-- op: validate-branch -->

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,

package/src/assets/scripts/hooks/assets/orchestrator-charter.md

@@ -5,16 +5,17 @@ Never do work-product mainline: no file edits, no builds, no multi-file reads, n
 
 Routing (Agent tool) — pick the roster agent that fits the work:
 - Search and listing: Explore. Codebase orientation: Skim.
-- Execution against a spec: Code (write code to a plan; open the prompt with `OPERATION: <mode>` — `issue-fix` for pre-classified review issues, else `implement`), Code-edit (mechanical changes: renames, moves, boilerplate; `OPERATION: edit`), Validate (build, typecheck, lint, test), Git (git/GitHub operations).
+- Execution against a spec: Code (write code to a plan; open the prompt with `OPERATION: <mode>` — `issue-fix` for pre-classified review issues, else `implement`), Refactor (a given mechanical change: "rename X to Y everywhere", moves, boilerplate; `OPERATION: edit`), Polish (judgment pass for clarity that keeps behaviour: "make this code cleaner"), Validate (build, typecheck, lint, test), Git (git/GitHub).
+- Bug fix: Code (`OPERATION: implement`; `issue-fix` only for Triage-classified review issues). Fix: gate failures only (`validation-fix`, `alignment-fix`, `qa-fix`, `ci-fix`).
 - Analysis, design, research: Design, Research, Review, Triage (validate review issues against blast-radius matrix).
-- Real-scale work that matches a workflow: invoke the full skill instead — devflow:implement, devflow:plan, devflow:research, devflow:explore, devflow:debug, devflow:code-review, devflow:resolve.
+- Real-scale work matching a workflow: invoke the full skill instead — devflow:implement, devflow:plan, devflow:research, devflow:explore, devflow:debug (all debug work, never the Debug agent), devflow:code-review, devflow:resolve.
 - Anything else: the closest roster agent, never general-purpose.
 
 Stays mainline (judgment work): conversation, decisions, routing, synthesizing agent reports, answers already in loaded context, one targeted Read to scope a delegation.
 
 Operating rules:
 - Decompose mainline. Subagents cannot spawn subagents — you own task breakdown, then delegate leaf tasks.
-- Subagents see none of this conversation. Make every delegation self-contained: goal, constraints, relevant session decisions and facts, exact paths. A deliverable that draws on the conversation (issue, PR, report) needs the substance in the prompt — not a pointer to it.
+- Subagents see none of this conversation. Make every delegation self-contained: goal, constraints, relevant session decisions and facts, exact paths. A deliverable that draws on the conversation (issue, PR, report) needs its substance in the prompt, not a pointer.
 - Report cap: ask every direct delegation for a final report of at most about 1,500 tokens — findings, paths and verdicts, not file dumps.
 - Parallelize independent delegations in one message. Git operations stay sequential.
 - Feature knowledge (direct delegations only — workflow skills handle their own): before delegating non-trivial code work, match the task area against .devflow/features/index.md and pass each matching KB's one to three most relevant `## Rules` bullets (verbatim, IDs included; a KB without Rules: Anti-Patterns or Gotchas entries, cited by section), its path and its `##` heading index as FEATURE_KNOWLEDGE; after delegated changes to a covered area, spawn Knowledge to refresh that KB.