Real-time monitoring dashboard for Proxmox VE, PBS, Docker, Kubernetes, TrueNAS and vSphere. Self-hosted, with alerts for failed backups, full disks, unhealthy containers and offline nodes.
Go aialertsdashboarddockerdocker-monitoringgohomelabinfrastructure-monitoringkubernetesmonitoringmspproxmoxproxmox-backup-serverproxmox-mail-gatewayproxmox-veself-hostedtruenastypescriptvspherewebhooks
Merge pending maintenance repairs with current main
rcourtman2fc54a5a1f55
diff --cc .github/workflows/unified-agent-native.ymlindex 3b7cf0d281,365e454c9a..a979545d77--- a/.github/workflows/unified-agent-native.yml+++ b/.github/workflows/unified-agent-native.yml@@@ -183,6 -168,69 +168,69 @@@ jobsset -euo pipefailtimeout --version | grep -q 'GNU coreutils'+ # Server/LXC fixtures execute Linux-only scripts, not a macOS installer.+ # Keep their Bash/GNU metadata, archive and rename semantics local to that step;+ # native macOS agent/runtime tests still use the runner's own utilities.+ - name: Supply Linux server installer fixture tools on macOS+ if: runner.os == 'macOS'+ shell: bash+ run: |+ set -euo pipefail+ brew install bash gnu-tar gawk+ linux_bash="$(brew --prefix bash)/bin/bash"+ test -x "$linux_bash"+ "$linux_bash" -c '(( BASH_VERSINFO[0] >= 5 ))'+ coreutils_bin="$(brew --prefix coreutils)/bin"+ fixture_bin="$(mktemp -d "$RUNNER_TEMP/pulse-installer-fixture-tools.XXXXXX")"+ ln -s "$linux_bash" "$fixture_bin/bash"- for tool in stat chmod chown mv; do++ for tool in stat chmod chown mv ln; do+ executable="$coreutils_bin/g$tool"+ test -x "$executable"+ "$executable" --version | grep -q 'GNU coreutils'+ ln -s "$executable" "$fixture_bin/$tool"+ done+ gnu_tar="$(brew --prefix gnu-tar)/bin/gtar"+ test -x "$gnu_tar"+ "$gnu_tar" --version | grep -q 'GNU tar'+ ln -s "$gnu_tar" "$fixture_bin/tar"+ # The NAS boot filter rejects embedded NUL/control bytes with octal+ # ranges. Use the same binary-aware awk semantics as its Linux jobs,+ # not the native macOS parser, only within these server fixtures.+ gnu_awk="$(brew --prefix gawk)/bin/gawk"+ test -x "$gnu_awk"+ "$gnu_awk" --version | grep -q 'GNU Awk'+ ln -s "$gnu_awk" "$fixture_bin/awk"+ printf 'PULSE_INSTALLER_FIXTURE_BIN=%s\n' "$fixture_bin" >> "$GITHUB_ENV"++ # Observe the existing generated NAS watchdog/collector control before+ # Node acquisition and the large installer inventory. The runner's two+ # phases partition the same discovered checks; no check runs twice or is+ # dropped, and the production process/cleanup deadlines stay unchanged.+ - name: Test NAS removal contracts before frontend preparation+ if: matrix.unix+ shell: bash+ run: |+ set -euo pipefail+ if [[ -n "${PULSE_INSTALLER_FIXTURE_BIN:-}" ]]; then+ export PATH="$PULSE_INSTALLER_FIXTURE_BIN:$PATH"+ fi+ python3 scripts/installtests/run_unix_contracts.py --phase preflight++ - name: Set up Node.js for native runtime test assets+ uses: actions/setup-node@949feb2413d6458794dcd2491c4babbbce0c15c1 # v7.1.0+ with:+ node-version: '24'+ cache: 'npm'+ cache-dependency-path: 'frontend-modern/package-lock.json'++ - name: Install frontend test dependencies+ working-directory: frontend-modern+ run: npm ci++ - name: Build real frontend assets for API-linked native tests+ working-directory: frontend-modern+ run: npm run build+- name: Test native agent runtimerun: >-go testdiff --cc docs/UPGRADE_v6.mdindex ec3222b328,bfef9cf395..482bb3f0df--- a/docs/UPGRADE_v6.md+++ b/docs/UPGRADE_v6.md@@@ -1,11 -1,16 +1,16 @@@# Upgrade to Pulse v6- This guide covers practical upgrade steps for existing Pulse installs moving to v6.+ This guide covers the v5-to-v6 migration and its compatibility changes. For+ updates within v6, use [Updating Pulse](AUTO_UPDATE.md); the historical packets+ below are context, not an instruction to install an old version or downgrade.+ Choose an actually [published software release](https://github.com/rcourtman/Pulse/releases),+ not a draft, source tag or Helm-chart asset. Keep the existing runtime edition:+ public Community downloads do not replace a private Pro build.-For the current v6 beta packet, see:+For the current v6 release candidate packet, see:-- `docs/releases/RELEASE_NOTES_v6.6.0-beta.3.md`-- `docs/releases/V6_CHANGELOG_v6.6.0-beta.3.md`+- `docs/releases/RELEASE_NOTES_v6.6.0-rc.4.md`+- `docs/releases/V6_CHANGELOG_v6.6.0-rc.4.md`For the current stable v6 packet, see:diff --cc docs/release-control/v6/internal/subsystems/agent-lifecycle.mdindex 1a1edcbf43,160e55bce6..56c97ef559--- a/docs/release-control/v6/internal/subsystems/agent-lifecycle.md+++ b/docs/release-control/v6/internal/subsystems/agent-lifecycle.md@@@ -15,38 -15,92 +15,124 @@@## Purpose+### Lost container mutation acknowledgements reconcile through reads++Typed container lifecycle execution attempts its mutation once. A transport+error preserves uncertain execution and, while the original operation context+remains live, reads the same container and waits for its existing health check.+Readback never manufactures a mutation acknowledgement or extends a canceled+operation. Fixed, non-sensitive timeout/cancellation/unknown messages survive+receipt sanitization. `docker_lifecycle_test.go` covers lost acknowledgement,+health recovery, cancellation, exactly-once mutation and receipt redaction.+++### Verified agent actions remain attached to their originating occurrence++An agent action's execution and verification evidence belongs to its original+action and investigation. Replaying that result after a finding reopens must+preserve the new occurrence's investigation eligibility and current record.+The shared findings store validates session identity and the persisted+regression boundary atomically; current finding reads select current work+while explicit action history retains earlier receipts. The three-occurrence+Patrol action regression in+`internal/api/ai_handlers_patrol_actions_additional_test.go` also reconstructs+persisted findings and action audit state before the third occurrence.++### Collected backup evidence does not require command-agent access++Guest investigation manifests include the existing read-only storage tool for+collected backup attempts. The org-scoped recovery reader preserves task error+text independently of PVE command clients and connected agents. Missing command+access remains an execution boundary; reading a failure or a successful task+does not grant a lifecycle action or prove a restorable artifact. Manifest,+persisted-task and API/tool parity regressions cover this separation.++ ### Native CI tooling refresh (14 October 2026)++ The native agent matrix uses the exact setup-node v7.1.0 and upload-artifact+ v7.0.2 pins in the [deployment tooling contract](deployment-installability.md#node-setup-and-artifact-action-refresh-14-october-2026).+ The Node 24 application toolchain, locked frontend cache, real asset build before+ all-platform runtime tests, generated Windows command execution and retained+ Linux removal receipt are unchanged. `TestNativeAgentWorkflowBuildsRealFrontendBeforeRuntime`,+ `TestNativeAgentRejectsBrokenImagesBeforeFrontendPreparation` and+ `TestNativeWindowsExecutesGeneratedInstallCommand` bind those actual consumers+ to the refreshed pin without relaxing ordering or platform controls. Local+ source proof is not native Windows, appliance or installed lifecycle acceptance.++ ### Optional configuration-signing guidance fits narrow installers (13 October 2026)++ The three existing signing environment names wrap within their advice card.+ Their complete text, values, optional semantics, trust defaults and copied+ installation/removal commands are unchanged. The source regression in+ `InfrastructureOperationsModel.test.tsx` preserves those exact names and the+ wrapping class; desktop/phone light/dark browser proof must inspect the actual+ installer and preserve separate-token/private-file copy behaviour. This is+ readability, not an installed agent or QNAP recovery result.++ ### Backend bootstrap preserves silent input on BusyBox hosts++ Setup, Proxmox and container bootstrap commands prefer standalone `stty`,+ otherwise the BusyBox `stty` applet. They distinguish absent terminals, missing+ or unsupported tools and failed snapshot/echo/restoration before installation.+ The privileged Bash child keeps the selected tool and complete saved terminal+ state through EXIT/HUP/INT/TERM cleanup. Overflow is drained while silent;+ empty, interrupted or oversized input never reaches the installer. The isolated+ POSIX root/sudo prefix emits that child once, without moving credentials into+ shell source, argv, environment or history. Existing complete-download,+ preflight, private-file, scope, profile, identity and TLS boundaries remain.+ `portable_bootstrap_test.go` exercises all three producers with real PTYs and+ BusyBox, full terminal restoration and closed privilege/download fixtures;+ it is not native appliance installation or recovery evidence.++ ### Unraid/QNAP removal retires exact boot entries and confirms watchdog quiescence++ The Unix uninstall caller selects these platforms from their vendor/installed+ footprints, not from an ordinary recovered Linux state directory or QNAP state+ finder alone. Existing exact state-removal authority must select the wrapper's+ state directory. Regular root-owned files and parents are required; FAT boot+ volumes cannot be assumed to implement Unix chmod semantics. Unknown wrapper+ ownership and missing observation tools refuse before mutation.++ One complete bounded boot-file parse admits only the exact generated Unraid+ launch or canonical QNAP deferred block/legacy direct launch for that wrapper.+ All duplicates retire; unrelated entries (including co-installed names and+ legacy Telegraf) remain. Foreign/indirect targets, partial or changed blocks,+ linked/non-regular files, binary/incomplete content and over-1-MiB files refuse+ without evaluating or disclosing their text. The original remains in a private+ `.pulse-removal.*` recovery directory outside the active boot namespace through+ remote confirmation. A changed source during staging or a concurrently created+ file, directory or symlink refuses without clobbering it; interrupted staging+ retains the actual original and never restores automatic activation. New boot+ content uses no-clobber file creation, compatible with FAT without hard links;+ this is not an atomic whole-content swap or a lock against external root writers.++ Complete bounded kernel evidence returns only numeric IDs and roles. Only exact+ selected watchdog/collector processes receive checked TERM, watchdog first,+ with independent absence observations. Editor sessions, backup wrappers and+ co-installed names are not targets. Relative/foreign same-name processes or+ unattributable QNAP deferred autorun or live Unraid go shells refuse instead+ of signalling another boot owner. A live go shell may already hold later boot+ commands in memory; editing its file cannot establish quiescence. Failed/diagnostic/duplicate/empty reads and ignored/refused signals+ retain identity, credentials, trust and recoverable files. QNAP mount and+ unmount each have checked bounded results, including cleanup after partial mount.++ Whole boot/process and applicable init-manager quiescence closes again before+ same-instance server removal and before local erasure; late activation refuses,+ even after remote removal succeeded. NAS paths do not subsequently run the+ unchecked global pkill or delete arbitrary discovered QNAP state/whole legacy+ Unraid directories. Successful/absent/repeated removal still requires complete+ fresh observations. No automatic restart, credential churn or transport-policy+ change follows a partial operation.++ `TestInstallSHNASBootOwnersQuiesceBeforeRecoveryErasure` requires all eighteen+ actual-function/full-uninstall caller controls in `agent_nas_teardown.py`. The+ boot filesystem transformations are real private user operations; flash/kernel+ faults are closed models. Two generated watchdog/child controls use real private+ ordinary-user processes, not appliance mounts or root services. Native signed+ Unraid/QNAP/Linux/PowerShell, TLS/identity/repetition/cleanup and containing+ publication remain separate obligations; this source proof does not resolve+ #1099 or claim installed restoration.+### Patrol maintenance coverage adds no agent authorityThe Patrol operator-state projection in `internal/api/router.go` now reads thediff --cc docs/release-control/v6/internal/subsystems/api-contracts.mdindex 36fbc9aaf5,116d5a271f..5efd96bc41--- a/docs/release-control/v6/internal/subsystems/api-contracts.md+++ b/docs/release-control/v6/internal/subsystems/api-contracts.md@@@ -21,66 -20,19 +21,79 @@@## Purpose+### Reporting telemetry observes canonical generation and delivery boundaries++`internal/api/reporting_activity.go` records best-effort content-free events to+the root config persistence wired through the existing settings-store boundary.+Organization context contributes only to a local opaque deduplication key. Direct+resource and VM inventory downloads count only a full successful response write,+excluding HEAD, cancellation and short writes. Distinct generation days cover+returning manual use without retaining download identities. Scheduled report generation, file+saving and existing SMTP transport outcomes each contribute their own counter.+A successful reporting period is recorded only after final schedule state saves.+Interrupted email recovery records uncertainty after persisting that outcome.+Retries still use the same scheduling/delivery system and frozen reporting window.++No endpoint, report payload, delivery state, retry policy, pricing or entitlement+changes. The activity adapter cannot block a report on tally failure. Scheduler+restart/retry, distinct-period reuse, complete download and mock-suppression proof+lives in `internal/api/reporting_activity_test.go`. Notifications retains SMTP+acceptance authority, and the activity recorder never claims inbox delivery.+The shared adapter is declared by exact path in the paid-surface allowlist.+The real boundary regression rejects sibling reporting implementation files and+private licensing imports added to this observer, preserving the private renderer+and licensing bridge boundaries.+++### Container verification distinguishes transitional health++Both agent and independent lifecycle readbacks classify a running container's+`starting` health as inconclusive, not a final postcondition contradiction.+Execution and verification remain separate axes: a confirmed readback cannot+turn a lost mutation acknowledgement into acknowledged execution. The action+summary retains the agent's sanitized error. The Docker action-result tests+cover this projection without changing receipt protocol versions or authority.+++### Finding-scoped investigation reads belong to the current occurrence++The finding investigation and transcript endpoints return only the session+owned by the finding's current occurrence. After a resolved finding is+re-detected, a retained earlier session returns `404` through these current+views until a new session exists. Explicit session and action history retain+their original evidence. Outcome and record reconciliation check session+identity and the persisted regression boundary under the findings lock before+changing current state. `TestPatrolHistoricalActionCannotResolveRecurringFinding`+in `internal/api/ai_handlers_patrol_actions_additional_test.go` covers three+occurrences, restart, historical reads and duplicate action callbacks.++### Recovery point reads stay coherent between HTTP and investigations++The points endpoint and investigation adapter use the same org-scoped manager+reader. Demo composition reads the canonical fixture graph through the recovery+query helpers; ordinary tenants read their persisted store. Moving the existing+in-memory filters into recovery preserves point, series and facet query semantics+and pagination bounds. The API/tool parity regression checks that a collected+backup failure remains readable without a PVE client or command agent. The+investigation backup inventory uses the same `KindBackup` and canonical subject+query as the points endpoint, retaining point identity, repository references,+tri-state verification and evidence provenance in real and demo modes. Tool+pagination translates global offsets into the shared source's bounded pages.+No route, entitlement, recovery mutation or action approval is added.++ ### Copied backend bootstrap commands have one portable private reader++ Existing setup artifact aliases and Proxmox/container command fields retain+ separate credential response fields. Their command text now selects standalone+ `stty` or, only when absent, BusyBox `stty`, with distinct fail-closed terminal,+ tool and mode diagnostics. One isolated root/sudo prefix emits the privileged+ reader once, preserving complete fetch/preflight and 0700/0600 path handoff.+ No route, payload key, issuance scope, TLS policy or install authority changes.+ `TestContract_PortablePrivateBootstrapPayloads` checks the serialized producer+ boundary; full configapi PTY/tool/privacy/caller tests exercise the commands.+ Browser acceptance must use the actual producer fields through their existing+ setup/agent consumers, not a frontend-file guard skip or fabricated commands.+### Patrol setup panel reuses existing AI endpointsThe Patrol page setup panel adds no endpoint or payload field. It calls@@@ -12470,51 -12217,22 +12496,71 @@@ reference route checks cover caller filFinal-source checks must retain this upstream behavior beside the reviewedreporting/help repairs; source proof is not installed credential recovery.+### Successful extended history HTTP reads++`chartapi.Service.WriteHistoryJSON` and `WriteHistoryPayload` share one+post-write observation boundary for metric history and the main, workload,+infrastructure and storage chart handlers, including cached bytes. Existing+response bodies, range/entitlement checks and failure behavior remain the API+contract. Only GET responses requested beyond seven days that contain a real+returned numeric metric point strictly older than seven days qualify. Long+empty windows, metadata timestamps, failed encoding/writes, cancellation,+HEAD and mock responses cannot increment the tally. Mock and live cache keys+are separated. The optional observer receives no request or content.+`history_activity_test.go` and `telemetry_history_reads_test.go` exercise this+boundary. Schema v19 count semantics and retention belong to security-privacy.++### Saved-node connection tests use draft TLS settings (16 October 2026)++`POST /api/config/nodes/{id}/test` accepts an optional JSON body containing+`verifySSL` and `fingerprint` for PVE, PBS and PMG. Omission retains the saved+value, `false` disables CA verification, and an empty fingerprint clears the+saved pin for that probe. An empty body remains compatible with existing+callers. The bounded decoder rejects malformed bodies and unknown fields.+The endpoint retains its existing administrator and settings-write authority.+Credentials are read server-side, and overrides affect only the temporary+client. A test must not save configuration or alter runtime connection health.+This is neutral to storage-recovery because no persistence or recovery path changes.++`config_handlers_connection_test.go` exercises actual TLS probes for all three+platforms, saved credentials, omitted/cleared settings and unchanged configuration+and health. `frontend-modern/src/api/__tests__/nodes.test.ts` binds the optional+body to the saved-node route, including explicit false and empty values.++### Router chart service initializes once for concurrent requests (16 October 2026)++Each router constructs and publishes its chart service once, including routers+created without the normal constructor. Eager construction uses the same guarded+accessor as lazy history and chart handlers. Concurrent requests share that+router's service, while different routers retain separate services and resolve+the tenant monitor from each request context. Payload and route authority are+unchanged. `TestChartServiceInitializationIsConcurrentAndRouterScoped` in+`internal/api/contract_test.go` and `TestMultiTenant_TenantIsolation` are the+direct race-detector proofs. This is a separate CI stabilization slice.++The additive reporting-catalog `backupHealthAvailable` flag describes runtime+renderer presence independently of entitlement. New backup schedules are offered+only when it is present, while existing schedules remain editable after a runtime+change. Legacy catalogs default to false. API and catalog-model tests cover+absence and registration so staggered source upgrades do not offer unavailable+rendering. No price or entitlement changes.+++ ### API-rejection guidance in diagnostics (14 October 2026)++ `GET /api/diagnostics` distinguishes `proxmox_permission_denied` (403) from+ `proxmox_auth_rejected` (401), with `proxmox_api_error` for other observed HTTP+ failures. Typed PVE/PBS statuses outrank response text. Retained scheduler text+ uses the first explicit producer status marker, not numbers in endpoint or+ token identities. Authentication guidance requires confirmed invalidity before+ replacement; permission guidance preserves both scoped ACLs and privilege+ separation. The existing `errors` array now carries these bounded diagnoses and+ recovery guidance into Errors Detected, using positional connection references+ rather than adding private identities. It does not claim to list every fault.+ PVE live-monitor reconciliation and separate PBS monitor/probe evidence remain.+ Routes, caller scope/token filtering, cache policy and probe count are unchanged.+ `TestDiagnosticsAPIStatusOutranksResponseText`,+ `TestDiagnosticsSerializedAPIStatusMarkers`,+ `TestComputeDiagnosticsAPIRejectionsPreserveCredentials` and+ `TestContract_DiagnosticsAPIRejectionGuidanceSurvivesSerialization` cover real+ HTTP statuses, private-body controls, same-credential fixture recovery and wire+ attribution. They are not installed permission or guest-recovery acceptance.diff --cc docs/release-control/v6/internal/subsystems/cloud-paid.mdindex e084399e37,25675415de..b09e11eb29--- a/docs/release-control/v6/internal/subsystems/cloud-paid.md+++ b/docs/release-control/v6/internal/subsystems/cloud-paid.md@@@ -15,27 -15,17 +15,38 @@@## Purpose+### Reporting measurement precedes commercial feature decisions++Schema-v20 reporting usage exports only aggregate generation by closed report+kind, distinct successful-generation days for manual and scheduled use, file-save+and SMTP outcomes, backup source-data states, distinct successful+saved-schedule periods and repeat periods, plus measurement availability and+elapsed observation days. The receiver admits these fields only for schema v20+or later with an available tally and positive observation days. It bounds counts+and repeat/success relationships without changing billing, pricing, grants,+customer entitlements or existing opt-out behavior.++The public adoption report uses each recent active published non-mock rotating+ID's latest rolling counts. Old senders, missing receiver columns and unavailable+tallies are unmeasured, not zero usage. Partial elapsed observation is explicit.+Neither rotating installation IDs nor the coarse nonfree flag establish paying+customer identity, demand or willingness to pay. No join to license keys,+accounts, purchases or support is introduced. `pulse-pro:license-server/telemetry_test.go`+verifies receiver round-trip, schema/availability gates and bounds. Public+snapshot, privacy and adoption-query tests verify the shared semantics. Receiver+deployment and a client release are necessary before collecting fleet evidence.++ ### Retired mobile settings keep information separate from entitlement++ Pulse Mobile retirement guidance is a full-text labelled note, not a paid+ feature offer with a clamped sales description. Instances without the existing+ Relay capability can read the date and phone-alert alternatives but cannot+ pair devices or configure connections. Entitled phones keep their existing+ configuration and pairing controls until 31 March 2027. The change introduces+ no commercial offer, billing read, entitlement substitution or service change.++ `RelaySettingsPanel.runtime.test.tsx` and the current first-session/paid-settings+ browser consumers verify the readable notice and unchanged access boundaries.### Opt-in confirmed-operation transport keeps paid contexts unchanged@@@ -3715,29 -3705,12 +3726,39 @@@ Mobile settings gate and Alerts push paprovided remote access to the web UI. Pulse Mobile retires on 31 March 2027;until then licensed instances keep pairing and push unchanged.+ The backend feature catalog follows the same boundary: `relay`, `mobile_app`+ and `push_notifications` have no generic upgrade reason. Both full entitlements+ and non-billing commercial posture omit those retired offers. Missing extended+ history advertises only Pro's 90 days, never Relay or remote web access. Catalog+ roles, capability grants, subscriber terms and the legacy `relay` runtime's+ 14-day compatibility limit remain unchanged. The retirement HTTP regression+ checks both commercial projections and runtime capabilities for Community,+ legacy Relay and Pro; continuing Relay subscribers' Pro grants remain owned by+ the license server, not inferred from a legacy tier payload.+++### Extended history measurement does not establish customer identity++The license server accepts schema-v19 `successful_history_reads_over_7d_30d`+as a nonnegative aggregate integer, migrates storage without rewriting older+rows, and resets pre-v19 supplied values to zero. The public reporter treats+older schemas or missing receiver columns as unmeasured. Current coarse+`paid_license` posture is not a paying-subscription census and must not be+joined to billing accounts. This adds no price, entitlement, refund or billing+behavior. Receiver intake and migration tests pin the additive schema boundary.+Deploying the compatible receiver and release adoption remain separate from+source verification. Count and disclosure semantics belong to security-privacy.++### Business backup health report renderer++New backup health PDF/CSV rendering lives in pulse-enterprise's reportingadmin+package behind `GenerateBackupHealthReportFunc`. BusinessHooks installs that+private callback without forking the canonical reporting handlers, scheduler or+delivery system. Public code owns task collection, retained evidence, tenant+scope, effective branding and the shared rendering contract. The public adapter+fails explicitly when the private renderer is absent.++Existing advanced-reporting and branding entitlements, pricing, grants and+metric/recovery retention remain unchanged. This source change does not deploy+a runtime or change customer subscriptions. Private renderer tests cover formats,+missing/observed-zero distinction, formula-safe CSV and PDF generation. Runtime+hook tests and final-source Pro browser delivery qualify registration/composition.diff --cc docs/release-control/v6/internal/subsystems/deployment-installability.mdindex a65840abb7,49c91022a8..2ae2676443--- a/docs/release-control/v6/internal/subsystems/deployment-installability.md+++ b/docs/release-control/v6/internal/subsystems/deployment-installability.md@@@ -15,23 -15,78 +15,94 @@@```## Purpose+### Telemetry schema release disclosures follow receiver compatibility++`docs/releases/TELEMETRY_SCHEMA_V19.md` carries the extended-history telemetry notice for+inclusion in the first release containing schema v19. Source landing neither+deploys the compatible license-server receiver nor releases upgraded clients.+The reporter exposes missing receiver columns and pre-v19 clients as unknown+coverage, never as evidence of zero use. Existing telemetry opt-out, ID rotation+and retention are unchanged. Payload details belong to security-privacy.+`docs/releases/TELEMETRY_SCHEMA_V20.md` likewise carries the reporting outcome+and repeat-use notice for the first schema-v20 release. Schema and tally+availability gate measurement, including unknown old receivers and clients.+The telemetry privacy tests pin both notices. These disclosure files use the+telemetry release-disclosure proof route, rather than changing release promotion,+artifact dispatch, opt-out, pricing or customer entitlements.+++ ### Issue metadata checks before publication (14 October 2026)++ Build and Test runs the locked issue parser and silent-triage policy tests on+ proposed source, not only after publication when an issue event obtains its+ write credential. Parser/test/manifest changes, issue templates, triage guidance+ and every workflow read by the policy tests admit the check. Missing bases admit+ it too; complete receipt-only ranges and unrelated inputs do not. Guidance-only+ changes still run it even when application runtime checks are inapplicable.+ Mixed source or dependency ranges retain every existing runtime/audit check.++ The bounded hosted job uses Node 24, read-only repository permission, checkout+ without persisted credentials, no dependency cache and a locked install without+ lifecycle scripts. Both install and test failures propagate; no App token,+ issue mutation, tolerant exit or production operation belongs to this job.+ The separate issue-event pre-token test remains mandatory and unchanged.++ `TestCIIssueMetadataUsesSourceOnlyTriageChecks` executes the actual workflow's+ classification and recipes through `test_ci_browser_proof_only.py`, including+ real Git whole-range/lookalike controls and install/test failure exits. Actual+ locked parser tests remain independently required. These source controls do not+ establish a hosted pass, live issue classification or reporter resolution.++ ### Unraid/QNAP removal retires exact boot entries and confirms watchdog quiescence++ The Unix uninstall caller selects these platforms from their vendor/installed+ footprints, not from an ordinary recovered Linux state directory or QNAP state+ finder alone. Existing exact state-removal authority must select the wrapper's+ state directory. Regular root-owned files and parents are required; FAT boot+ volumes cannot be assumed to implement Unix chmod semantics. Unknown wrapper+ ownership and missing observation tools refuse before mutation.++ One complete bounded boot-file parse admits only the exact generated Unraid+ launch or canonical QNAP deferred block/legacy direct launch for that wrapper.+ All duplicates retire; unrelated entries (including co-installed names and+ legacy Telegraf) remain. Foreign/indirect targets, partial or changed blocks,+ linked/non-regular files, binary/incomplete content and over-1-MiB files refuse+ without evaluating or disclosing their text. The original remains in a private+ `.pulse-removal.*` recovery directory outside the active boot namespace through+ remote confirmation. A changed source during staging or a concurrently created+ file, directory or symlink refuses without clobbering it; interrupted staging+ retains the actual original and never restores automatic activation. New boot+ content uses no-clobber file creation, compatible with FAT without hard links;+ this is not an atomic whole-content swap or a lock against external root writers.++ Complete bounded kernel evidence returns only numeric IDs and roles. Only exact+ selected watchdog/collector processes receive checked TERM, watchdog first,+ with independent absence observations. Editor sessions, backup wrappers and+ co-installed names are not targets. Relative/foreign same-name processes or+ unattributable QNAP deferred autorun or live Unraid go shells refuse instead+ of signalling another boot owner. A live go shell may already hold later boot+ commands in memory; editing its file cannot establish quiescence. Failed/diagnostic/duplicate/empty reads and ignored/refused signals+ retain identity, credentials, trust and recoverable files. QNAP mount and+ unmount each have checked bounded results, including cleanup after partial mount.++ Whole boot/process and applicable init-manager quiescence closes again before+ same-instance server removal and before local erasure; late activation refuses,+ even after remote removal succeeded. NAS paths do not subsequently run the+ unchecked global pkill or delete arbitrary discovered QNAP state/whole legacy+ Unraid directories. Successful/absent/repeated removal still requires complete+ fresh observations. No automatic restart, credential churn or transport-policy+ change follows a partial operation.++ `TestInstallSHNASBootOwnersQuiesceBeforeRecoveryErasure` requires all eighteen+ actual-function/full-uninstall caller controls in `agent_nas_teardown.py`. The+ boot filesystem transformations are real private user operations; flash/kernel+ faults are closed models. Two generated watchdog/child controls use real private+ ordinary-user processes, not appliance mounts or root services. Native signed+ Unraid/QNAP/Linux/PowerShell, TLS/identity/repetition/cleanup and containing+ publication remain separate obligations; this source proof does not resolve+ #1099 or claim installed restoration.+### TrueNAS SCALE removal retires every owned middleware boot task before recovery erasureThe [agent lifecycle removal contract](agent-lifecycle.md#truenas-scale-removal-retires-every-owned-middleware-boot-task-before-recovery-erasure)diff --cc docs/release-control/v6/internal/subsystems/frontend-primitives.mdindex 7caba44d04,624db03e4d..710512d884--- a/docs/release-control/v6/internal/subsystems/frontend-primitives.md+++ b/docs/release-control/v6/internal/subsystems/frontend-primitives.md@@@ -242,10 -332,9 +332,15 @@@ the chart's native hover title and assiAn independent qualified memory reading is not paused by a disk deferral.Neither Last seen, backup completion nor running power state renews memory.Unannotated unrelated platforms and actual zero readings retain their meaning.++Selected agent memory freshness is independent of VM/LXC classification. A stale++agent retains its original observation as last known, while an independent++current Proxmox observation remains current. Guest kind still determines the++provider's cache interpretation.++A current reading from a cache-inclusive Proxmox source (`status-mem`,-`status-freemem`, `cluster-resources`, `derived-total-minus-used`, the same set-the backend marks `MayIncludeCache`) keeps its numbers, colour and thresholds;+`status-freemem`, `cluster-resources`, `derived-total-minus-used`, the same+sources and guest kinds the backend marks `MayIncludeCache`) keeps its numbers,+colour and thresholds;the shared presentation adds `mayIncludeCache` and a `cacheNote` saying a highpercentage alone does not show memory pressure and which fix can supply theguest's own figure. A VM row shows `May include cache` (`Cache?` in compact@@@ -9771,37 -9722,60 +9880,95 @@@ existing table evidence. No route, guespermission changes. This presentation result does not establish thaw, coveredfilesystem writes, native restart recovery or containing released software.+### Client backup report scheduling and data-quality states++Reports adds Client backup health to the existing schedule editor. PDF/CSV,+weekly/monthly cadence, current workload/tag scope and existing email/disk+delivery controls reuse the schedule workflow. Empty selection and tags mean+all current VMs and system containers. The picker restricts this kind to those+workload types and has no performance-report selection cap. Its existing default+cap remains unchanged for other consumers. Switching kinds retains only valid+workload selections and preserves the existing digest/inventory constraints.++The schedule card presents last report data quality separately from delivery+acceptance. Missing/incomplete history never reads as zero failures or completed+delivery failure. The browser payload cannot supply server-owned quality fields.+Copy states the PVE task scope, PBS destinations and unsupported-provider state.+Pricing and current advanced-reporting/branding entitlement behavior are intact.++Proofs: `ReportingPanel.test.tsx`, `ResourcePicker.test.tsx` and+`reportingSchedulesModel.backupHealth.test.ts` under Settings tests cover report+kinds, quality/delivery coexistence, unrestricted workload selection, payloads+and kind switching. Final-source browser proof covers the actual editor, client+scope, reload, delivery/recovery states and narrow/desktop layouts.++The shared picker uses semantic theme colours for workload names, selection,+tags and chips. Large selections remain in a bounded scrollable summary so+client filters and delivery controls stay reachable. Toggle rows expose pressed+state, and keyboard removal scrolls selected chips into view. The browser matrix+covers light and dark themes at all three widths.++The additive reporting-catalog `backupHealthAvailable` flag describes runtime+renderer presence independently of entitlement. New backup schedules are offered+only when it is present, while existing schedules remain editable after a runtime+change. Legacy catalogs default to false. API and catalog-model tests cover+absence and registration so staggered source upgrades do not offer unavailable+rendering. No price or entitlement changes.+++ ### One explicit guest backup completion time (12 October 2026)++ The Workloads backup badge and name-cell indicator disclose the same UTC+ completion date/time as the guest drawer, including on the fine-pointer hover+ shortcut. `formatBackupCompletionTime` normalises the original instant once per+ disclosed readout; the semantic `time` preserves its ISO timestamp. Local browser+ timezone and locale cannot silently change the visible calendar day or time.+ The completion text wraps at narrow widths. Unknown/future/absent readings still+ have no completion element; running or ended activity and clock ticks do not+ renew it. Only replacement evidence changes the supplied completed time.++ `BackupCompletionTime.test.tsx`, `BackupStatusAccess.test.tsx` and the formatter+ controls connect both disclosure paths to the drawer, offset inputs, updates,+ uncertainty and disposal. The `backup-completion-time` browser fixture uses real+ VM/LXC rows, policy producer, hover, keyboard/touch dialogs and the guest drawer+ in non-UTC desktop and phone contexts. This is unambiguous presentation, not+ PBS verification ingestion, independent thaw, filesystem liveness, native+ guest restart recovery or containing software availability.++ ### Host drawers distinguish unknown filesystem usage from empty filesystems++ The existing Proxmox node and Docker host per-filesystem rows use the shared+ host disk presentation. An explicit negative usage sentinel, negative or+ non-finite used bytes, or absent/non-positive/non-finite capacity produces+ **Usage unavailable**, with any finite positive capacity retained separately.+ Unavailable usage has neutral text and no utilization bar; a retained capacity+ alone is not a healthy zero. Finite byte ratios preserve their existing+ threshold presentation. Real zero-byte values, including zeros omitted by the+ canonical DiskInfo JSON representation, remain valid empty filesystems when+ capacity is known and no unknown sentinel is present.++ The shared usage text wraps in both existing drawers, rather than relying on+ a tooltip or rendering an old percentage after a new unavailable read. The+ existing mount filtering, row disclosure and single-filesystem summary stay+ unchanged. The connected `HostDrawer.filesystem-readings.test.tsx` and shared+ `DrawerDiskListCard.readings.test.tsx` controls cover unknown/capacity/zero,+ invalid bytes and same-mounted-drawer replacement. The desktop Chromium and+ narrow touch WebKit `browser-tests/host-disk-usage.cjs` fixture consumes synthetic+ Resources responses through the actual platform tables and drawers. No new+ route, monitoring policy, provider operation or native recovery claim is added.++ The shared `filesystemByteUsage.ts` admission also applies to filesystem inputs+ of `stackedDiskBarModel.ts`: unusable byte rows remain neutral in tooltips and+ do not contribute used bytes, capacity, bars, combined percentages or highest+ usage. All-unmeasured filesystem lists with no independent accepted aggregate+ render N/A, not a fabricated zero. Independently supplied aggregate metrics and+ retained/unavailable source classifications preserve their existing semantics.+ The connected stacked-model controls retain explicit aggregate fallback tests;+ the browser fixture checks mixed and all-unknown lists in the actual summaries+ as well as both drawers, including live replacement at narrow widths.++ The aggregate bar admits byte sublabels only with finite non-negative measured+ used bytes and finite positive capacity. An independently valid percentage+ remains visible beside invalid capacity without formatting NaN/Infinity bytes.+ Model/component controls cover non-finite, absent and non-positive capacity;+ `workload-disk-metrics.cjs` checks both Bars (including the tooltip) and Sparklines+ through the same REST reading at desktop and phone widths.diff --cc docs/release-control/v6/internal/subsystems/monitoring.mdindex 58df29d96e,82d8df5a0e..dea75ac8a1--- a/docs/release-control/v6/internal/subsystems/monitoring.md+++ b/docs/release-control/v6/internal/subsystems/monitoring.md@@@ -17,16 -17,322 +17,332 @@@## Purpose+### Storage investigation history shares the chart source boundary++`ReadStorageMetricHistory` and `GetStorageMetricsForChart` use the same monitor+selector for memory, retained and generated storage history. Analytical reads+retain the requested window and propagate retained-store errors. Chart-only+lookback remains presentation behavior and cannot supply older observations as+current investigation history. Generated demo samples carry `mock_synthetic`;+they are never evidence of a real storage growth rate. The requested-window and+store-error regression is `internal/monitoring/storage_history_test.go`.++ ### Conflicting saved endpoint pins cannot select certificate trust++ For equivalent Proxmox endpoint URL spellings, all nonempty saved member pins+ must agree under the TLS verifier's existing case/colon normalization. Exact+ spelling and map iteration can no longer select one of contradictory pins.+ Resolution returns a fixed, credential-free trust-conflict error before a TLS+ probe, password login, token read, first-use capture or polling-client creation.+ The member stays unreachable to Pulse; an independently trusted sibling can+ continue ordinary monitoring. No saved pin is removed or overwritten, and the+ error cannot become an empty pin/CA or opt-out fallback. Agreeing pin formats,+ nonempty invalid pins, primary-pin fallback, declared-member first-use and the+ existing scheme/port/base-path/IPv4-mapped trust boundaries remain unchanged.++ `TestClusterConflictingSavedPinsNeverAuthenticate` covers startup, recovery and+ lazy selection in token/JSON/form modes, three URL spellings and both VerifySSL+ settings with real TLS sockets. It checks zero TLS/login/read work for conflicts,+ no installed client or trust mutation, sibling use, and accepted monitoring+ following a normal reload with reconciled fixture pins. Existing established-pin,+ first-use, cancellation, ownership and guest-admission controls still apply.+ `TestClusterSavedPinResolutionRejectsConflicts` and+ `TestClusterFirstUseCaptureDoesNotReconcileConflictingPins` retain the conflict+ through normalized authorities, invalid nonempty pins and a capture race.+ `TestClusterConflictingPinsEndpointProjection` uses the production endpoint+ builder, real clients and monitor projection in all three auth modes: native+ Online, identity and saved trust are not changed by failed Pulse reachability.+ The producer also records contradictory exact duplicate saved rows before+ its map/deduplication can overwrite them, and carries those endpoint conflicts+ through initialisation, missing-client reconnect and cluster refresh. The+ cluster owns a copy of that conflict set; aliases cannot escape it, and a+ later repeated row cannot clear it. Normal configuration reload with agreeing+ pins is required to resume that endpoint. A non-conflicting sibling is not+ refused. The public constructor's optional conflict inputs preserve existing+ callers and do not introduce a new trust mode. Producer tests cover both+ routes, pin formatting, repeated contradictions and configuration ownership.+ The projection cases include exact duplicates as well as URL aliases.+ A credential-free agreement check also holds automatic topology refresh while+ saved trust is contradictory: discovery cannot collapse the rows, move an+ alias or substitute a pin to clear that refusal. Current trusted sibling+ clients keep monitoring; topology changes wait for independently reconciled+ configuration. `TestClusterPinConflictsSurviveMonitorLifecycle` exercises the+ actual initialisation, missing-client retry and refresh/rebuild paths in all+ three auth modes and both layouts, including normal refresh after reconciliation.+ Saved-view consolidation also refuses a view with internal pin contradictions,+ so map indexing cannot hide an earlier contradictory row before monitoring+ starts. `TestConsolidatePVEInstancesRetainsInternallyConflictingPins` covers+ both merge orders, repeated rows, same-node/address evidence and agreeing formats.+ Internal agreement uses the TLS verifier's case/colon comparison even when+ legacy identity formatting would erase or simplify a malformed nonempty pin;+ colon-only, whitespace and prefixed pins cannot hide a contradiction.+ The endpoint-ownership routing control uses a five-second fixture client and+ a ten-second enclosing caller lifetime, rather than a one-second latency+ criterion. It records elapsed time and both targets' request counts; unchanged+ pin, admission and routing assertions remain required. Runtime timeouts and+ separate timeout/cancellation controls are unchanged. This is not a diagnosis+ or dismissal of the retained earlier one-second timeout.+ Lock-evidence fixture cases use independent base-path namespaces while each+ case's clients share the same guard key. A recycled loopback port cannot inherit+ an earlier synthetic guest's cooldown. `TestGuestAgentLockEvidenceFixtureIsolation`+ shares one listener and retains an earlier uncertainty fence unchanged while an+ independent fixture completes its lock/command checks. No runtime fence is+ cleared, expired or weakened; native guest recovery is not established.+ This establishes source/consumer behaviour, not native recovery or attribution+ of a guest, PBS or certificate report.+++ ### Cluster recovery requires success of the operation actually probed++ Startup and unhealthy-member recovery read `/nodes`; lazy construction uses the+ same probe. A failed nodes or login request cannot count as successful recovery+ because its response text mentions a guest agent, QMP or `guest-get-*`. The old+ per-guest substring exception is removed from these non-guest operations.+ Failed selection retains its actual sanitised reason and observation time, and+ installs no polling client. Successful probe plus accepted full-timeout session+ is still required. The existing temporary-rate-limit path may admit an ordinary+ request, but does not report the failed probe as passed or clear a known failure.++ The single-endpoint last-resort path remains available with its cached client;+ selecting it no longer marks that endpoint healthy before a request succeeds.+ A later accepted ordinary read still clears the failure. Actual per-guest+ errors remain request-level errors, without marking an otherwise working node+ unhealthy. Certificate pins, first-use trust, credential encodings, request and+ recovery cadence, rate-limit backoff and guest/backup fences are unchanged.++ `TestClusterNodeProbeRequiresSuccess` covers startup/recovery/selection in token,+ JSON password and form password modes, three guest-like failure bodies at the+ nodes or login stage, no extra login/full client and distinct later recovery.+ `TestClusterSingleEndpointFallbackKeepsFailedHealth` checks cached selection,+ failed ordinary read and later success. `TestClusterNodeProbeRateLimitKeepsOrdinaryRead`+ preserves genuine rate-limit handling. `TestClusterNodeProbeEndpointProjection`+ carries the actual failed and later recovered member through the production+ monitor projection while independent native Online, saved trust and identity+ remain unchanged. These are source/consumer controls, not attribution or+ installed acceptance for a reported PBS/QGA/backup incident.+++ ### Node inventory admission consumes the complete response++ The PVE `/nodes` reader consumes and closes the entire existing 8 MiB-bounded+ body before returning inventory or allowing startup/recovery/lazy probes to+ succeed. A valid JSON prefix with a missing transport tail, extra JSON values,+ oversized suffix, malformed UTF-8, missing/null data, conflicting errors or+ ambiguous/case-overwritten fields is not an authoritative inventory. Each row+ must have a canonical nonempty, unique node name; null/unnamed/duplicate rows+ and ambiguous supported node fields reject the whole response rather than+ publish partial or invented empty inventory. Validation errors contain no body+ material. Unique provider metadata and explicit empty arrays remain accepted,+ including scoped tokens with no visible nodes. Existing node fields and offline+ status are preserved without changing provider permissions.++ `node_inventory_response_test.go` exercises actual HTTP reads and all supported+ fields, the explicit-empty controls, byte/transport bounds and no replay.+ `cluster_node_inventory_test.go` checks pinned HTTPS in token, JSON-password and+ form-password modes at startup, recovery and lazy selection: failed success+ installs no client and never advances to a full session; distinct complete+ recovery remains usable. The cached fallback keeps its earlier failure until a+ complete ordinary read succeeds. `TestClusterNodeInventoryEndpointProjection`+ drives missing/duplicate/incomplete responses and subsequent ordinary recovery+ through the production monitor projection while native Online, identity and+ saved pins remain intact. Recovery cadence, auth encodings, TLS admission,+ rate-limit policy, other API readers and guest/backup fences are unchanged.+ These are source and consuming-surface proofs, not attribution or installed+ acceptance for any reported PBS, guest restart or workload-safety incident.+++ ### First-use cluster trust includes password construction++ Declared, previously untrusted Proxmox members use the existing credential-free+ TLS capture and pinned retry whether the inherited primary pin fails during+ password login or during the token-authenticated nodes probe. Startup, ordinary+ unhealthy recovery and lazy first selection share this path. Capture still+ requires typed local pin-mismatch evidence and cannot replace a primary, saved+ member or concurrent winner pin; it never sends an HTTP request or credentials.+ The pinned retry is not repeated to obtain a nodes count. Failed or cancelled+ authentication installs no polling session; a separately accepted full-timeout+ client is required before recovery becomes healthy. Refusal retains the+ established runtime pin for a distinct later ordinary recovery. Saved trust,+ CA/redirect policy, login encodings, cadence and guest/backup fences do not change.++ `TestClusterFirstUseSessionAdmission` covers JSON password, existing form+ fallback and token modes in all three phases, then ordinary member reads.+ The adjacent refusal, established-pin and cancellation controls exercise actual+ TLS sockets. Concurrent lazy selection retains serialized construction while+ health/trust inspection stays usable during capture. `TestClusterFirstUsePasswordEndpointProjection` carries first-use+ probe/full-session refusal and later public-read recovery into the monitor's+ cluster-member projection without changing native Online state, identity or+ saved fingerprints. This is source/consumer qualification, not installed+ cluster recovery or attribution of an existing user report.+++ ### Proxmox password success admits a complete session, not just HTTP 200++ PVE and PBS consume the entire existing byte-bounded login body before+ publishing ticket, CSRF token and the normal two-hour expiry together. The+ shared `internal/securityutil/proxmox_session.go` parser requires canonical,+ unambiguous envelope/session keys, complete UTF-8 JSON, a nonempty cookie-safe+ ticket and a nonempty header-safe CSRF token. Unknown unique metadata such as+ username and capabilities remains supported. Partial/null, duplicate or+ case-conflicting credentials, extra JSON values, incomplete reads and oversized+ tails fail without replacing the retained tuple or advancing PVE generation.+ Validation errors contain no response credentials. A malformed success is not+ a provider credential refusal and does not trigger JSON-to-form fallback.++ `session_response_admission_test.go` in both client packages exercises these+ controls and eight joined expired readers, zero subsequent API/form requests+ on invalid success, retained state and distinct later ordinary recovery with+ coherent cookie/CSRF pairs. Cluster recovery additionally checks empty and+ partial success for the retained polling client, with and without a previous+ client. `TestPBSInvalidSessionKeepsFirstPollBoundary` exercises the real pinned+ constructor, normal startup retry, poll executor and production broadcast:+ invalid success installs no client, valid construction is not healthy telemetry,+ and only the accepted first poll publishes recovered node/datastore readings.++ TLS trust, credentials, auth encodings and 400/415 fallback, API-token paths,+ renewal ownership, retries/cadence, guest/backup fences and History are unchanged.+ The parser establishes response integrity, not cryptographic ticket validation+ or native/installed acceptance. It neither attributes nor resolves a reported+ PBS, Windows guest, restart or workload-safety incident.+++ The invalid-QGA-success matrix uses a distinct synthetic base path for each+ case/reader, so OS reuse of a closed ephemeral listener cannot borrow a previous+ fixture's live cooldown. `TestGuestAgentInvalidSuccessFixtureIsolation` shares+ one listener deliberately and checks two independent first admissions and both+ retained second-client fences. No production key, alias, TTL or guard state is+ changed or cleared to qualify these tests.++ ### Proxmox recovery sessions honour the owning caller++ PVE/PBS context-aware constructors bind initial password login, including the+ existing JSON/form fallback, to the initiating context. Cluster selection,+ first-use pinned retry, synchronous construction and unhealthy-member recovery+ carry that context through both the short probe and the retained polling+ session. The six-second background recovery budget also bounds construction;+ ending a caller is neither a credential refusal nor successful recovery.+ Cancelled selection/recovery preserves prior errors and does not install a+ partial or nil client. Startup retry exits without publishing a new health+ outcome or advancing another provider after its monitor stops. Discarded probe+ transports close their idle connections.++ The compatibility constructors retain their background-context behaviour.+ Accepted clients retain their configured full timeout, and subsequent ordinary+ reads use their own contexts, not the ended construction context. TLS pins,+ CA verification, redirects, first-use admission, auth encodings, retry cadence,+ provider permissions, guest/backup fences and History are unchanged.++ `TestClientConstructionHonoursContext` in both client packages covers ended+ password/token construction, in-flight JSON/form cancellation/deadlines,+ independent later reads and wrong-pin refusal. Cluster caller-budget controls+ cover selection/recovery at first login, probe and full login, then trusted+ ordinary recovery. Startup cancellation covers PVE, PBS and multi-endpoint+ cluster construction. The connected PBS first-poll control emits the actual+ broadcast for desktop/phone consumption: cancellation cannot turn an offline+ server healthy, and accepted construction alone still cannot do so. These are+ secret-free local fixtures, not installed recovery, native guest safety or an+ attribution of any reporter's failure.+++ ### Cluster recovery requires a usable polling session++ A short endpoint probe cannot establish successful recovery until the client+ retained for ordinary polling has been constructed successfully. A refused or+ malformed password login for that second client preserves the existing client+ (or its absence), records the failure and does not count or publish recovery.+ An endpoint must never become healthy with a nil polling client. A later+ ordinary eligible recovery can install an accepted full-timeout session and+ clear its own error; usable siblings continue to serve polling throughout.++ `TestClusterRecoveryRequiresUsableSession` covers pinned HTTPS 401/403,+ malformed success and JSON-to-form refusal, with and without a retained client,+ then accepted recovery and ordinary reads. `TestClusterRecoverySessionEndpointProjection`+ drives public cluster reads and background recovery through the monitor's+ per-endpoint projection: native Online state, identity and saved pins survive,+ while PulseReachable and PulseError reflect the actual polling session. The+ existing recovery interval, authentication encodings, TLS trust/first-use+ policy, failover order and guest-command safety state are unchanged. These+ synthetic controls establish neither installed trust recovery nor a reported+ incident's cause.++ ### Rejected infrastructure URLs stay out of diagnostics++ PVE/PBS constructors validate a host before logging it. URL syntax errors omit+ `url.Parse`'s copy of the supplied input; ordinary validation reasons remain.+ Cluster logs, health snapshots, recovery summaries and aggregate errors use+ display-only labels:+ a valid base URL or `[invalid endpoint]`. Health snapshots preserve each entry+ even when rejected endpoints share that label, and are built only for enabled+ log events. These labels never supply routing,+ alias membership, saved configuration or TLS-pin identity. HTTP/HTTPS defaults,+ base paths, authentication, CA/pin/opt-out choices and guest fences are unchanged.++ `TestClientRejectedHostDiagnosticsContainNoCredentials` and+ `TestClusterRejectedEndpointDiagnosticsContainNoCredentials` exercise actual+ constructors, single/multiple endpoint routing and recovery with synthetic+ userinfo/query/fragment and malformed URLs. Accepted-host and+ `TestInfrastructureURLValidationPolicyUnchanged` controls preserve ordinary+ routing and diagnostics. This bounds client diagnostics, not arbitrary provider+ error text, previously saved logs, native trust recovery or an installed service.++ ### PBS password renewal publishes one complete shared session++ Concurrent reads of an expired PBS password session share one in-flight+ authentication attempt. Ticket, CSRF token and expiry are published together;+ each ordinary request uses one complete tuple. Only renewal is shared: the+ subsequent API reads remain independent, and a cancelled waiter cannot cancel+ the owner. Caller cancellation and deadlines stay context errors, not credential+ refusals, including token reads that never attempt a login. Joined callers receive the owner's failure without reissuing it;+ a later ordinary call may try again. JSON authentication and the existing+ 400/415 form fallback retain their semantics. Tokens do not acquire session+ authority, and API 401/403 replies remain terminal without adding a replay.++ `pkg/pbs/auth_session_concurrency_test.go` exercises pinned local HTTPS expiry,+ encoding fallback/refusal, malformed responses, independent reads, cookie/CSRF+ pairing, owner/waiter cancellation and ordinary later recovery. Its accepted+ node/datastore responses also consume through the canonical PBS projection.+ TLS pins/CA/opt-out and redirect policy, credentials, ticket lifetime, provider+ permissions, wire shapes, polling schedules, guest/backup fences and stored+ History are unchanged. These synthetic controls do not establish an installed+ connection, native recovery or the cause of a reported PBS/guest failure.++ ### Connection retirement preserves unrelated guest safety state++ Retiring a consolidated PVE connection cancels and clears only its own guest+ metadata lifecycle. Connection labels may contain `|`; matching a label prefix+ cannot establish ownership. The metadata key's two fixed node/VMID suffixes+ are read from the right, while diagnostic memory snapshots use their recorded+ `Instance`. A separate `site|other` connection keeps its outstanding owner,+ OS-command suppression, original observations and refresh/backoff deadlines+ when `site` is retired. The retired connection's cancelled fetch still owns+ its key until completion, and shared transport uncertainty is never cleared.++ `TestGuestMetadataRetirementOwnershipContract` covers exact cleanup, nested and+ Unicode labels, diagnostic origins and in-flight HTTP bodies at all three+ metadata stages. `TestGuestMetadataRetirementPollingKeepsSuppression` exercises+ both clients and ordinary collectors: no reissued suppressed OS command, no+ unrelated identity loss, and continued independent filesystem/CPU/memory reads.+ Wire formats, TTLs, guest-command/backup-lock/TLS fences and stored History are+ unchanged. These are synthetic source controls, not native thaw/restart recovery,+ a reporter's failure cause or installed/release acceptance.++ ### Rate refusals cannot permanently disable guest OS discovery++ An observed HTTP 429 from guest OS-info preserves the existing OS-command+ failure count and suppression state, like access refusal or stopped QGA. It+ neither exercised the OS command nor supplies a fresh OS observation. Ordinary+ metadata backoff remains in force; a subsequent admitted poll can learn the OS+ without a restart or clearing command-safety state. Only the typed wire status+ admits this distinction: provider text quoting 429 is not a rate refusal.++ `TestGuestMetadataRateLimitRecoveryContract` covers both HTTP client types and+ ordinary collectors with cold/stale metadata, OS-like 429 bodies, unchanged+ backoff and accepted filesystem/memory readings, subsequent Windows discovery+ before Linux-only memory admission, and genuine repeated-failure suppression+ with a quoted 429. Existing unsupported-command, backup-lock and uncertain-reply+ fences are unchanged. Its fixtures use local sockets and synthetic credentials,+ not native guest recovery, History storage or a reported failure's cause.+### Cluster endpoint membership belongs to its client`NewClusterClient` snapshots the supplied endpoint slice before registering@@@ -7404,41 -7752,64 +7855,103 @@@ through `publishPVEGuests` to the canonupdates its former direct-call assertions without changing Docker ingestion orthe runtime ownership gate; the behavioral withdrawal controls remain required.+### Backup history collection carries completeness++`GetBackupTaskHistory` in `pkg/proxmox/backup_history.go` enumerates a bounded+ninety-day PVE task window with pagination and a fixed collection cutoff. Offline+nodes, failed reads, repeated/capped pages and unconfirmed `Sys.Audit` authority+remain explicit partial evidence. A successful HTTP response alone cannot prove+visibility of other users' backup jobs. The cluster client retains its canonical+transport failover wrapper. Older adapters can still supply live tasks but+cannot qualify report observation coverage.++`pollBackupTasks` persists mapped task evidence synchronously through the+organization's recovery manager before recording collection quality. The+continuity allowance derives from the configured backup interval/cycle cadence.+An unavailable manager or failed write cannot certify complete observation.+Multi-guest attribution requires a nontruncated, contiguous completed task log+with a terminal marker and parsed guests. Incomplete logs remain unqualified+and eligible for later collection. No backup artifact or restore assurance is+created by an execution outcome.++Proofs: `pkg/proxmox/backup_history_test.go` covers pagination, permissions,+partial reads and offline nodes. `internal/monitoring/backup_task_history_test.go`+covers durable failures surviving an empty poll and log qualification.++Backup collection starts with a bounded retained-history backfill, then uses a+durable collection checkpoint with a day of overlap. The oldest known pending+execution remains in range until completion, including after restart. Failed+reads do not advance the checkpoint. A capped backfill may advance a later+incremental read without backdating observation coverage. Another node's+failure cannot be hidden by a truncation reason. The live API/state keeps its+existing 200 provider tasks per node plus their guest details, while the recovery+store retains executions beyond that live window. Checkpoint, long-running-job,+failed-read, capped-backfill and bounded-live-payload regression tests exercise+these boundaries.++Recovery rollup and alert readers take a locked snapshot of the manager pointer,+matching the existing setter during live monitor dependency rebinding. The+`TestBackupHealthRecoveryRebindingCanOverlapActiveReaders` race proof exercises+rebinding while both consumers remain active.+++ ### Complete guest enumeration before publication (14 October 2026)++ PVE `cluster/resources`, node `qemu` and node `lxc` enumeration consume and+ close the whole existing 8 MiB-bounded HTTP response before admission. Only+ HTTP 200 containing a complete UTF-8 JSON object with an explicit canonical+ `data` array is authoritative inventory. Missing/null data, duplicate or+ case-variant supported fields, conflicting errors, trailing values, incomplete+ bodies, invalid rows and duplicate guest identities fail the whole enumeration;+ no partial inventory or provider body is returned as a successful reading.+ Cluster guest identities require a node and positive cluster-wide unique VMID.+ Node lists require positive unique VMIDs; existing LXC string integers remain.+ Scoped empty arrays, optional names/status/metrics, null counter presence,+ templates, unique provider metadata and unfiltered non-guest resources remain+ supported. Observation timestamps are assigned only to an admitted inventory.++ A refused efficient enumeration can use the existing ordinary node fallback.+ Failed node enumerations retain their earlier guest observations, History and+ backup-template eligibility; a complete fallback can still remove deleted+ guests and restore ordinary sampling. Complete cluster recovery returns to+ its efficient route. This changes no TLS/pin, credentials, permissions,+ polling cadence, guest-command/backup-lock checks, completion uncertainty,+ publication ownership or grace-period rules.++ `guest_inventory_response_test.go` covers complete-body and all-or-nothing+ admission on all three real HTTP readers; `io_counters_test.go` covers+ scoped-empty, extended fields, counter presence and receipt-time controls.+ `diagnostic_snapshots_test.go` covers actual efficient/fallback collection,+ owned publication, retained observation times, breach/History/template+ continuity, independent-connection preservation and normal recovery/removal.+ These controlled source proofs do not establish native thaw/restart recovery,+ installed trust, report attribution or release availability.++ Failed-node retention selects canonical guest membership but takes the unchanged+ complete tuple from that connection's last accepted producer state. Enrichment's+ partial previous-state projection is not an observation: it must not turn an+ unavailable/retained memory reading into zero, lose CPU/disk usage or change the+ original in-guest collection state. A node-scoped detached snapshot copies only+ selected guests, not unrelated host disks or Kubernetes state. The existing+ canonical/enrichment path remains the fallback when no accepted source tuple+ exists; linked-agent evidence is never promoted to Proxmox ownership. The+ same publication owner still admits or withdraws the eventual generation.+ `proxmox_guest_observations_test.go` checks scope, original memory provenance,+ CPU/disk/read time and nested detachment, alongside the end-to-end admission+ controls above. The first complete admission proof exposed the former partial+ retention and is retained as failed evidence, not weakened into acceptance.++ ### Permission-denial diagnostics retain scoped access (14 October 2026)++ A PVE token's 403 error explains that privilege-separated access is the+ intersection of user and token ACLs on the intended resource. It no longer+ says to inspect only the user or includes the configured username/provider+ body. The actual HTTP status, authentication-error wrapping and guest permission+ classification remain; there is no retry, token rotation, access widening or+ TLS change. Diagnostics distinguishes rejected authentication from permission+ and other wire failures without promoting a denied resource to a reading.+ `TestClientRequest_403TokenPermissionHint` and+ `TestGetNodeStatusPermissionRefusalDoesNotInventMemory` cover the ordinary+ HTTP boundary, unknown-not-zero memory and resumed CPU/memory with the same+ credential. `TestComputeDiagnosticsAPIRejectionsPreserveCredentials` covers+ pinned PVE/PBS fixture use and preserves the separate PBS scheduler state.+ Native scoped-fleet recovery, QGA/thaw and installed trust remain separate.diff --cc docs/release-control/v6/internal/subsystems/security-privacy.mdindex f836c1048b,89c7fcea83..8277a028e6--- a/docs/release-control/v6/internal/subsystems/security-privacy.md+++ b/docs/release-control/v6/internal/subsystems/security-privacy.md@@@ -18,91 -18,146 +18,231 @@@## Purpose+### Restricted outbound connections keep approved destinations pinned++`pkg/securityutil/outbound_http.go` owns restricted HTTP destination validation,+redirect policy and DNS pinning. `pkg/securityutil/pinned_dial.go` owns shared+numeric-address connection scheduling, including notification callers. The+dialer never resolves a hostname or expands destination permissions. Callers+must validate every candidate before handing it over.++The primitive validates and normalises numeric IPs, rejects malformed input,+deduplicates equivalent IPv4 forms, respects the requested TCP address family,+and races at most two staggered serial workers under one positive connection+timeout. Remaining time is shared among each worker's remaining candidates.+Caller cancellation cancels in-flight work. A successful connection cancels+competitors and closes any late successful loser without writing an HTTP+payload to it. Transport TLS and destination-policy checks remain in place.++`pkg/securityutil/pinned_dial_test.go` verifies family fallback, later-address+budget, concurrency, cancellation, late-connection closure, numeric-only input+and error preservation. Notification loopback controls exercise both clients+against a real stalled TCP address and a healthy receiver. The registry routes+both shared runtime files to these controls and the existing outbound policy+tests, keeping this primitive owned without moving notification allowlisting.++### Reporting usage remains content-free and distinguishable from missing measurements++`internal/config/reporting_activity.go` is the canonical durable count store.+It retains 30 UTC-day buckets of closed report kinds and outcomes. Local opaque+schedule/period SHA-256 markers expire after 90 days and use existing config+storage encryption when configured. No raw report, recipient, schedule, scope,+organization identifier, range or error content enters the tally. Only schema+v20 scalar counters, measurement availability and elapsed observation days leave+the installation through the existing opt-out-controlled heartbeat. Local tally+errors never fail reporting. Mock mode never records real reporting activity.++Generation counts include separate attempts and complete direct response writes.+Distinct successful-generation days measure activity, including manual downloads+and scheduled retries, with same-day attempts counted once. Multiple days alone+cannot establish a fresh successful period or returning manual use. The adoption+summary keeps multi-day generation separate from successful repeat periods.+Saved files, SMTP acceptance, definite failures and uncertain acceptance remain+separate. Persisted successful saved-schedule windows count once. A successful+repeat period requires a different window on that schedule within 90 days,+including monthly reuse, so retries and same-period reruns do not inflate that+period metric. The aggregate+query uses only each eligible rotating ID's latest counts and marks old-schema,+missing-column and unavailable-tally data unmeasured. Elapsed observation days do+not establish continuous uptime, and SMTP acceptance does not prove inbox receipt.+No customer/account joins or paying-customer census are permitted.++`internal/config/reporting_activity_test.go`,+`internal/api/reporting_activity_test.go`, the telemetry payload/disclosure tests,+the server snapshot tests and the adoption-report tests verify this boundary.+Both privacy document copies and `docs/releases/TELEMETRY_SCHEMA_V20.md` disclose+the payload. Client source landing and compatible receiver activation remain+separate from release and installed fleet measurement.+++### Investigation evidence retains tenant and runtime-source boundaries++Recovery HTTP and tool reads share `Manager.ListPointsForOrg`: a nonblank tenant+is required, cancellation and read failures remain errors, and ordinary reads+use that tenant's cached store. The optional demo source follows the current+fixture graph and never merges persisted tenant rows into demo evidence. The+real-to-demo-to-real regression checks both consumers and retained store data;+the persisted task regression excludes another tenant and another guest with+the same provider VM ID. Historical storage reads preserve source labels and+requested time bounds. These read paths add no credential, execution or approval+authority.++### Reports and metric summaries read only the requesting organization++The server's report engine (`pkg/server/server.go`) resolves the metrics store+of each request's organization through the multi-tenant monitor+(`EngineConfig.MetricsStoreForOrg`) and refuses a request that names no+organization, so no report path falls back to the default organization's+store. Report handlers also reject a resource that is not in the requesting+organization's inventory, scheduled runs resolve their scope against their+owning organization's inventory, and Pulse Assistant's `pulse_summarize`+reads its executor's organization. A resource ID that exists in two+organizations yields each organization only its own history.+`internal/api/reporting_org_scope_test.go`,+`TestReportingScheduledRunReadsOnlyItsOwningOrganizationsMetrics`,+`pkg/reporting/engine_org_scope_test.go` and+`TestSummarizeToolReadsOnlyItsOrganizationsMetrics` hold this boundary.++ ### Conflicting saved endpoint pins cannot select certificate trust++ For equivalent Proxmox endpoint URL spellings, all nonempty saved member pins+ must agree under the TLS verifier's existing case/colon normalization. Exact+ spelling and map iteration can no longer select one of contradictory pins.+ Resolution returns a fixed, credential-free trust-conflict error before a TLS+ probe, password login, token read, first-use capture or polling-client creation.+ The member stays unreachable to Pulse; an independently trusted sibling can+ continue ordinary monitoring. No saved pin is removed or overwritten, and the+ error cannot become an empty pin/CA or opt-out fallback. Agreeing pin formats,+ nonempty invalid pins, primary-pin fallback, declared-member first-use and the+ existing scheme/port/base-path/IPv4-mapped trust boundaries remain unchanged.++ `TestClusterConflictingSavedPinsNeverAuthenticate` covers startup, recovery and+ lazy selection in token/JSON/form modes, three URL spellings and both VerifySSL+ settings with real TLS sockets. It checks zero TLS/login/read work for conflicts,+ no installed client or trust mutation, sibling use, and accepted monitoring+ following a normal reload with reconciled fixture pins. Existing established-pin,+ first-use, cancellation, ownership and guest-admission controls still apply.+ `TestClusterSavedPinResolutionRejectsConflicts` and+ `TestClusterFirstUseCaptureDoesNotReconcileConflictingPins` retain the conflict+ through normalized authorities, invalid nonempty pins and a capture race.+ `TestClusterConflictingPinsEndpointProjection` uses the production endpoint+ builder, real clients and monitor projection in all three auth modes: native+ Online, identity and saved trust are not changed by failed Pulse reachability.+ The producer also records contradictory exact duplicate saved rows before+ its map/deduplication can overwrite them, and carries those endpoint conflicts+ through initialisation, missing-client reconnect and cluster refresh. The+ cluster owns a copy of that conflict set; aliases cannot escape it, and a+ later repeated row cannot clear it. Normal configuration reload with agreeing+ pins is required to resume that endpoint. A non-conflicting sibling is not+ refused. The public constructor's optional conflict inputs preserve existing+ callers and do not introduce a new trust mode. Producer tests cover both+ routes, pin formatting, repeated contradictions and configuration ownership.+ The projection cases include exact duplicates as well as URL aliases.+ A credential-free agreement check also holds automatic topology refresh while+ saved trust is contradictory: discovery cannot collapse the rows, move an+ alias or substitute a pin to clear that refusal. Current trusted sibling+ clients keep monitoring; topology changes wait for independently reconciled+ configuration. `TestClusterPinConflictsSurviveMonitorLifecycle` exercises the+ actual initialisation, missing-client retry and refresh/rebuild paths in all+ three auth modes and both layouts, including normal refresh after reconciliation.+ Saved-view consolidation also refuses a view with internal pin contradictions,+ so map indexing cannot hide an earlier contradictory row before monitoring+ starts. `TestConsolidatePVEInstancesRetainsInternallyConflictingPins` covers+ both merge orders, repeated rows, same-node/address evidence and agreeing formats.+ Internal agreement uses the TLS verifier's case/colon comparison even when+ legacy identity formatting would erase or simplify a malformed nonempty pin;+ colon-only, whitespace and prefixed pins cannot hide a contradiction.+ The endpoint-ownership routing control uses a five-second fixture client and+ a ten-second enclosing caller lifetime, rather than a one-second latency+ criterion. It records elapsed time and both targets' request counts; unchanged+ pin, admission and routing assertions remain required. Runtime timeouts and+ separate timeout/cancellation controls are unchanged. This is not a diagnosis+ or dismissal of the retained earlier one-second timeout.+ Lock-evidence fixture cases use independent base-path namespaces while each+ case's clients share the same guard key. A recycled loopback port cannot inherit+ an earlier synthetic guest's cooldown. `TestGuestAgentLockEvidenceFixtureIsolation`+ shares one listener and retains an earlier uncertainty fence unchanged while an+ independent fixture completes its lock/command checks. No runtime fence is+ cleared, expired or weakened; native guest recovery is not established.+ This establishes source/consumer behaviour, not native recovery or attribution+ of a guest, PBS or certificate report.+++ ### First-use cluster trust includes password construction++ Declared, previously untrusted Proxmox members use the existing credential-free+ TLS capture and pinned retry whether the inherited primary pin fails during+ password login or during the token-authenticated nodes probe. Startup, ordinary+ unhealthy recovery and lazy first selection share this path. Capture still+ requires typed local pin-mismatch evidence and cannot replace a primary, saved+ member or concurrent winner pin; it never sends an HTTP request or credentials.+ The pinned retry is not repeated to obtain a nodes count. Failed or cancelled+ authentication installs no polling session; a separately accepted full-timeout+ client is required before recovery becomes healthy. Refusal retains the+ established runtime pin for a distinct later ordinary recovery. Saved trust,+ CA/redirect policy, login encodings, cadence and guest/backup fences do not change.++ `TestClusterFirstUseSessionAdmission` covers JSON password, existing form+ fallback and token modes in all three phases, then ordinary member reads.+ The adjacent refusal, established-pin and cancellation controls exercise actual+ TLS sockets. Concurrent lazy selection retains serialized construction while+ health/trust inspection stays usable during capture. `TestClusterFirstUsePasswordEndpointProjection` carries first-use+ probe/full-session refusal and later public-read recovery into the monitor's+ cluster-member projection without changing native Online state, identity or+ saved fingerprints. This is source/consumer qualification, not installed+ cluster recovery or attribution of an existing user report.+++ ### Proxmox password success admits a complete session, not just HTTP 200++ PVE and PBS consume the entire existing byte-bounded login body before+ publishing ticket, CSRF token and the normal two-hour expiry together. The+ shared `internal/securityutil/proxmox_session.go` parser requires canonical,+ unambiguous envelope/session keys, complete UTF-8 JSON, a nonempty cookie-safe+ ticket and a nonempty header-safe CSRF token. Unknown unique metadata such as+ username and capabilities remains supported. Partial/null, duplicate or+ case-conflicting credentials, extra JSON values, incomplete reads and oversized+ tails fail without replacing the retained tuple or advancing PVE generation.+ Validation errors contain no response credentials. A malformed success is not+ a provider credential refusal and does not trigger JSON-to-form fallback.++ `session_response_admission_test.go` in both client packages exercises these+ controls and eight joined expired readers, zero subsequent API/form requests+ on invalid success, retained state and distinct later ordinary recovery with+ coherent cookie/CSRF pairs. Cluster recovery additionally checks empty and+ partial success for the retained polling client, with and without a previous+ client. `TestPBSInvalidSessionKeepsFirstPollBoundary` exercises the real pinned+ constructor, normal startup retry, poll executor and production broadcast:+ invalid success installs no client, valid construction is not healthy telemetry,+ and only the accepted first poll publishes recovered node/datastore readings.++ TLS trust, credentials, auth encodings and 400/415 fallback, API-token paths,+ renewal ownership, retries/cadence, guest/backup fences and History are unchanged.+ The parser establishes response integrity, not cryptographic ticket validation+ or native/installed acceptance. It neither attributes nor resolves a reported+ PBS, Windows guest, restart or workload-safety incident.+++ ### Rejected infrastructure URLs stay out of diagnostics++ PVE/PBS constructors validate a host before logging it. URL syntax errors omit+ `url.Parse`'s copy of the supplied input; ordinary validation reasons remain.+ Cluster logs, health snapshots, recovery summaries and aggregate errors use+ display-only labels:+ a valid base URL or `[invalid endpoint]`. Health snapshots preserve each entry+ even when rejected endpoints share that label, and are built only for enabled+ log events. These labels never supply routing,+ alias membership, saved configuration or TLS-pin identity. HTTP/HTTPS defaults,+ base paths, authentication, CA/pin/opt-out choices and guest fences are unchanged.++ `TestClientRejectedHostDiagnosticsContainNoCredentials` and+ `TestClusterRejectedEndpointDiagnosticsContainNoCredentials` exercise actual+ constructors, single/multiple endpoint routing and recovery with synthetic+ userinfo/query/fragment and malformed URLs. Accepted-host and+ `TestInfrastructureURLValidationPolicyUnchanged` controls preserve ordinary+ routing and diagnostics. This bounds client diagnostics, not arbitrary provider+ error text, previously saved logs, native trust recovery or an installed service.+### Patrol maintenance coverage widens no authorityPatrol inherits only maintenance from an ancestor window scoped@@@ -3426,46 -3430,16 +3578,60 @@@ controls in `send_report_test.go` and `status/endpoint, non-disclosure and resumed ordinary reporting with the samecredential. They are not a credential inventory probe or native recovery proof.+### Concurrent chart service publication retains tenant boundaries (16 October 2026)++`internal/api/router.go` initializes each router's chart service through the+same guarded accessor used by concurrent history and chart requests. The+service remains scoped to its router and resolves the monitor from the current+request context. This synchronizes publication without changing authentication,+authorization, tenant selection or disclosure. The concurrent initialization+regression in `internal/api/contract_test.go` and the existing+`TestMultiTenant_TenantIsolation` race test verify that boundary.++### Instance administration refuses organization owners (17 October 2026)++`ensureAdminSession`, the session check behind `RequireAdmin` and the settings+scope helpers, admits only instance administrators: the configured admin or an+instance RBAC admin grant, whichever organization the request names. It used+to admit any manager of the request's organization, which on a multi-tenant+install let an organization owner rotate the instance administrator's API+token and receive its secret, widen token scopes, change SSO providers and+system settings, apply updates and restart the service. API tokens follow the+same boundary: `ensureAdminSession` and `ensureSettingsScope` refuse a token+bound to any organization other than the default one (`tokenActsForInstance`)+whatever its scopes. Before that, an org-bound `settings:write` token resolved+to its own organization without naming it, passed the tenant middleware and+reached system settings, SSO providers, token management, relay, log level,+updates and diagnostics. `internal/api/org_bound_token_authority_test.go` holds+the token matrix. Routes that act only on+the request organization opt in through `RequireOrgAdmin`,+`ensureOrgAdminSession` or `ensureOrgSettingsWriteScope`; every other route fails+closed. `internal/api/org_admin_session_authority_test.go` holds the session+matrix and `TestSettingsWriteScopeSplitsInstanceAndOrgManagerSession` the+settings scope split.++### Backup report renderer hook preserves authority++The server supplies `GenerateBackupHealthReportFunc` from BusinessHooks before+router and scheduler construction, and clears it for runtimes without the hook.+The callback receives already-scoped recovery evidence and effective branding.+It adds no route, organization selection, credential, action or licensing+authority. Existing report administrator/settings scopes and advanced-reporting+checks remain before generation and delivery. Missing private rendering fails+explicitly. `pkg/server/server_test.go` retains runtime identity separation.+Backup reporting tests cover missing renderer and unchanged entitlement refusal.+The live disposable Pro runtime proof exercises actual registered rendering.+++ ### Diagnostics does not prescribe credential or ACL churn (14 October 2026)++ Proxmox 403 is an access denial, not evidence that a saved token must be+ rotated or privileges broadened. Diagnostic recovery keeps intentional target+ boundaries, both user/token ACLs and privilege separation; 401 replacement is+ conditional on confirmed invalidity. Typed HTTP status precedes untrusted+ provider text. The existing displayed error summary uses connection positions+ and fixed diagnoses/guidance, not host, token, username or provider-body text.+ No credential, TLS, authorization, caller-filtering or endpoint contract is+ weakened. The diagnostic wire/identity and ordinary same-credential recovery+ controls in `diagnostics_access_test.go`, `diagnostics_additional_test.go`,+ `contract_test.go` and `client_request_test.go` cover these properties; they do+ not establish provider or installed acceptance.diff --cc docs/release-control/v6/internal/subsystems/storage-recovery.mdindex 7ae4b3701f,980a11295e..79b077b9fc--- a/docs/release-control/v6/internal/subsystems/storage-recovery.md+++ b/docs/release-control/v6/internal/subsystems/storage-recovery.md@@@ -21,40 -21,30 +21,64 @@@## Purpose+### Patrol timer checkpoints preserve run and recovery history++The existing Patrol history envelope retains the next scheduled deadline and+its effective interval. History and timer writes share a serialized+read-modify-write boundary, preserving each other's records, daily tallies and+cursor. A failed history read must fail the timer write instead of replacing+unreadable evidence. The configuration and Patrol history tests cover concurrent+writes, file reconstruction and failed-write retry. This cursor schedules a+check only; it grants no additional recovery execution authority.++### Recurring findings preserve the ownership of recovery evidence++Storage and recovery findings use the same occurrence-bound investigation+projection as other Patrol findings. A previous verified action remains+historical evidence when the finding is re-detected; it cannot resolve the new+occurrence or replace its investigation record. Finding-scoped investigation+and transcript reads select the current session, including an explicit absent+state before a new session starts. Explicit session and action history retain+the earlier result. The shared three-occurrence and persisted-restart controls+live in `internal/api/ai_handlers_patrol_actions_additional_test.go`.++### Recovery APIs and investigations share the org-scoped point reader++`Manager.ListPointsForOrg` selects the composed recovery evidence source for+both the HTTP points API and investigation tools. Real installations retain+tenant-scoped SQLite reads, including errors; demo composition projects the+current canonical fixture graph through shared recovery filters and pagination.+It does not seed a second store or grant recovery execution. Source selection is+bound before consumers share the manager and follows runtime demo-mode changes+without exposing persisted rows through demo reads. Manager boundary tests preserve tenant+validation, cancellation and read failures; the API/tool parity regression in+`internal/api/investigation_evidence_parity_test.go` reads actual graph-owned+failure text without a PVE command connection.++ ### Known PBS health survives unreadable backup inventories (13 October 2026)++ Backups keeps the separately supplied PBS server/datastore projection mounted+ while PVE and PBS inventories load, fail or recover. Inventory notices and+ source-local retries remain explicit; both failures still suppress the inventory+ summary rather than claim zero restore points or no backups. PBS counts are+ Loading/Unavailable until its own valid response arrives; resource health,+ capacity, identity and detail access remain independent. No backup execution,+ agent requirement, credential/access change or reporter recovery is implied.+ `ProxmoxBackupsTable.test.tsx` covers both pending reads, each source failure,+ both failures and ordinary recovery without replacing the known server table.++ ### Portable installation input does not change recovery authority++ The backend setup/Proxmox/container copied-command reader can use BusyBox `stty`+ when standalone `stty` is absent. Tool or terminal-mode failures stop before+ installation; full same-tool restoration and silent overflow draining retain+ the private credential boundary. The shorter root/sudo dispatch adds no root+ profile, state/identity replacement, backup operation or incident-replay right.+ Reported QNAP installed boot/watchdog/removal/reinstall recovery remains a+ separate native outcome; source PTYs and publishing an incoming updater do+ not establish it. `portable_bootstrap_test.go` and the serialized API contract+ cover these producer boundaries without touching stored monitoring data.+### Patrol maintenance coverage adds no recovery executionPatrol's operator-state projection now projects the active recurringdiff --cc docs/release-control/v6/internal/subsystems/unified-resources.mdindex a7fb62876c,ae1c7ca7eb..ceb9d09e21--- a/docs/release-control/v6/internal/subsystems/unified-resources.md+++ b/docs/release-control/v6/internal/subsystems/unified-resources.md@@@ -23,22 -23,63 +23,79 @@@ and sort the complete canonical change## Purpose+### Docker object aliases do not identify their reporting host++Containers and other Docker child objects own their native IDs, names and+subject-typed discovery/metrics targets. Reporting-agent IDs, Docker host IDs,+hostnames and task placement nodes remain routing metadata, not child aliases.+Canonical hostname/platform presentation must not reintroduce those parent+identities. Missing child targets cannot promote the parent to primary identity.+Host aliases and same-entity host facets retain their existing semantics.++`TestDockerChildIdentityDoesNotClaimItsCommandHost` covers all nine child kinds,+owned aliases and missing-target boundaries. The registered Docker log-read+control in `internal/ai/tools/internal_routing_identity_test.go` consumes actual+registry ingestion with collected containers, images and networks. Genuine+duplicate names must still fail closed. Source controls alone do not establish+installed command transport or autonomous recovery.++ ### Workload aggregate disk presence survives projection (14 October 2026)++ `useWorkloads` does not default an absent aggregate disk usage/used byte field+ to zero merely because capacity was supplied. Both REST and owning snapshots+ preserve the difference between capacity-only inventory and finite measured+ usage. Explicit zero percentages, percentage-only metrics and valid byte-only+ metrics remain available. This aggregate metric contract is distinct from+ DiskInfo filesystem records whose zero byte fields may be omitted. Identity,+ producer selection, collection, retention and History transport are unchanged.++ Raw byte metrics always serialize a generic `value`, even its default zero.+ That scalar cannot confer a current percentage: an explicit `percent` or a+ valid used/total byte pair is required when `unit` names bytes. Legacy untyped+ value-only percentages and explicit percent-unit values remain usable.++ Verification: `useWorkloads.test.ts` exercises mounted REST and owning-snapshot+ refreshes and `workloadDiskUsage.test.ts` covers numeric admission. The+ `workload-disk-metrics` browser fixture consumes the REST mapper into production+ rows/drawer with synthetic evidence; browser proof is retained separately and+ establishes no installed/native recovery.+++ ### Workloads preserve platform guest interfaces — issue #2757++ Both the `/api/resources` and owning canonical-snapshot Workloads projections+ retain `proxmox.networkInterfaces` when the linked agent reports no interface+ list. A present agent list still wins, including an explicit empty list;+ lists from different producers are not merged. Names, addresses, MACs and+ reported traffic retain their association. The selected identity/IP order,+ canonical row and History coordinates do not change.++ `networkInterfacesFromAgent` is internal frontend provenance. Only the selected+ agent list inherits `agentStale` in the drawer's Network section. A silent linked+ agent still marks its other readings last known, but cannot mark independently+ supplied Proxmox interfaces as its last report. Legacy drawer callers keep their+ existing agent-freshness semantics. This adds no wire field, guest query,+ collection command, permission or native freshness/recovery guarantee.++ `useWorkloads.test.ts` checks REST/snapshot VM and LXC source transitions,+ agent precedence, empty/absent lists, IP order and stable canonical identity;+ `GuestDrawer.test.tsx` checks reactive source-specific last-known presentation+ without clearing agent RAID/filesystem warnings. Desktop and narrow browser+ proof must consume producing JSON, not manually populated WorkloadGuest rows.+ The row's existing Network tooltip uses semantic foreground/muted tokens for+ names, addresses, MACs, traffic and the address-only fallback. Fixed dark-palette+ text must not make the newly retained names unreadable on a light surface.++ ### Independently known PBS remains available in Backups (13 October 2026)++ The resource-owned PBS table is outside backup-inventory loading/error gates.+ Its canonical identity, datastore health/capacity and details remain usable+ when either or both inventory endpoints fail. Error/loading counts are not zero+ backup evidence. The inventory-only surface retains incomplete notices and+ ordinary retries. `ProxmoxBackupsTable.test.tsx` checks stable server-table+ ownership through loading, single/both failures and valid response recovery.+ This consumes existing resources; it adds no producer or native recovery claim.+### Shared interpretation of selected guest memory`GuestMemoryEvidenceForResource` and the VM/container `MemoryEvidence` accessorsdiff --cc frontend-modern/browser-tests/resource-stopped-filesystem.cjsindex 826564e1f1,826564e1f1..03364df79b--- a/frontend-modern/browser-tests/resource-stopped-filesystem.cjs+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.cjs@@@ -3,7 -3,7 +3,8 @@@ const fs = require('node:fs')const path = require('node:path');const crypto = require('node:crypto');const { chromium, webkit } = require('playwright');--const root = '/workspace/frontend-modern';++const workspace = process.env.PULSE_BROWSER_PROOF_ROOT || '/workspace';++const root = path.join(workspace, 'frontend-modern');const origin = 'http://127.0.0.1:5343';const hash = (file) => crypto.createHash('sha256').update(fs.readFileSync(file)).digest('hex');const runtime = [@@@ -12,6 -12,6 +13,7 @@@'frontend-modern/src/components/Infrastructure/ResourceDetailDrawer.tsx','frontend-modern/src/components/Workloads/GuestDrawerHistory.tsx','frontend-modern/src/utils/workloadGuestPresentation.ts',++ 'frontend-modern/src/utils/memoryObservation.ts',];const settle = (page) =>page.evaluate(async () => {@@@ -20,13 -20,13 +22,18 @@@});async function verify(original = false) {-- const output = `/workspace/tmp/resource-stopped-filesystem/browser-${original ? 'original' : 'final'}`;++ const output = path.join(++ workspace,++ `tmp/resource-stopped-filesystem/browser-${original ? 'original' : 'final'}`,++ );fs.mkdirSync(output, { recursive: true });const result = {result: 'incomplete',phase: original ? 'original-adverse-observation' : 'candidate-verification',playwright: require('playwright/package.json').version,-- runtime_hashes: Object.fromEntries(runtime.map((file) => [file, hash('/workspace/' + file)])),++ runtime_hashes: Object.fromEntries(++ runtime.map((file) => [file, hash(path.join(workspace, file))]),++ ),cases: [],screenshots: [],cleanup: { browsers: false, server: false },@@@ -35,9 -35,9 +42,8 @@@};assert.equal(result.playwright,-- JSON.parse(fs.readFileSync('/workspace/tests/integration/package-lock.json')).packages[-- 'node_modules/@playwright/test'-- ].version,++ JSON.parse(fs.readFileSync(path.join(workspace, 'tests/integration/package-lock.json')))++ .packages['node_modules/@playwright/test'].version,);process.chdir(root);const { createServer } = await import(path.join(root, 'node_modules/vite/dist/node/index.js'));@@@ -53,6 -53,6 +59,7 @@@await server.listen();for (const [name, engine, width, height, dark] of [['chromium-desktop-light', chromium, 1280, 900, false],++ ['chromium-tablet-light', chromium, 1024, 768, false],['webkit-phone-dark', webkit, 390, 844, true],]) {browser = await engine.launch(@@@ -308,6 -308,6 +315,68 @@@);await apply({ type: 'vm', power: 'stopped', status: 'online', reason: '', usage: 90 });await unavailable();++ // Selected memory freshness belongs to its source, independently of guest type.++ for (const type of ['vm', 'system-container']) {++ await apply({++ type,++ power: 'running',++ status: 'online',++ memorySource: 'agent',++ memoryState: 'current',++ memoryUsage: 0,++ agentStale: false,++ });++ assert.match(++ await chart.locator('[data-history-current="memory"]').innerText(),++ /0\.0%\s*current/,++ );++ const memoryReads = reads();++ await apply({ agentStale: true });++ assert.equal(await chart.locator('[data-history-current="memory"]').count(), 0);++ assert.match(++ await chart.locator('[data-history-last-known="memory"]').innerText(),++ /0\.0%/,++ );++ assert.match(++ await chart.locator('[data-history-deferred="memory"]').innerText(),++ /Last known/,++ );++ assert.match(++ await chart.locator('[data-history-deferred="memory"]').innerText(),++ /2026-10-10 00:00:00 UTC/,++ );++ record.states.push({ state: `${type}-agent-stale`, text: await chart.innerText() });++ await capture(`${type}-agent-stale`);++ await apply({ memorySource: 'cluster-resources', memoryUsage: 95 });++ assert.match(++ await chart.locator('[data-history-current="memory"]').innerText(),++ /95\.0%\s*current/,++ );++ await capture(`${type}-provider-current`);++ await apply({ memoryState: 'last-known' });++ const memoryText = await chart.locator('[data-history-deferred="memory"]').innerText();++ if (type === 'vm') assert.match(memoryText, /may include cache/i);++ else assert.doesNotMatch(memoryText, /may include cache/i);++ await capture(`${type}-provider-retained`);++ await apply({ memorySource: 'agent', memoryState: 'unknown', agentStale: false });++ assert.equal(await chart.locator('[data-history-current="memory"]').count(), 0);++ assert.match(++ await chart.locator('[data-history-deferred="memory"]').innerText(),++ /Freshness unknown/,++ );++ await apply({ memoryState: 'current' });++ assert.equal(reads(), memoryReads);++ }++ record.checks.push(++ 'A stale selected agent retains its original memory observation for VM and LXC; independent Proxmox memory stays current, with the cache caveat only for VMs.',++ );++ await apply({++ type: 'vm',++ power: 'stopped',++ memorySource: 'agent',++ memoryUsage: 0,++ agentStale: false,++ });mode = 'stored';const read = page.waitForResponse((r) => r.url().includes('/api/metrics-store/history'));await page.clock.runFor(30_000);diff --cc frontend-modern/browser-tests/resource-stopped-filesystem.tsxindex dc7c35b3b4,dc7c35b3b4..73a2bf24e1--- a/frontend-modern/browser-tests/resource-stopped-filesystem.tsx+++ b/frontend-modern/browser-tests/resource-stopped-filesystem.tsx@@@ -25,6 -25,6 +25,10 @@@ type Snapshot =platform: Resource['platformType'];scopes?: Resource['platformScopes'];seen: number;++ memorySource?: string;++ memoryState?: string;++ memoryUsage?: number;++ agentStale?: boolean;};function Fixture() {@@@ -54,9 -54,9 +58,14 @@@},cpu: { current: 10 },memory: {-- current: 0,-- observation: { state: 'current', source: 'agent', observedAt: '2026-10-10T00:00:00Z' },++ current: snapshot().memoryUsage ?? 0,++ observation: {++ state: snapshot().memoryState ?? 'current',++ source: snapshot().memorySource ?? 'agent',++ observedAt: '2026-10-10T00:00:00Z',++ },},++ agent: { stale: snapshot().agentStale === true },disk: { current: snapshot().usage },network: { rxBytes: 0, txBytes: 200 },proxmox: {diff --cc frontend-modern/browser-tests/unix-private-install.cjsindex 96e520158d,62f3566191..1d4c744fbb--- a/frontend-modern/browser-tests/unix-private-install.cjs+++ b/frontend-modern/browser-tests/unix-private-install.cjs@@@ -2,24 -2,45 +2,46 @@@const assert = require('node:assert/strict');const fs = require('node:fs');const path = require('node:path');+ const http = require('node:http');+ const crypto = require('node:crypto');const { chromium, webkit } = require('playwright');+ const hash = (bytes) => crypto.createHash('sha256').update(bytes).digest('hex');(async () => {-- const root = '/workspace/frontend-modern';- process.chdir(root);- console.log(- JSON.stringify({- fixtureHTML: fs.existsSync(path.join(root, 'browser-tests/unix-private-install.html')),- fixtureTSX: fs.existsSync(path.join(root, 'browser-tests/unix-private-install.tsx')),- }),- );- const artifacts = path.join(root, 'node_modules', 'unix-private-browser');- fs.mkdirSync(artifacts, { recursive: true });- const { createServer } = await import(path.join(root, 'node_modules/vite/dist/node/index.js'));- const server = await createServer({- root,- configFile: path.join(root, 'vite.config.ts'),- server: { host: '127.0.0.1', port: 5241, strictPort: true },- const artifacts = '/workspace/tmp/unix-private-install';++ const workspace = process.env.PULSE_BROWSER_PROOF_ROOT || '/workspace';++ const root = path.join(workspace, 'frontend-modern');++ const artifacts = path.join(workspace, 'tmp/unix-private-install');+ const preview = path.join(artifacts, 'static');+ const bindingBytes = fs.readFileSync(path.join(preview, 'binding.json'));+ const binding = JSON.parse(bindingBytes);+ for (const [file, expected] of Object.entries(binding.sources))+ assert.equal(hash(fs.readFileSync(path.join(root, file))), expected, file);+ for (const [file, expected] of Object.entries(binding.artifacts))+ assert.equal(hash(fs.readFileSync(path.join(preview, file))), expected, file);+ const served = [];+ const server = http.createServer((req, res) => {+ const file = new URL(req.url, 'http://fixture.invalid').pathname.slice(1);+ if (!['GET', 'HEAD'].includes(req.method) || !Object.hasOwn(binding.artifacts, file)) {+ res.writeHead(404);+ res.end();+ return;+ }+ const bytes = fs.readFileSync(path.join(preview, file));+ assert.equal(hash(bytes), binding.artifacts[file]);+ served.push({ file, sha256: hash(bytes) });+ res.writeHead(200, {+ 'Content-Type': file.endsWith('.js')+ ? 'text/javascript'+ : file.endsWith('.css')+ ? 'text/css'+ : 'text/html',+ 'Cache-Control': 'no-store',+ });+ res.end(bytes);});+ const captures = [],+ consumerCommands = [],+ requests = [];+ let cleanup = { browser_closed: false, server_closed: false };const results = [];let browser;const secret = 'browser-synthetic-install-token';@@@ -38,7 -63,37 +64,38 @@@viewport: { width, height: 900 },...(engine === 'webkit' ? { isMobile: true, hasTouch: true } : {}),});++ await page.clock.install();const errors = [];+ const capture = async (name, locator) => {+ if (locator)+ await locator.evaluate((el) => window.scrollBy(0, el.getBoundingClientRect().top - 48));+ await page.evaluate(+ () =>+ new Promise((resolve) => requestAnimationFrame(() => requestAnimationFrame(resolve))),+ );+ assert.equal(+ await page.evaluate(() => document.documentElement.scrollWidth <= innerWidth),+ true,+ name,+ );+ const file = `${engine}-${tone}-${name}.png`;+ await page.screenshot({ path: path.join(artifacts, file) });+ captures.push({+ file,+ sha256: hash(fs.readFileSync(path.join(artifacts, file))),+ engine,+ tone,+ width,+ height: 900,+ });+ };+ const activate = async (locator) => {+ if (engine === 'webkit') await locator.tap();+ else {+ await locator.focus();+ await page.keyboard.press('Enter');+ }+ };page.on('pageerror', (e) => errors.push(e.message));page.on('console', (m) => {if (m.type() === 'error') {@@@ -48,6 -103,6 +105,8 @@@});page.on('requestfailed', (r) => console.log('REQUEST_FAILED', r.url(), r.failure()));let minted = 0;++ let lookupReads = 0;++ const seen = new Date(Date.now() - 5000).toISOString();let optionalAuth = false;await page.addInitScript(() => {window.__copies = [];@@@ -84,6 -142,6 +146,21 @@@},});}++ if (url.pathname === '/api/agents/agent/lookup') {++ lookupReads++;++ return route.fulfill({++ json: {++ agent: {++ id: 'fixture-connected',++ hostname: 'fixture-host',++ displayName: 'Fixture host',++ connected: true,++ status: 'online',++ lastSeen: seen,++ },++ },++ });++ }if (url.pathname === '/api/state')return route.fulfill({ json: { connectedInfrastructure: [] } });return route.fulfill({ json: { data: [] } });@@@ -162,6 -248,6 +267,22 @@@await page.getByRole('button', { name: 'Show advanced connection and install options', exact: true }).click();++ const signing = page++ .locator('div')++ .filter({ has: page.getByText('Config signing (optional)', { exact: true }) })++ .last();++ for (const key of [++ 'PULSE_AGENT_CONFIG_SIGNATURE_REQUIRED=true',++ 'PULSE_AGENT_CONFIG_SIGNING_KEY',++ 'PULSE_AGENT_CONFIG_PUBLIC_KEYS',++ ]) {++ const code = signing.getByText(key, { exact: true });++ await code.scrollIntoViewIfNeeded();++ const bounds = await code.boundingBox();++ assert.ok(bounds && bounds.x >= 0 && bounds.x + bounds.width <= width, key);++ assert.match(await code.getAttribute('class'), /wrap-anywhere/);++ }++ await capture('config-signing', signing);await page.getByLabel('Connection URL (Agent → Pulse)', { exact: true }).fill('https://pulse.example/base/');@@@ -203,12 -289,13 +324,23 @@@'Never insert the token into the command',),);- await page.screenshot({- path: path.join(artifacts, `${engine}-commands.png`),- fullPage: true,- });+ await capture(+ 'trust-options',+ page.getByLabel('Custom CA certificate path (optional)', { exact: true }),+ );+ consumerCommands.push({ engine, tone, kind: 'linux-install', command: unixCommands[0] });++ await page.getByPlaceholder('Hostname or agent ID').fill('fixture-host');++ await page.getByRole('button', { name: 'Check status', exact: true }).click();++ await page.getByText('First host connected', { exact: true }).waitFor();++ const age = page.getByText(/^Last seen /);++ const initialAge = await age.innerText();++ const readsBeforeTick = lookupReads;++ await page.clock.runFor(65_000);++ assert.notEqual(await age.innerText(), initialAge);++ assert.equal(lookupReads, readsBeforeTick);++ await capture('connected-age', age);optionalAuth = true;- await page.goto('http://127.0.0.1:5241/browser-tests/unix-private-install.html?optional=1');+ await page.goto(`${origin}/browser-tests/unix-private-install.html?optional=1`);await page.getByRole('button', { name: 'Confirm without token', exact: true }).click();const optionalCode = page.locator('code').filter({ hasText: 'bootstrap_dir=$(mktemp' });const optionalCommands = await optionalCode.allTextContents();@@@ -242,15 -329,38 +374,38 @@@await browser.close();browser = undefined;}- assert.equal(captures.length, 16);++ assert.equal(captures.length, 24);+ } finally {+ if (browser) await browser.close();+ cleanup.browser_closed = true;+ await new Promise((resolve) => server.close(resolve));+ cleanup.server_closed = true;+ fs.writeFileSync(+ path.join(artifacts, 'consumer-commands.json'),+ JSON.stringify({ source: binding.source_sha, consumerCommands }, null, 2) + '\n',+ );fs.writeFileSync(path.join(artifacts, 'result.json'),- JSON.stringify({ playwright: require('playwright/package.json').version, results }, null, 2),+ JSON.stringify(+ {+ source: binding.source_sha,+ binding_sha256: hash(bindingBytes),+ source_inputs: Object.keys(binding.sources).length,+ playwright: require('playwright/package.json').version,+ results,+ captures,+ requests,+ served,+ cleanup,+ },+ null,+ 2,+ ) + '\n',);- console.log(JSON.stringify({ result: 'passed', artifacts, results }));- } finally {- if (browser) await browser.close();- await server.close();}+ console.log(+ JSON.stringify({ result: 'passed', artifacts, results, captures: captures.length, cleanup }),+ );})().catch((e) => {console.error(e);process.exitCode = 1;diff --cc frontend-modern/public/docs/UPGRADE_v6.mdindex ec3222b328,bfef9cf395..482bb3f0df--- a/frontend-modern/public/docs/UPGRADE_v6.md+++ b/frontend-modern/public/docs/UPGRADE_v6.md@@@ -1,11 -1,16 +1,16 @@@# Upgrade to Pulse v6- This guide covers practical upgrade steps for existing Pulse installs moving to v6.+ This guide covers the v5-to-v6 migration and its compatibility changes. For+ updates within v6, use [Updating Pulse](AUTO_UPDATE.md); the historical packets+ below are context, not an instruction to install an old version or downgrade.+ Choose an actually [published software release](https://github.com/rcourtman/Pulse/releases),+ not a draft, source tag or Helm-chart asset. Keep the existing runtime edition:+ public Community downloads do not replace a private Pro build.-For the current v6 beta packet, see:+For the current v6 release candidate packet, see:-- `docs/releases/RELEASE_NOTES_v6.6.0-beta.3.md`-- `docs/releases/V6_CHANGELOG_v6.6.0-beta.3.md`+- `docs/releases/RELEASE_NOTES_v6.6.0-rc.4.md`+- `docs/releases/V6_CHANGELOG_v6.6.0-rc.4.md`For the current stable v6 packet, see:diff --cc frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.tsindex d9a15c7c44,d90fe3717d..119efcf262--- a/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts+++ b/frontend-modern/src/components/Infrastructure/__tests__/resourceDetailDrawerMetricsHistoryModel.branchcov0712.test.ts@@@ -67,18 -67,6 +67,48 @@@ describe('canonical drawer History hono},);+ it('qualifies a retained Proxmox listing reading by the guest kind', () => {+ const listing = (type: 'vm' | 'system-container') => {+ const value = { ...resource('last-known'), type };+ value.memory!.observation!.source = 'cluster-resources';+ return getResourceMetricsHistoryDeferredMetrics(value).memory.message;+ };+ // A QEMU listing counts the guest's cache; a container's has it removed.+ expect(listing('vm')).toContain('cached memory the VM can reuse');+ expect(listing('system-container')).not.toContain('cached memory');+ expect(listing('system-container')).toContain('Source: Proxmox.');+ });+++ it.each(['vm', 'system-container'] as const)(++ 'keeps %s agent freshness independent of provider memory interpretation',++ (type) => {++ const value = { ...resource('current', 0), type, agent: { stale: false } };++ value.memory!.observation!.source = 'agent';++ expect(getResourceMetricsHistoryCurrentMetrics(value).memory).toBe(0);++ value.agent.stale = true;++ expect(getResourceMetricsHistoryCurrentMetrics(value).memory).toBeUndefined();++ expect(getResourceMetricsHistoryDeferredMetrics(value).memory).toMatchObject({++ lastKnownValue: 0,++ message: expect.stringContaining('stopped reporting'),++ });++ expect(getResourceMetricsHistoryDeferredMetrics(value).memory.message).toContain(++ '2026-10-04 12:00:00 UTC',++ );++ expect(getResourceMetricsHistoryDeferredMetrics(value).memory.message).toContain(++ 'Last known.',++ );++++ // A stale supplemental agent cannot invalidate Proxmox's independent++ // reading or change the VM/LXC distinction of a listing measurement.++ value.memory!.observation!.source = 'cluster-resources';++ expect(getResourceMetricsHistoryCurrentMetrics(value).memory).toBe(0);++ value.memory!.observation!.state = 'last-known';++ const message = getResourceMetricsHistoryDeferredMetrics(value).memory.message;++ expect(message).not.toContain('stopped reporting');++ expect(message.includes('cached memory the VM can reuse')).toBe(type === 'vm');++ },++ );++it.each([-1, 101, NaN, Infinity])('withdraws invalid retained memory %s', (value) => {expect(getResourceMetricsHistoryDeferredMetrics(resource('last-known', value)).memory.lastKnownValue,diff --cc frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.tsindex 775ac3940b,719e5cfbb4..a7f9db1ac9--- a/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts+++ b/frontend-modern/src/components/Infrastructure/resourceDetailDrawerMetricsHistoryModel.ts@@@ -173,14 -171,7 +173,15 @@@ const memoryReading = (resource: Resourresource.memory ? finiteMetric(getMemoryPercent(resource)) : undefined,resource.memory?.observation,isProxmoxGuest(resource),- { agentStale: resource.agent?.stale === true },+ {++ agentStale: resource.agent?.stale === true,+ guestKind:+ resource.type === 'vm'+ ? 'vm'+ : resource.type === 'system-container'+ ? 'container'+ : undefined,+ },);const guestDiskReading = (resource: Resource) => {diff --cc frontend-modern/src/features/docs/__tests__/troubleshootingEntryGuide.test.tsindex 5eadaa9493,7d5d321694..7f6edd4c21--- a/frontend-modern/src/features/docs/__tests__/troubleshootingEntryGuide.test.ts+++ b/frontend-modern/src/features/docs/__tests__/troubleshootingEntryGuide.test.ts@@@ -11,7 -11,7 +11,7 @@@ const renderedGuides = new Map<string,function renderGuide(name: string): HTMLElement {// Several destinations share a long guide. Render each immutable document- // once, rather than making sixteen navigation checks parse it repeatedly.- // once, rather than making seventeen navigation checks parse it repeatedly.++ // once, rather than making navigation checks parse it repeatedly.// entry() clones its section, so the cached article is never modified.const cached = renderedGuides.get(name);if (cached) return cached;@@@ -52,64 -44,7 +52,88 @@@ describe('troubleshooting workflow entrconst section = entry();const link = section.querySelector('a');expect(link?.getAttribute('href')).toBe('/docs/VM_DISK_MONITORING#backup-safety');- expect(section.querySelectorAll('li')).toHaveLength(12);+ // New, independently verified workflows must not break unrelated safety+ // checks. Require every existing job once, without relying on list offsets.+ const requiredWorkflows: [string, string[]][] = [++ [++ 'Not sure which version is affected:',++ ['/docs/TROUBLESHOOTING#find-the-running-server-and-agent-versions'],++ ],++ [++ 'Proxmox or PBS reports a certificate error:',++ ['/docs/TROUBLESHOOTING#proxmox-or-pbs-certificate-validation-failed'],++ ],++ [++ 'Copied agent install or removal command failed:',++ ['/docs/UNIFIED_AGENT#copied-agent-command-fails-before-installation'],++ ],++ [++ 'PBS is Active but missing from monitoring:',++ ['/docs/PBS#pbs-is-active-but-missing-from-monitoring'],++ ],++ [++ 'RAID is reported degraded despite a spare:',++ ['/docs/TROUBLESHOOTING#raid-array-is-degraded-with-a-spare'],++ ],++ [++ 'Unraid reports missing disks in empty slots:',++ ['/docs/TROUBLESHOOTING#unraid-reports-missing-disks-in-empty-slots'],++ ],+ [+ 'Cannot sign in:',+ [+ '/docs/TROUBLESHOOTING#i-forgot-my-password',+ '/docs/TROUBLESHOOTING#cannot-login--401-unauthorized',+ ],+ ],+ [+ 'Update failed or its result is uncertain:',+ [+ '/docs/AUTO_UPDATE#update-failed',+ '/docs/DOCKER#check-a-failed-or-pending-workload-update',+ ],+ ],+ [+ 'Agent host is missing or reporting is rejected:',+ ['/docs/UNIFIED_AGENT#agent-lookup-returns-http-401-or-403'],+ ],+ [+ 'Guest readings are missing or disagree:',+ [+ '/docs/VM_DISK_MONITORING#current-retained-and-unavailable-disk-readings',+ '/docs/TROUBLESHOOTING#guest-memory-is-high-but-available-memory-is-plentiful',+ ],+ ],+ [+ 'Proxmox data belongs to the wrong host, or healthy jobs look Pending:',+ [+ '/docs/TROUBLESHOOTING#monitoring-is-mixed-between-proxmox-installations',+ '/docs/TROUBLESHOOTING#replication-jobs-are-pending-stale-or-missing',+ ],+ ],+ ['TrueNAS readings are stale or absent:', ['/docs/TRUENAS#stale-truenas-data']],+ [+ 'Pulse itself uses more memory, CPU or disk writes:',+ [+ '/docs/TROUBLESHOOTING#memory-use-keeps-growing',+ '/docs/TROUBLESHOOTING#excessive-cpu-writes-or-database-growth',+ ],+ ],+ [+ 'Notification Test works but alerts do not arrive:',+ ['/docs/TROUBLESHOOTING#test-succeeds-but-real-alerts-are-missing'],+ ],+ [+ 'Private information was posted:',+ ['/docs/TROUBLESHOOTING#if-you-already-posted-private-information'],+ ],+ ];+ for (const [label, expectedLinks] of requiredWorkflows) {+ const actual = [...workflow(section, label).querySelectorAll('a[href]')].map((link) =>+ link.getAttribute('href'),+ );+ expect(actual, label).toEqual(expect.arrayContaining(expectedLinks));+ }expect(section.querySelector('pre')).toBeNull();const beforeList = [...section.children].slice(@@@ -127,7 -62,24 +151,17 @@@it('keeps server updates, workload updates and reporting acceptance distinct', () => {const section = entry();- const row = (label: string) => {- const rows = [...section.querySelectorAll('li')].filter((element) =>- prose(element.querySelector('strong') as HTMLElement).startsWith(label),- );- expect(rows, label).toHaveLength(1);- return rows[0] as HTMLElement;- };- const update = row('Update failed or its result is uncertain');- const install = row('Agent host is missing or reporting is rejected');- const command = row('Copied agent install or removal command failed');- const reporting = row('Guest readings are missing or disagree');- const memory = row('Pulse itself uses more memory, CPU or disk writes');- const raid = row('RAID is reported degraded despite a spare');+ const update = workflow(section, 'Update failed or its result is uncertain:');++ const install = workflow(section, 'Agent host is missing or reporting is rejected:');++ const command = workflow(section, 'Copied agent install or removal command failed:');++ const reporting = workflow(section, 'Guest readings are missing or disagree:');++ const memory = workflow(section, 'Pulse itself uses more memory, CPU or disk writes:');++ const raid = workflow(section, 'RAID is reported degraded despite a spare:');+ expect(raid.querySelector('a')?.getAttribute('href')).toBe(+ '/docs/TROUBLESHOOTING#raid-array-is-degraded-with-a-spare',+ );+ expect(prose(raid)).toContain('A spare-inclusive total is not the required member count');+ expect(prose(raid)).toContain('do not change the array just to clear a Pulse alert');expect(prose(update)).toContain('An update of a monitored container is a different job');const updateLinks = [...update.querySelectorAll('a')].map((link) => link.getAttribute('href'));expect(updateLinks).toEqual([diff --cc frontend-modern/src/utils/__tests__/agentInstallCommand.test.tsindex ba725b0946,c0c7be1b52..77565c4616--- a/frontend-modern/src/utils/__tests__/agentInstallCommand.test.ts+++ b/frontend-modern/src/utils/__tests__/agentInstallCommand.test.ts@@@ -389,13 -405,10 +405,14 @@@ history = p.get("history"env = os.environ.copy()if history:env.update(HISTFILE=history, HISTSIZE="100", HISTFILESIZE="100", HISTCONTROL="", PS1="PULSE_TEST$ ")+# Phases share a fixture directory. A marker left by an earlier run would let+# the shell's echo of the command line pass for the real prompt.+try: os.remove(env["READER_PID"])+except FileNotFoundError: passprogram = ["bash", "--noprofile", "--norc", "-i"] if history else ["sh", "-c", p["command"]]child = subprocess.Popen(program, stdin=slave, stdout=slave, stderr=slave, preexec_fn=session, env=env)- if history: os.write(master, (p["command"] + "\\n").encode())+ command_sent = not bool(history)+ exit_sent = Falseos.close(slave)output = b""sent = Falsediff --cc internal/api/contract_test.goindex 001ff0ed25,13341e4ac3..25fd6c0606--- a/internal/api/contract_test.go+++ b/internal/api/contract_test.go@@@ -27275,150 -27263,41 +27304,189 @@@ func TestContract_DiagnosticsTLSGuidanc}}+func TestChartServiceInitializationIsConcurrentAndRouterScoped(t *testing.T) {+ const requests = 64+ router := &Router{}+ start := make(chan struct{})+ services := make(chan *chartapi.Service, requests)+ for range requests {+ go func() {+ <-start+ services <- router.ensureChartService()+ }()+ }+ close(start)++ var shared *chartapi.Service+ for range requests {+ service := <-services+ if service == nil {+ t.Fatal("chart service was not initialized")+ }+ if shared == nil {+ shared = service+ } else if service != shared {+ t.Fatal("concurrent requests received different chart services")+ }+ }+ if router.ensureChartService() != shared {+ t.Fatal("later requests replaced the chart service")+ }+ if (&Router{}).ensureChartService() == shared {+ t.Fatal("different routers shared a chart service")+ }+}++// Login, status and middleware reads of the SSO configuration run on every+// request goroutine while an administrator edits providers, and the legacy+// OIDC_* provider is re-applied on every read. Run under -race.+func TestSSOConfigConcurrentReadsAndAdminWrites(t *testing.T) {+ t.Setenv("OIDC_ENABLED", "true")+ t.Setenv("OIDC_ISSUER_URL", "https://issuer.example.com")+ t.Setenv("OIDC_CLIENT_ID", "pulse-env")++ router, _ := setupTestRouter(t)+ router.ensureSSOConfig()++ const (+ readers = 4+ writers = 4+ rounds = 6+ )++ stop := make(chan struct{})+ var readersWG sync.WaitGroup+ for range readers {+ readersWG.Add(1)+ go func() {+ defer readersWG.Done()+ for {+ select {+ case <-stop:+ return+ default:+ }+ // /api/security/status and the CSRF middleware.+ _ = router.ensureSSOConfig().GetEnabledProviders()+ // OIDC and SAML login handlers.+ if provider := router.getSSOProvider(config.LegacyOIDCProviderID); provider == nil || provider.OIDC == nil || provider.OIDC.ClientID != "pulse-env" {+ t.Error("environment OIDC provider missing during concurrent edits")+ return+ }+ w := httptest.NewRecorder()+ router.handleListSSOProviders(w, httptest.NewRequest(http.MethodGet, "/api/security/sso/providers", nil))+ if w.Code != http.StatusOK {+ t.Errorf("list providers: status %d", w.Code)+ return+ }+ }+ }()+ }++ create := func(id string) int {+ body, _ := json.Marshal(config.SSOProvider{+ ID: id,+ Name: "Provider " + id,+ Type: config.SSOProviderTypeOIDC,+ OIDC: &config.OIDCProviderConfig{+ IssuerURL: "https://issuer.example.com",+ ClientID: id,+ },+ })+ w := httptest.NewRecorder()+ router.handleCreateSSOProvider(w, httptest.NewRequest(http.MethodPost, "/api/security/sso/providers", bytes.NewReader(body)))+ return w.Code+ }+ remove := func(id string) int {+ w := httptest.NewRecorder()+ router.handleSSOProvider(w, httptest.NewRequest(http.MethodDelete, "/api/security/sso/providers/"+id, nil))+ return w.Code+ }++ var writersWG sync.WaitGroup+ for i := range writers {+ writersWG.Add(1)+ go func() {+ defer writersWG.Done()+ for j := range rounds {+ id := fmt.Sprintf("race-%d-%d", i, j)+ if code := create(id); code != http.StatusCreated {+ t.Errorf("create %s: status %d", id, code)+ return+ }+ if code := remove(id); code != http.StatusNoContent {+ t.Errorf("delete %s: status %d", id, code)+ return+ }+ }+ if id := fmt.Sprintf("keep-%d", i); create(id) != http.StatusCreated {+ t.Errorf("create %s failed", id)+ }+ }()+ }+ writersWG.Wait()+ close(stop)+ readersWG.Wait()++ providerIDs := func(cfg *config.SSOConfig) []string {+ ids := make([]string, 0, len(cfg.Providers))+ for _, provider := range cfg.Providers {+ ids = append(ids, provider.ID)+ }+ sort.Strings(ids)+ return ids+ }++ want := []string{"keep-0", "keep-1", "keep-2", "keep-3", config.LegacyOIDCProviderID}+ sort.Strings(want)+ if got := providerIDs(router.ensureSSOConfig()); fmt.Sprint(got) != fmt.Sprint(want) {+ t.Fatalf("published providers = %v, want %v", got, want)+ }++ persisted, err := router.persistence.LoadSSOConfig()+ if err != nil {+ t.Fatalf("load persisted SSO config: %v", err)+ }+ if got := providerIDs(persisted); fmt.Sprint(got) != fmt.Sprint(want[:writers]) {+ t.Fatalf("persisted providers = %v, want %v", got, want[:writers])+ }+}+++ func TestContract_PortablePrivateBootstrapPayloads(t *testing.T) {+ const token = "synthetic-portable-install-token"+ artifact := configapi.BuildSetupScriptInstallArtifact("https://pulse.example", "pbs", "https://pbs.example:8007", "https://pulse.example", false, token, 1900000000)+ payload := map[string]any{+ "setup": artifact,+ "proxmox": AgentInstallCommandResponse{Command: configapi.BuildProxmoxAgentInstallCommand(configapi.AgentInstallCommandOptions{BaseURL: "https://pulse.example", Token: token, InstallType: "pbs", IncludeInstallType: true}), Token: token},+ "container": map[string]string{"command": buildContainerRuntimeAgentInstallCommand("https://pulse.example", token, false), "token": token},+ }+ encoded, err := json.Marshal(payload)+ if err != nil {+ t.Fatal(err)+ }+ var wire map[string]map[string]any+ if err := json.Unmarshal(encoded, &wire); err != nil {+ t.Fatal(err)+ }+ for kind, fields := range wire {+ command, ok := fields["command"].(string)+ if !ok || strings.Contains(command, token) || strings.ContainsAny(command, "\r\n") || strings.Count(command, "bash -c ") != 1 {+ t.Fatalf("%s wire command lost its single private body", kind)+ }+ for _, required := range []string{`"$@" bash -c`, "tty_control=(stty)", "tty_control=(busybox stty)", "Cannot restore terminal settings.", ` -o "$install_script"`} {+ if !strings.Contains(command, required) {+ t.Fatalf("%s wire command lost %s", kind, required)+ }+ }+ credentialKey := "token"+ if kind == "setup" {+ credentialKey = "setupToken"+ if fields["commandWithEnv"] != command || fields["commandWithoutEnv"] != command || fields["downloadURL"] != fields["url"] {+ t.Fatal("setup artifact aliases or credential-free download changed")+ }+ }+ if fields[credentialKey] != token {+ t.Fatalf("%s lost its separate credential field", kind)+ }+ }+ }diff --cc internal/monitoring/guest_agent_transport_integration_test.goindex 6ae60c8084,8a459a7c72..c4483ad7f5--- a/internal/monitoring/guest_agent_transport_integration_test.go+++ b/internal/monitoring/guest_agent_transport_integration_test.go@@@ -90,7 -109,13 +109,12 @@@ func testGuestAgentTransportDeferralKee}}))defer server.Close()- client, err := proxmox.NewClient(proxmox.ClientConfig{Host: server.URL, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: guestPollFixtureHangGuard})+ host := server.URL- timeout := time.Second++ timeout := guestPollFixtureHangGuard+ if strings.HasPrefix(kind, "foreign ") {- timeout = 15 * time.Second+ host += "/command-reply-fixture/" + strings.ReplaceAll(kind, " ", "-")+ }+ client, err := proxmox.NewClient(proxmox.ClientConfig{Host: host, TokenName: "fixture@pve!pulse", TokenValue: "fixture", Timeout: timeout})if err != nil {t.Fatal(err)}@@@ -106,8 -132,31 +133,31 @@@t.Fatal("VM disappeared")}m.recordGuestSnapshot("transport", "qemu", "node", 105, GuestMemorySnapshot{Name: vm.Name, Status: vm.Status, RetrievedAt: at, MemorySource: source, Memory: vm.Memory, Raw: raw, Notes: notes})- m.recordGuestMetrics([]models.VM{vm}, nil, time.Now().Add(-time.Second))+ m.recordGuestMetrics([]models.VM{vm}, nil, cycleStart)previous = &vm+ if preserveOrigins {+ // The safe fixture's actual builder/broadcast output is also+ // available for consuming browser proof. Do not hand-author a+ // fresh/last-known carrier or replace its observation time.+ m.state.UpdateVMs([]models.VM{vm})+ front := m.buildBroadcastFrontendStateFromSnapshot(m.state.GetSnapshot(), m.mockModeFence.begin())+ if len(front.Resources) != 1 {+ t.Fatal("typed-reply producer lost the canonical guest")+ }+ wire, err := json.Marshal(map[string]any{+ "kind": kind, "phase": phase.Load(), "guestCommands": calls.Load(),+ "vm": vm, "resources": front.Resources,+ "history": m.metricsHistory.GetAllGuestMetrics(identity, time.Hour),+ })+ if err != nil {+ t.Fatal(err)+ }+ marker := "TYPED_REPLY_PRODUCER"+ if strings.HasPrefix(kind, "foreign ") {+ marker = "COMMAND_REPLY_PRODUCER"+ }+ t.Logf("%s %s", marker, wire)+ }return vm, source}initial, source := build()diff --cc scripts/installtests/agent_upstart_teardown.pyindex f8a15970dd,0d42c09a9c..1025de3661--- a/scripts/installtests/agent_upstart_teardown.py+++ b/scripts/installtests/agent_upstart_teardown.py@@@ -123,11 -150,14 +150,17 @@@ class AgentUpstartTeardown(unittest.Testools = root / "tools"; tools.mkdir()for name in ("ps", "initctl"):p = tools / name; p.write_text(MODEL); p.chmod(0o700)+ link = tools / "fixture-link.py"; link.write_text(LINK_MODEL)+ # Native macOS ln lacks -T. No host ln implementation may determine+ # whether these closed DSM semantics or restoration controls pass.+ external_link = tools / "ln"+ external_link.write_text("#!/bin/sh\nprintf 'unexpected external ln\\n' >&2\nexit 96\n")+ external_link.chmod(0o700)if fault == "missing-initctl": (tools / "initctl").unlink()- init = root / "init"; init.mkdir()+ # The installer refuses a group- or world-writable job directory.+ # Give it an explicit mode so a caller umask of 002 cannot make+ # the trusted fixture look untrusted.+ init = root / "init"; init.mkdir(mode=0o755)config = init / "pulse-agent.conf"unrelated = root / "unrelated"; unrelated.write_text("retain unrelated recovery\n")if conf == "linked": config.symlink_to(unrelated)diff --cc scripts/installtests/native_installer_fixture_tools_test.goindex 0161a758e1,a1dd4ebf48..14990a7c48--- a/scripts/installtests/native_installer_fixture_tools_test.go+++ b/scripts/installtests/native_installer_fixture_tools_test.go@@@ -50,9 -159,8 +159,8 @@@ func TestNativeInstallerPhasesKeepNASBe}func TestNativeInstallerFixtureToolsAreRealAndStepLocal(t *testing.T) {- supply, installer := nativeInstallerFixtureSteps(t)- for _, scenario := range []string{"real tools", "install failure", "missing bash", "legacy bash", "missing stat", "non-GNU chmod", "missing mv", "non-GNU mv", "missing ln", "non-GNU ln", "missing tar", "non-GNU tar"} {+ supply, preflight, installer := nativeInstallerFixtureSteps(t)- for _, scenario := range []string{"real tools", "install failure", "missing bash", "legacy bash", "missing stat", "non-GNU chmod", "missing mv", "non-GNU mv", "missing tar", "non-GNU tar", "missing awk", "non-GNU awk"} {++ for _, scenario := range []string{"real tools", "install failure", "missing bash", "legacy bash", "missing stat", "non-GNU chmod", "missing mv", "non-GNU mv", "missing ln", "non-GNU ln", "missing tar", "non-GNU tar", "missing awk", "non-GNU awk"} {t.Run(scenario, func(t *testing.T) {root := t.TempDir()bin, prefix, tarPrefix, runnerTemp := filepath.Join(root, "bin"), filepath.Join(root, "brew with spaces"), filepath.Join(root, "gnu tar with spaces"), filepath.Join(root, "runner temp")@@@ -73,7 -182,7 +182,7 @@@ esaif err := os.WriteFile(filepath.Join(bin, "brew"), []byte(brew), 0700); err != nil {t.Fatal(err)}- tools := []string{"bash", "stat", "chmod", "chown", "mv", "ln", "tar"}- tools := []string{"bash", "stat", "chmod", "chown", "mv", "tar", "awk"}++ tools := []string{"bash", "stat", "chmod", "chown", "mv", "ln", "tar", "awk"}installed := make(map[string]string)for _, name := range tools {leaf, toolPrefix := name, prefix@@@ -156,7 -269,7 +269,7 @@@}entries, err := os.ReadDir(fixtureBin)if err != nil || len(entries) != len(tools) {- t.Fatal("fixture supply must select only Bash/stat/chmod/chown/mv/ln/tar")- t.Fatal("fixture supply must select only Bash/stat/chmod/chown/mv/tar/awk")++ t.Fatal("fixture supply must select only Bash/stat/chmod/chown/mv/ln/tar/awk")}for _, name := range tools {if target, err := os.Readlink(filepath.Join(fixtureBin, name)); err != nil || target != installed[name] {@@@ -170,9 -283,9 +283,9 @@@// only Python's containing suite to avoid recursively starting Go.probe := `#!/bin/shset -eu- test "$*" = 'scripts/installtests/run_unix_contracts.py' || exit 91+ test "$*" = "scripts/installtests/run_unix_contracts.py --phase $EXPECTED_PHASE" || exit 91test "$(command -v bash)" = "$PULSE_INSTALLER_FIXTURE_BIN/bash" || exit 92- for tool in stat chmod chown mv ln tar; do-for tool in stat chmod chown mv tar awk; do++for tool in stat chmod chown mv ln tar awk; dotest "$(command -v "$tool")" = "$PULSE_INSTALLER_FIXTURE_BIN/$tool" || exit 93done# Exercise the actual Linux-only flags with real executables and file bytes.@@@ -186,37 -299,34 +299,50 @@@ cp "$PROBE_ROOT/extracted/source" "$PROmv -T "$PROBE_ROOT/staged" "$PROBE_ROOT/published"cmp "$PROBE_ROOT/source" "$PROBE_ROOT/published"test ! -e "$PROBE_ROOT/staged"+# DSM Upstart removal links its manual override and restores retired config+# with GNU ln -T: a hard link that never replaces or descends into a target.+links="$PROBE_ROOT/links"+rm -rf "$links"+mkdir "$links" "$links/occupied-directory"+ln -T -- "$PROBE_ROOT/published" "$links/linked"+cmp "$PROBE_ROOT/source" "$links/linked"+printf 'concurrent\n' > "$links/occupied"+if ln -T -- "$PROBE_ROOT/published" "$links/occupied" 2>/dev/null; then exit 94; fi+test "$(cat "$links/occupied")" = concurrent+if ln -T -- "$PROBE_ROOT/published" "$links/occupied-directory" 2>/dev/null; then exit 95; fi+test ! -e "$links/occupied-directory/published"+ # Exercise the NAS filter's actual octal byte range, not a --version double.+ # Safe text must pass; NUL and other disallowed controls must fail. Neither+ # false-positive empty matching nor dropping binary bytes is acceptable.+ printf 'safe boot text\n' > "$PROBE_ROOT/boot-safe"+ printf 'unsafe\000boot\n' > "$PROBE_ROOT/boot-nul"+ printf 'unsafe\001boot\n' > "$PROBE_ROOT/boot-control"+ awk 'BEGIN { bad = 0 } /[\000-\010\013-\037\177]/ { bad = 1 } END { exit bad }' "$PROBE_ROOT/boot-safe"+ for file in boot-nul boot-control; do+ if awk 'BEGIN { bad = 0 } /[\000-\010\013-\037\177]/ { bad = 1 } END { exit bad }' "$PROBE_ROOT/$file"; then+ exit 94+ fi+ doneexit "${SUITE_EXIT:-0}"`if err := os.WriteFile(filepath.Join(bin, "python3"), []byte(probe), 0700); err != nil {t.Fatal(err)}- // The supply step itself links with the native ln; only the installer- // step must resolve the supplied GNU ln ahead of a native one.++ // Supply uses native ln, while installer phases must use the verified GNU ln.+ if err := os.WriteFile(filepath.Join(bin, "ln"), []byte("#!/bin/sh\nprintf 'native BSD utility reached\\n' >&2\nexit 64\n"), 0700); err != nil {+ t.Fatal(err)+ }- for _, code := range []string{"0", "23"} {- cmd := exec.CommandContext(ctx, "bash", "-c", installer.Run)- cmd.Env = append(env, "PULSE_INSTALLER_FIXTURE_BIN="+fixtureBin, "PROBE_ROOT="+root, "SUITE_EXIT="+code)- output, err := cmd.CombinedOutput()- if code == "0" && err != nil {- t.Fatalf("fixture-local path did not reach the suite: %v: %s", err, output)- } else if code == "23" {- if exit, ok := err.(*exec.ExitError); !ok || exit.ExitCode() != 23 {- t.Fatalf("containing suite failure hidden: %v: %s", err, output)+ for phase, step := range map[string]nativeGuidanceStep{"preflight": preflight, "remaining": installer} {+ for _, code := range []string{"0", "23"} {+ cmd := exec.CommandContext(ctx, "bash", "-c", step.Run)+ cmd.Env = append(env, "PULSE_INSTALLER_FIXTURE_BIN="+fixtureBin, "PROBE_ROOT="+root, "SUITE_EXIT="+code, "EXPECTED_PHASE="+phase)+ output, err := cmd.CombinedOutput()+ if code == "0" && err != nil {+ t.Fatalf("fixture-local path did not reach the suite: %v: %s", err, output)+ } else if code == "23" {+ if exit, ok := err.(*exec.ExitError); !ok || exit.ExitCode() != 23 {+ t.Fatalf("containing suite failure hidden: %v: %s", err, output)+ }}}}