@if (findingsSectionAvailable()) {
  <sm-collapsible-section
    [title]="texts.sections.findings"
    [expanded]="expanded()"
    toggleTestid="inspector-findings-toggle"
    (toggle)="toggle.emit()"
    data-testid="inspector-findings"
  >
    @if (issues().length + aiActionFindings().length > 0) {
      <span class="sm-block__count" smSectionTitleExtra>({{
        issues().length + aiActionFindings().length
      }})</span>
    }
    @if (expanded()) {
      <div class="inspector__findings-body">
        <!-- Severity chips (queue-chip pattern) + Clear all. Chips carry
             the combined live count over both lists and toggle that
             tier's visibility; Clear all row-dismisses every VISIBLE AI
             finding (reversible, dismissed bucket). -->
        @if (issues().length + aiActionFindings().length > 0) {
          <div class="inspector__findings-toolbar">
            <div
              class="inspector__severity-chips"
              role="group"
              [attr.aria-label]="texts.findingsFilter.groupLabel"
            >
              @for (chip of severityChips(); track chip.severity) {
                <button
                  type="button"
                  class="inspector__severity-chip"
                  [class.is-on]="chip.active"
                  [attr.data-severity]="chip.severity"
                  [attr.aria-pressed]="chip.active"
                  [pTooltip]="chip.label"
                  tooltipPosition="top"
                  [attr.aria-label]="texts.findingsFilter.chipAriaLabel(chip.label, chip.count, chip.active)"
                  (click)="toggleSeverity(chip.severity)"
                  [attr.data-testid]="'inspector-findings-chip-' + chip.severity"
                >
                  <i [class]="chip.icon" aria-hidden="true"></i>
                  <span class="inspector__severity-chip-count">{{ chip.count }}</span>
                </button>
              }
            </div>
            @if (visibleAiFindings().length > 0) {
              <button
                type="button"
                class="inspector__findings-clear"
                [disabled]="clearingAll()"
                [pTooltip]="texts.findingsDismissAll.tooltip"
                tooltipPosition="top"
                [attr.aria-label]="texts.findingsDismissAll.ariaLabel(visibleAiFindings().length)"
                (click)="onDismissAll()"
                data-testid="inspector-findings-dismiss-all"
              >
                <i class="pi pi-times" aria-hidden="true"></i>
                <span>{{ texts.findingsDismissAll.label }}</span>
              </button>
            }
          </div>
        }
        @if (severityFilterEmpty()) {
          <p class="inspector__findings-filter-empty" data-testid="inspector-findings-filter-empty">
            {{ texts.findingsFilter.empty }}
          </p>
        }
        <!-- One deterministic-row template, rendered by BOTH lists below
             (the design issues and the observed-in-sessions group), so
             the row anatomy cannot drift between them. -->
        <ng-template #issueRow let-issue>
          <li
            class="inspector__finding"
            [attr.data-severity]="issue.severity"
            data-testid="inspector-finding"
          >
            <div class="inspector__finding-head">
              <span
                class="inspector__finding-severity"
                [attr.data-severity]="issue.severity"
                >{{ issue.severity }}</span
              >
              <code class="inspector__finding-analyzer">{{ issue.analyzerId }}</code>
              @let issueFixer = issueFixerForRow(issue);
              @let dismissValue = issueDismissValue(issue);
              @if (issueFixer !== null || dismissValue !== null) {
                <span class="inspector__finding-actions inspector__finding-actions--push">
                  <!-- AI fix (issueFixers bucket): a probabilistic fixer
                       of THIS deterministic analyzer is enabled and the
                       node has matching open issues, so the affordance
                       rides the row it resolves, never the standalone
                       launcher (user decision 2026-07-22). One submit
                       fixes every matching issue of the node. -->
                  @if (issueFixer; as fixer) {
                    <p-button
                      [icon]="
                        issueFixPhase(fixer) === 'queued' ? 'pi pi-clock' : 'pi pi-sparkles'
                      "
                      severity="info"
                      size="small"
                      [rounded]="true"
                      [text]="true"
                      [disabled]="issueFixDisabled(fixer)"
                      [loading]="issueFixPhase(fixer) === 'running'"
                      [pTooltip]="fixer.description"
                      tooltipPosition="left"
                      appendTo="body"
                      [ariaLabel]="texts.issueFixAriaLabel(fixer.id)"
                      (onClick)="fixIssue(fixer, issue.analyzerId)"
                      [attr.data-testid]="'inspector-issue-fix-' + issue.analyzerId"
                    />
                  }
                  <!-- Per-issue dismiss (2026-07-27): suppress this
                       analyzer for the row's EXACT value (its verbatim
                       data.target) via the node's .sm sidecar, behind
                       the shared consent gate. Rows without a value
                       carry no dismiss key, so they render no X. -->
                  @if (dismissValue !== null) {
                    <p-button
                      icon="pi pi-times"
                      severity="secondary"
                      size="small"
                      [rounded]="true"
                      [text]="true"
                      [disabled]="issueDismissBusy(issue)"
                      [loading]="issueDismissBusy(issue)"
                      [pTooltip]="texts.issueDismissTooltip"
                      tooltipPosition="left"
                      appendTo="body"
                      [ariaLabel]="texts.issueDismissAriaLabel(issue.analyzerId)"
                      (onClick)="dismissIssue(issue)"
                      [attr.data-testid]="'inspector-issue-dismiss-' + issue.analyzerId"
                    />
                  }
                </span>
              }
            </div>
            <p class="inspector__finding-message">{{ issue.message }}</p>
            @if (issue.fix?.summary; as fixSummary) {
              <p class="inspector__finding-hint" data-testid="inspector-finding-hint">
                <strong>{{ texts.findingHintLabel }}</strong> {{ fixSummary }}
              </p>
            }
          </li>
        </ng-template>
        @if (visibleDesignIssues().length > 0) {
          <ul class="inspector__findings-list">
            <!-- Content-keyed track (issues carry no id): a silent
                 refresh that returns the same findings keeps every row's
                 DOM, preserving the no-flicker contract of the issues
                 effect. `$index` only breaks ties between identical
                 findings, so it never causes a rebuild on its own. -->
            @for (
              issue of visibleDesignIssues();
              track issue.analyzerId + '|' + issue.message + '|' + $index
            ) {
              <ng-container *ngTemplateOutlet="issueRow; context: { $implicit: issue }" />
            }
          </ul>
        }
        <!-- Observed-in-sessions group (spec/provider-activity.md,
             Session journal): the `observed-link-missing` rows render
             apart, under their own sub-header, so they read as reality
             commenting on the authored design, never as code defects.
             Same row template and affordances as the list above. -->
        @if (visibleObservedIssues().length > 0) {
          <h4
            class="inspector__findings-subheader"
            data-testid="inspector-observed-sessions-header"
          >
            {{ texts.observedSessionsHeader }}
          </h4>
          <ul class="inspector__findings-list" data-testid="inspector-observed-sessions-list">
            @for (
              issue of visibleObservedIssues();
              track issue.analyzerId + '|' + issue.message + '|' + $index
            ) {
              <ng-container *ngTemplateOutlet="issueRow; context: { $implicit: issue }" />
            }
          </ul>
        }
        <!-- Probabilistic (AI) finding rows, MIXED into this card
             below the deterministic issues (user call 2026-07-22:
             every finding lives here; the launcher buttons stay in
             the AI actions card). Same row anatomy, plus the
             per-finding actions and the hidden-buckets honesty line. -->
        @if (visibleAiFindings().length > 0) {
          <ul class="inspector__findings-list" data-testid="inspector-ai-actions-list">
            <!-- Finding rows carry a stable DB id, so tracking it keeps
                 row DOM across the silent live refreshes (same
                 no-flicker contract as the deterministic list above).
                 Severity-sorted (error, warn, info) and narrowed by the
                 chips, like the deterministic list. -->
            @for (f of visibleAiFindings(); track f.id) {
              <li
                class="inspector__finding"
                [attr.data-severity]="f.severity"
                [attr.data-testid]="'inspector-ai-action-' + f.id"
              >
                <div class="inspector__finding-head">
                  <span
                    class="inspector__finding-severity"
                    [attr.data-severity]="f.severity"
                    >{{ f.severity }}</span
                  >
                  <code class="inspector__finding-analyzer">{{ f.type }}</code>
                  <!-- Inline origin mark: the kernel's safety lane
                       authored this row, the extension it names is
                       only the run that surfaced it. Without the
                       mark the operator reads it as that
                       extension's own judgment. -->
                  @if (f.origin === 'kernel') {
                    <span
                      class="inspector__finding-kernel"
                      [pTooltip]="texts.aiActions.finding.kernelTagTooltip"
                      tooltipPosition="top"
                      [attr.data-testid]="'inspector-finding-kernel-' + f.id"
                      >{{ texts.aiActions.finding.kernelTag }}</span
                    >
                  }
                  <!-- Inline stale mark: stale rows ride the tray
                       (never a hidden bucket, user call 2026-07-20). -->
                  @if (f.stale) {
                    <span
                      class="inspector__finding-stale"
                      [pTooltip]="texts.aiActions.finding.staleTagTooltip"
                      tooltipPosition="top"
                      [attr.data-testid]="'inspector-finding-stale-' + f.id"
                      >{{ texts.aiActions.finding.staleTag }}</span
                    >
                  }
                  <!-- The fixer left this one to the author: no fix
                       button (the gate refuses to re-inject it), the
                       mark says why. -->
                  @if (f.resolution === 'human-decision') {
                    <span
                      class="inspector__finding-decision"
                      [pTooltip]="texts.aiActions.finding.decisionTagTooltip"
                      tooltipPosition="top"
                      [attr.data-testid]="'inspector-finding-decision-' + f.id"
                      >{{ texts.aiActions.finding.decisionTag }}</span
                    >
                  }
                  <span
                    class="inspector__ai-action-provenance"
                    [attr.data-testid]="'inspector-ai-action-provenance-' + f.id"
                    >{{ aiActionConfidenceModel(f) }}</span
                  >
                  <span class="inspector__ai-action-id" aria-hidden="true">#{{ f.id }}</span>
                  <!-- Per-finding actions: AUTOMATIC fix (queue the
                       fixer, when the finder has one), manual mark
                       fixed, or dismiss (hide the class; reversible). -->
                  <span class="inspector__finding-actions">
                    @if (aiActionFindingFixable(f)) {
                      <p-button
                        [icon]="
                          aiActionFindingFixPhase(f) === 'queued'
                            ? 'pi pi-clock'
                            : 'pi pi-sparkles'
                        "
                        severity="info"
                        size="small"
                        [rounded]="true"
                        [text]="true"
                        [disabled]="aiActionFindingFixDisabled(f)"
                        [loading]="aiActionFindingFixPhase(f) === 'running'"
                        [pTooltip]="texts.aiActions.finding.fixTooltip"
                        tooltipPosition="left"
                        appendTo="body"
                        [ariaLabel]="texts.aiActions.finding.fixAriaLabel(f.id)"
                        (onClick)="fixAiActionFinding(f)"
                        [attr.data-testid]="'inspector-finding-fix-' + f.id"
                      />
                    }
                    <!-- The manual pair disables while the AUTOMATIC
                         fix is queued / running: resolving or
                         dismissing a finding mid-fix contradicts the
                         fixer already working on it. -->
                    <p-button
                      icon="pi pi-wrench"
                      severity="success"
                      size="small"
                      [rounded]="true"
                      [text]="true"
                      [disabled]="aiActionFindingBusy(f.id) || aiActionFindingFixBusy(f)"
                      [loading]="aiActionFindingBusy(f.id)"
                      [pTooltip]="texts.aiActions.finding.resolveTooltip"
                      tooltipPosition="left"
                      appendTo="body"
                      [ariaLabel]="texts.aiActions.finding.resolveAriaLabel(f.id)"
                      (onClick)="resolveAiActionFinding(f)"
                      [attr.data-testid]="'inspector-finding-resolve-' + f.id"
                    />
                    <p-button
                      icon="pi pi-times"
                      severity="secondary"
                      size="small"
                      [rounded]="true"
                      [text]="true"
                      [disabled]="aiActionFindingBusy(f.id) || aiActionFindingFixBusy(f)"
                      [loading]="aiActionFindingBusy(f.id)"
                      [pTooltip]="texts.aiActions.finding.dismissTooltip"
                      tooltipPosition="left"
                      appendTo="body"
                      [ariaLabel]="texts.aiActions.finding.dismissAriaLabel(f.id)"
                      (onClick)="dismissAiActionFinding(f)"
                      [attr.data-testid]="'inspector-finding-dismiss-' + f.id"
                    />
                  </span>
                </div>
                <p class="inspector__finding-message">{{ f.message }}</p>
              </li>
            }
          </ul>
        }
        <!-- Hidden-buckets honesty line (mirror of the CLI's
             "N dismissed, M fixed, K stale hidden"): one chip per
             non-zero bucket, click reveals that bucket below. -->
        @if (aiActionHiddenBuckets().length > 0) {
          <div class="inspector__ai-hidden" data-testid="inspector-ai-hidden">
            @for (chip of aiActionHiddenBuckets(); track chip.bucket) {
              <button
                type="button"
                class="inspector__ai-hidden-chip"
                [class.is-on]="chip.revealed"
                [attr.aria-pressed]="chip.revealed"
                [pTooltip]="texts.aiActions.hidden.chipTooltip"
                tooltipPosition="top"
                (click)="toggleAiActionBucket(chip.bucket)"
                [attr.data-testid]="'inspector-ai-hidden-' + chip.bucket"
              >
                {{ aiActionHiddenChipLabel(chip) }}
              </button>
            }
          </div>
          @if (aiActionRevealedBucket(); as bucket) {
            <!-- Delete all over the REVEALED rows: the per-row X for the
                 whole open bucket at once, permanent. Scoped to what the
                 operator opened, never to hidden rows. -->
            @if (aiActionRevealedRows().length > 0) {
              <div class="inspector__ai-revealed-actions">
                <button
                  type="button"
                  class="inspector__findings-clear inspector__findings-clear--danger"
                  [disabled]="deletingAll()"
                  [pTooltip]="texts.aiActions.revealedDeleteAll.tooltip"
                  tooltipPosition="top"
                  [attr.aria-label]="texts.aiActions.revealedDeleteAll.ariaLabel(aiActionRevealedRows().length)"
                  (click)="onDeleteAllRevealed()"
                  data-testid="inspector-ai-revealed-delete-all"
                >
                  <i class="pi pi-trash" aria-hidden="true"></i>
                  <span>{{ texts.aiActions.revealedDeleteAll.label }}</span>
                </button>
              </div>
            }
            <ul
              class="inspector__findings-list inspector__findings-list--revealed"
              data-testid="inspector-ai-revealed-list"
            >
              @for (f of aiActionRevealedRows(); track f.id) {
                <li
                  class="inspector__finding inspector__finding--revealed"
                  [attr.data-severity]="f.severity"
                  [attr.data-testid]="'inspector-ai-revealed-' + f.id"
                >
                  <div class="inspector__finding-head">
                    <span
                      class="inspector__finding-severity"
                      [attr.data-severity]="f.severity"
                      >{{ f.severity }}</span
                    >
                    <code class="inspector__finding-analyzer">{{ f.type }}</code>
                    @if (f.origin === 'kernel') {
                      <span
                        class="inspector__finding-kernel"
                        [pTooltip]="texts.aiActions.finding.kernelTagTooltip"
                        tooltipPosition="top"
                        [attr.data-testid]="'inspector-revealed-finding-kernel-' + f.id"
                        >{{ texts.aiActions.finding.kernelTag }}</span
                      >
                    }
                    @if (f.stale) {
                      <span
                        class="inspector__finding-stale"
                        [pTooltip]="texts.aiActions.finding.staleTagTooltip"
                        tooltipPosition="top"
                        >{{ texts.aiActions.finding.staleTag }}</span
                      >
                    }
                    <!-- Human-decided fix: the operator approved or
                         chose it (user ask 2026-07-26, the stale
                         treatment in the theme's primary color). -->
                    @if (bucket === 'fixed' && f.resolutionActor === 'human') {
                      <span
                        class="inspector__finding-human"
                        [pTooltip]="texts.aiActions.finding.humanTagTooltip"
                        tooltipPosition="top"
                        [attr.data-testid]="'inspector-revealed-finding-human-' + f.id"
                        >{{ texts.aiActions.finding.humanTag }}</span
                      >
                    }
                    <span class="inspector__ai-action-provenance">{{
                      aiActionConfidenceModel(f)
                    }}</span>
                    <span class="inspector__ai-action-id" aria-hidden="true">#{{ f.id }}</span>
                    <!-- Dismissed rows: restore + delete; fixed rows:
                         delete only. The delete X hard-removes the row
                         from the DB (no consent, no sidecar touch). -->
                    @if (bucket === 'dismissed' || bucket === 'fixed') {
                      <span class="inspector__finding-actions">
                        @if (bucket === 'dismissed') {
                          <p-button
                            icon="pi pi-undo"
                            severity="secondary"
                            size="small"
                            [rounded]="true"
                            [text]="true"
                            [disabled]="aiActionFindingBusy(f.id)"
                            [loading]="aiActionFindingBusy(f.id)"
                            [pTooltip]="texts.aiActions.finding.restoreTooltip"
                            tooltipPosition="left"
                            appendTo="body"
                            [ariaLabel]="texts.aiActions.finding.restoreAriaLabel(f.id)"
                            (onClick)="restoreAiActionFinding(f)"
                            [attr.data-testid]="'inspector-finding-restore-' + f.id"
                          />
                        }
                        <p-button
                          icon="pi pi-times"
                          severity="danger"
                          size="small"
                          [rounded]="true"
                          [text]="true"
                          [disabled]="aiActionFindingBusy(f.id)"
                          [loading]="aiActionFindingBusy(f.id)"
                          [pTooltip]="texts.aiActions.finding.deleteTooltip"
                          tooltipPosition="left"
                          appendTo="body"
                          [ariaLabel]="texts.aiActions.finding.deleteAriaLabel(f.id)"
                          (onClick)="deleteAiActionFinding(f)"
                          [attr.data-testid]="'inspector-finding-delete-' + f.id"
                        />
                      </span>
                    }
                  </div>
                  <p class="inspector__finding-message">{{ f.message }}</p>
                </li>
              }
            </ul>
          }
        }
      </div>
    }
  </sm-collapsible-section>
}