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.
Patrol Intelligence Contract
Contract Metadata
{
"subsystem_id": "patrol-intelligence",
"lane": "L6",
"contract_file": "docs/release-control/v6/internal/subsystems/patrol-intelligence.md",
"status_file": "docs/release-control/v6/internal/status.json",
"registry_file": "docs/release-control/v6/internal/subsystems/registry.json",
"dependency_subsystem_ids": ["frontend-primitives"]
}
Purpose
Unread investigation history is not absent history
Investigation detail and thread reads distinguish a genuine 404/empty response from an unavailable or denied read. Failed reads show an accessible warning and a read-only Retry, never a false empty state. Re-investigate is withheld while the detail read has failed, including when its last answer is retained: that answer may miss a newer run or queued fix. Retry only reads existing history; it does not start a run or change Patrol's existing refresh intervals.
Previously loaded same-finding/session evidence remains readable after a transient failure, labelled as potentially out of date or incomplete. Source changes do not borrow another finding/session's evidence; HTTP 401/403 still withdraw the query cache and show the existing access guidance without raw error payloads. A successful read clears the warning and restores normal empty/data/action presentation. The registered InvestigationSection and InvestigationMessages suites cover these transitions and retained row identity. This consumer contract requires truthful producer statuses; it does not prove private persistence admission, original installed recovery or release delivery.
Attention selection retains visible evidence in its name (24 October 2026)
Attention list buttons use their visible contents as the accessible name instead of replacing severity, summary, decision state and Last seen evidence with an Open-title label. Resource-leading titles, flapping/handled badges, pressed state and native keyboard/touch selection are preserved. The registered workbench suite checks the full accessible name, including changes to relative time, and existing review/detail/focus behaviour. No provider, action execution, authorisation or attention-state semantics change.
Mobile return controls retain Back to list in their contextual names. The
expanded resource-copy control retains its visible Copy ID name, including
after copying; the fuller explanation remains its tooltip.
One-page Patrol setup on the Patrol page
When Patrol is blocked because no provider is connected, Pulse Intelligence
is off, or the provider refused the saved key (provider_auth),
PatrolIntelligenceWorkspace.tsx shows PatrolSetupPanel.tsx inside the
setup card instead of a link to Provider & Models. The panel covers the two
routes most paid installs use: a cloud API key (Anthropic, OpenAI, Gemini,
DeepSeek, OpenRouter) or Ollama. It names the model Pulse will use from the
Patrol model guidance table and prices it with the cost preview before
anything is saved, at the schedule it will save: a per-token model on the
untouched 6-hour default gets the same slower schedule picking it on Patrol
settings proposes. Connect writes the key or Ollama URL with enabled: true,
runs the provider test that Provider & Models runs (the model list hides a
refused key behind an empty list; only a provider_* cause stops setup,
because the test probes the provider's default model and a model-level cause
is what setup is about to replace), picks the guided model from the
provider's own list (best guidance level, undated alias first, never a
caution model), saves it as the Patrol model (and as the shared model only
when there is none), then runs the Patrol model check and shows its verdict.
Ready means the check verified a Patrol mode; the panel then offers Run Patrol now, which re-reads Patrol state before the run gate. Once started,
the panel stays mounted until the operator finishes, because polling flips
the readiness cause mid-setup. The saved key is cleared from the page after
connect. Subscription CLIs, custom endpoints, other providers and model
overrides stay on Provider & Models, linked from the panel. provider_auth
also routes the setup action to Provider & Models instead of the model check.
patrolSetupModel.ts holds the pure decisions. Proofs:
frontend-modern/src/features/patrol/__tests__/patrolSetupModel.test.ts,
frontend-modern/src/features/patrol/__tests__/PatrolSetupPanel.render.test.tsx,
frontend-modern/src/features/patrol/__tests__/patrolControlPresentation.test.ts
and frontend-modern/src/utils/__tests__/patrolRuntimeActions.test.ts.
The workspace loads PatrolSetupPanel.tsx lazily, passing the readiness
provider as readinessProvider, so the panel's AI settings, provider and cost
code stays out of the AIIntelligence chunk and its bundle budget.
An unreachable provider (provider_connection: wrong URL, server down,
network) also routes the setup action to Provider & Models, with the subtitle
PATROL_WORKSPACE_UNREACHABLE_DESCRIPTION and no model-check hint, but it does
not open the setup panel: a passing network blip must not ask a cloud user to
re-enter a key that works.
Pro default notice and the not-running header
A Pro install that never chose a Patrol mode runs Ask first.
PatrolIntelligenceHeader.tsx says so once, in
patrol-default-mode-notice: Patrol investigates new warning and critical
findings, proposes a fix, changes nothing without approval, and spends the
operator's AI provider budget. Its two actions save Ask first or Watch only,
and either save clears the notice. The notice renders only when
default_mode_applied is true and the install is not plan-locked, so the free
Patrol surface stays free of paid-capability copy. When Patrol is enabled but
cannot run yet (the setup-only state), the header reads Patrol is not running yet instead of Watching your infrastructure, so the header no longer claims
monitoring that is not happening. usePatrolIntelligenceState.ts accepts only an
explicit default_mode_applied: true, so an older server never shows the notice.
Proofs:
frontend-modern/src/features/patrol/__tests__/PatrolIntelligenceHeader.render.test.tsx
and frontend-modern/src/features/patrol/__tests__/usePatrolIntelligenceState.test.ts.
Manual suppression reversal — issue #2528
Patrol Activity exposes the existing suppression collection independently of active findings. It lists only explicitly manual rules with resource and category scope, exact ID and reason; wildcard scopes are labelled both in the list and confirmation. Create-rule controls link to this existing Activity section. Finding dismissals, automatic/legacy rules and history are not removed or reopened by manual deletion. Reopen finding remains a separate action.
A confirmation is bound to its organisation, invalidates on organisation or membership change/disposal, verifies the unchanged manual row with a fresh authorised read, sends one exact-ID DELETE and requires readback absence before claiming removal. Any failed or uncertain step hides stale controls and requires explicit reload, not an automatic mutation retry. Other rules can still cover the same scope. Component/API tests cover cancellation, stale scope/origin, authorisation loss, malformed data, concurrent removal, late results and readback failure. Browser evidence must cover creation through removal and the actual existing links on desktop and narrow viewports. Synthetic proof is not publication or the reporter's own removal.
Long rule reasons remain scrollable without hiding the confirmation heading or Cancel/Remove controls. Resource/category and exact rule ID precede the reason, so confirmation can be reviewed on narrow displays without clipping safety information.
Canonical Patrol and Assistant continuation, 2026-09-07
Canonical action state and legacy approval state remain distinct in Assistant handoff. Unknown destructive risk stays unknown. A plan does not synthesize an old command-shaped fix. The linked investigation retains accepted action identity and original diagnostic uncertainty even if a later provider turn fails.
The current storage-capacity run identifies the actual exhausted tmpfs, while the
earlier host-capacity misdiagnosis remains a failed historical result. Approved
and rejected Docker and Proxmox VM cases have independent named observations.
The current local qualification and exact limits supersede earlier pending-work
notes below only for those named cases. See
docs/qualification/PATROL_ASSISTANT_CUSTOMER_JOURNEY.md. Wider volunteered
customer environments, backup recovery and unattended autonomy remain unqualified.
Action reconciliation refreshes the durable product investigation record from the authoritative session/action even when the finding outcome already matches. The same builder owns initial completion and later refresh. Original prose, evidence and retained rollback survive. Unchanged hydration is a no-op, and a record-only repair does not repeat outcome notifications. Resolved findings retain the canonical action-history link and resolved status in Assistant context. Live approved and rejected recovery cases pass, but storage's lexical scorecard pass fails semantic review because an exhausted container tmpfs was incorrectly attributed to host capacity. Storage and broader product qualification stay open.
Pausing the Patrol schedule does not disable investigation history review. The finding review control owns one detail target and regains keyboard focus on close. Investigation conclusions use sanitized Markdown, deduplicate identical stored/fetched text, and retain distinct evidence. Merged tool results render through Assistant's shared expandable evidence component with their explicit success/failure bit. Unknown historical status stays unknown. A broker refusal remains visible separately from the original diagnosis and cannot be presented as an accepted action. An attention/cannot-fix outcome does not establish manual review or identify who resolved a later finding.
Detection retains one model conversation for evidence gathering and finding decisions. Recording one finding does not establish diagnostic sufficiency or remove its evidence tools. Missing assessments and provider failures remain visible limitations alongside accepted records. Assistant continues those same records without promoting persistence into diagnosis or verified recovery.
Own the Patrol intelligence route shell, outcome-first feature surface, local
state orchestration, genuine-decision presentation, verified-work receipts,
findings and approval presentation, run-history rendering, and Patrol-specific
presentation helpers.
The centralized Findings surface loads full history for its All and Resolved
filters, keeps saved operator notes editable and clearable, and offers
Reopen finding only on dismissed findings. Reopening removes the
finding-backed suppression row, refreshes both Patrol and unified finding
sources, and retains the note as operator context.
Canonical Files
frontend-modern/src/features/patrol/PatrolIntelligenceSurface.tsxfrontend-modern/src/features/patrol/patrolAutonomyAvailability.tsfrontend-modern/src/features/patrol/patrolControlPresentation.tsfrontend-modern/src/features/patrol/usePatrolIntelligenceState.tsfrontend-modern/src/features/patrol/PatrolIntelligenceHeader.tsxfrontend-modern/src/features/patrol/PatrolIntelligenceBanners.tsxfrontend-modern/src/features/patrol/PatrolIntelligenceWorkspace.tsxfrontend-modern/src/features/patrol/patrolInvestigationContextModel.tsfrontend-modern/src/pages/AIIntelligence.tsxfrontend-modern/src/stores/aiIntelligence.tsfrontend-modern/src/stores/aiIntelligenceSummaryModel.tsfrontend-modern/src/types/aiIntelligence.tsfrontend-modern/src/components/AI/FindingsPanel.tsxfrontend-modern/src/components/Brand/PulsePatrolLogo.tsxfrontend-modern/src/components/patrol/frontend-modern/src/utils/aiFindingPresentation.tsfrontend-modern/src/utils/approvalRiskPresentation.tsfrontend-modern/src/utils/approvalState.tsfrontend-modern/src/utils/aiPatrolSchedulePresentation.tsfrontend-modern/src/utils/findingAlertIdentity.tsfrontend-modern/src/utils/remediationPresentation.tsfrontend-modern/src/utils/patrolEmptyStatePresentation.tsfrontend-modern/src/utils/patrolFormat.tsfrontend-modern/src/utils/patrolPagePresentation.tsfrontend-modern/src/utils/patrolRunPresentation.tsfrontend-modern/src/utils/patrolSummaryPresentation.tsfrontend-modern/src/utils/patrolRuntimePresentation.tsfrontend-modern/src/utils/patrolRuntimeActions.tsfrontend-modern/src/utils/textPresentation.tstests/integration/tests/78-monitor-first-patrol-workbench.spec.tsfrontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsxfrontend-modern/src/stores/patrolAttention.tstests/integration/tests/91-operational-trust-attention-workbench.spec.tsfrontend-modern/src/api/patrolAttention.tsfrontend-modern/src/features/patrol/PatrolObjectivesPanel.tsxfrontend-modern/src/features/patrol/patrolHomePresentation.tsfrontend-modern/src/features/patrol/PatrolRecentWorkPanel.tsxfrontend-modern/src/features/patrol/PatrolWeeklyDigestCard.tsxfrontend-modern/src/features/patrol/PatrolSetupPanel.tsxfrontend-modern/src/features/patrol/patrolSetupModel.ts
Shared Boundaries
frontend-modern/src/api/patrolAttention.tsshared withapi-contracts: the Patrol attention client is both the Patrol read-model transport and a canonical typed API boundary.
Extension Points
Quiet operator home
The first-party Patrol page is an outcome and exception surface, not a mirror of
the internal lifecycle. After the effective background posture it exposes three
mutually exclusive operator modes: Inbox, Protection, and Activity.
Inbox is the default and mounts only genuine operator decisions;
Protection owns retained objectives; Activity owns verified receipts plus
the subordinate action-audit and finding/run-record handoffs. Active decisions,
objective configuration, receipts, and operational records must not all render
at once. Investigation internals, lifecycle filters, raw findings, checks, and
run history remain deliberately available without competing with the daily
decision queue. The mode selector is keyboard navigable and retains the stable
Patrol route rather than inventing API filters or lifecycle states.
patrolHomePresentation.ts owns the deterministic projection from effective
autonomy and typed attention evidence into needs user versus can continue
work. Watch-only and ask-first modes keep current active issues operator-visible.
Safe-auto-fix and Autopilot may keep an issue quiet only when evidence is fresh
and complete and at least one eligible governed action can proceed without a
new approval. Unknown or stale evidence, failed or unknown verification,
ineligible or absent actions, policy denial, and outstanding approval remain
interruptions. This is presentation of existing authority, never a new grant of
authority or a bypass around planning, feasibility, approval, dispatch, and
verification.
The Recently handled surface is proof-constrained. It may render a receipt
only from the server-filtered verified-work endpoint backed by canonical action
audits. That projection covers both autonomous patrol actions and governed
operational_trust_attention actions, applies origin plus confirmed
postcondition filtering before its display limit, and orders by verification
time newest first. The browser never reconstructs receipts from a paginated
resolved-attention or settled-action list. Pending, failed, contradicted,
inconclusive, rejected, unknown, unavailable, and unrelated-origin work must
never be styled as handled work. Objective summary language similarly counts
protection only from active objectives whose server-authored coverage state is
covered.
Compact receipts present only the verified action, verification trust class,
time, and shared resource identity. Raw executor and readback summaries remain
available in Actions history; they must not be copied into the quiet Patrol
home or force an operator to interpret transport and lifecycle telemetry.
The effective autonomy label and plain-language consequence stay visible, but the four-level selector is a secondary disclosure. A plan-locked daily operator surface shows the effective watch-only experience without advertising paid modes or Plans & Billing; a wrong-runtime capability block may still expose its direct runtime repair action. Mobile must reach protected outcomes and genuine decisions without first traversing configuration or commercial chrome.
Model-authored operational objectives
Patrol's long-term operator contract is a retained operations brief, not a catalog of application-specific automations and not repeated model polling. An operator may describe an outcome such as keeping media playback free of buffering or keeping camera streams available. Pulse must not hard-code every application, API, log format, event source, or remedy implied by those examples. The model owns investigating the environment and designing the smallest useful observer from the tools and evidence actually available there.
The brief is deliberately value- and outcome-oriented. The operator should not need to prescribe metrics, polling intervals, implementation steps, or a guessed root cause. The model derives a measurable interpretation and observer plan from the brief and current environment, exposes that translation for correction, and may revise the implementation as evidence changes while preserving the brief's intent. More implementation detail is accepted as optional context, not treated as a script that displaces model reasoning.
Pulse's durable advantage in this loop is operational context and trusted reach, not a competing hard-coded intelligence layer. The canonical resource graph, live metrics, history, relationships, changes, findings, operator intent, local observers, governed capabilities, outcome evidence, and prior attempts form one compact estate state that an improving model can use immediately. A Patrol feature should therefore improve context, continuity, access, or trust; logic whose only value is reproducing reasoning the model can perform from that state should not become a permanent product subsystem.
MCP may be the model-facing transport for this compact estate state and its governed tools, including stateless request/response implementations, but it is an adapter rather than Patrol's control plane. Protocol statelessness must not erase product continuity: Pulse owns and persists the objective, canonical resource graph, observer artifacts and health, evidence history, permissions, action lifecycle, verification, and audit record. Each model request can be self-contained while resolving those durable records through canonical Pulse contracts. No Patrol workflow may depend on an MCP session as its memory, scheduler, event queue, or source of authorization, and the underlying contracts must remain usable by first-party UI, API, CLI, and future model transports.
The corresponding execution boundary is a constrained monitor-building tool, not arbitrary mutation authority. The model may propose a versioned local observer bundle: event, webhook, log, file, socket, API, or bounded-interval triggers; a probe artifact and digest; declared network, filesystem, secret, runtime, and resource requirements; health and failure outputs; resource budgets; and the evidence that should wake Patrol. Core validates, tests, sandboxes, installs, updates, disables, and audits that bundle. An observer is read-only by construction and cannot acquire infrastructure-action authority; any response to its findings still goes through the canonical capability, autonomy, approval, dispatch, and verification kernel.
After installation, the cheap local observer runs continuously or on events and the model wakes only for objective creation, observer redesign, an evidence transition, or a finding that needs reasoning. A timer may be one generated trigger when no event source exists, but it runs the local probe rather than calling a model on every interval. Objective status must distinguish covered, degraded, and uncovered monitoring so Patrol never claims protection merely because an instruction was saved. Generated observers are durable artifacts with bounded provenance and rollback; app-named integration code is an optimization only when repeated evidence justifies productizing it, never a prerequisite for a new objective.
The canonical retained-intent, proposal, and first local execution slices are implemented by
internal/ai/patrol_objectives.go, internal/ai/patrol_observer_builder.go,
internal/ai/patrol_observer_runtime.go, internal/ai/tools/tools_patrol.go, and
internal/api/patrol_objectives.go.
They provide encrypted retained intent, optimistic revisions, resource scoping,
model seed projection, the core-owned observer state machine, and the
Patrol-detection-only patrol_propose_observer builder. The model supplies a
bounded canonical-JSON probe proposal, measurable interpretation, direct or
proxy evidence fit, wake evidence, declared requirements, and one trigger
kind; core supplies identity, version,
read-only posture, digest, encrypted persistence, and the proposed state. The
artifact is excluded from public objective reads and later prompt seeds. The
public API cannot attach an observer or author coverage, and the model-facing
tool cannot validate, install, execute, lease, or advance its proposal.
Core validates and installs four generic declarative ABIs. pulse-resource-state/v1
compares canonical resource status; pulse-resource-metric/v1 compares fresh
canonical CPU, memory, disk, or temperature telemetry; and
pulse-availability-state/v1 consumes an existing enabled canonical target.
pulse-http-json/v1 performs a bounded GET and typed JSON-pointer assertion
against an exact in-scope discovery's core-owned Suggested Web URL. The model
may supply only the relative path, selector, predicate, bounded timing, and an
optional encrypted-discovery secret reference; it cannot supply an origin,
credential value, request body, redirect authority, or executable code. Core
includes only the names of credential references from scoped discovery records
in objective-planning model context; encrypted values never enter the prompt.
Core limits concurrency, timeout and response size, blocks metadata/link-local
targets and cross-origin redirects, and fails closed when discovery, scope,
freshness, telemetry, secret reference, or response evidence is missing.
All ABIs use a 10-to-300-second local interval, an empty external-requirements
object, strict unknown-field rejection, and a bounded consecutive-failure
window. Estate-wide objectives bind to the current canonical unified-resource
set at evaluation time. The installer is sandboxed by construction: it
registers typed data, not a process or script. Its runtime persists a
renewable health lease without incrementing the operator objective revision,
batches every due lease in a sweep into one encrypted persistence transaction,
and queues one scoped objective_evidence Patrol check on the transition into
failure rather than repeatedly polling a model. Observer health and observed
outcome remain separate: a healthy observer may report that its objective is
currently breached. Editing the retained brief, optional context, or resource
scope disables the existing observer and clears its lease, because an artifact
validated against old intent cannot remain proof of coverage for new intent.
Observer health and semantic fit are also separate. direct means the predicate
itself measures the full retained outcome; proxy means the signal is useful
for waking Patrol but only correlates with that outcome. Core installs and
leases either safe local signal, but a healthy proxy remains
uncovered/observer_proxy instead of becoming a false protection claim. Missing
fit on older stored observers defaults conservatively to proxy. This lets the
model exploit cheap reachability or resource-state signals without pretending
they prove richer outcomes such as smooth playback or successful recording.
Creating or materially updating an active objective queues an immediate,
objective-identity-deduplicated coverage-planning Patrol run. The first-party
PatrolObjectivesPanel exposes one outcome statement, optional context and
optional resource scope, then shows the server-owned covered, degraded, or
uncovered truth with pause, resume, edit, and delete controls. Saving text is
never presented as equivalent to active protection. A healthy proxy uses the
plain-language Useful signal only badge and the server explanation that the
full objective is not directly measured; it must not render as Watching in background or count toward protected outcomes.
Unsupported trigger or probe designs transition to rejected with an explicit
machine validation reason and uncovered coverage. A rejected or degraded
version may be replaced by a new model proposal, while core may reconsider an
unchanged rejected artifact after a runtime upgrade. Richer event, webhook, log,
file, socket, API, network, filesystem, secret-backed, and non-status signal
runtimes remain extensions of the same lifecycle. They must add a constrained
capability and validator rather than executing proposal JSON generically; until
such a runtime records a healthy installed observer, the saved objective
truthfully remains uncovered.
Desktop Autopilot activation consumes the server-owned acknowledgement
contract through frontend-modern/src/api/patrol.ts and
PatrolAutopilotAcknowledgementDialog.tsx. The UI displays requested versus
effective mode, records the current acknowledgement version before full-mode
activation, exposes revocation, and treats expiry, revocation, version drift,
and activation races as server-authored demotion. Proof is
PatrolAutopilotAcknowledgementDialog.test.tsx,
usePatrolIntelligenceState.test.ts, and desktop journey 82. This statement
does not certify mobile or physical-device behavior.
Open work descriptions are Patrol-owned operator guidance. They may mention the
visible next step, approvals, and verification results when those words help the
operator understand what to do next, but they must not become a separate proof
strip, backend accounting summary, or generic all-mode capability sentence.
Shell-level Patrol open-work counts are also Patrol-owned read-model
projections. They may de-duplicate active Patrol findings and live Patrol
approval targets so the stable Patrol tab shows that work exists, but they
must not become a second queue model, a renamed Needs Attention destination,
or historical proof/counting for resolved-only work.
- Add or change Patrol page orchestration through
frontend-modern/src/features/patrol/usePatrolIntelligenceState.ts, keepfrontend-modern/src/features/patrol/patrolInvestigationContextModel.tsas the canonical investigation-context derivation owner, keepfrontend-modern/src/features/patrol/PatrolIntelligenceSurface.tsxas the feature shell, keep the Patrol-owned section files underfrontend-modern/src/features/patrol/as the heavy render owners, keepfrontend-modern/src/pages/AIIntelligence.tsxas the route shell, keepfrontend-modern/src/stores/aiIntelligenceSummaryModel.tsas the canonical AI summary normalization owner, and updatefrontend-modern/src/stores/aiIntelligence.tstogether The default Patrol workspace is the current-issues list. It must not add a second proof strip that restates the same finding, approval, or setup problem above the list. When active Patrol findings are the next operator step, the finding row owns the canonical primary action, contextual Assistant handoffs, approvals, verification, and manual controls. A compact row must expose only what the operator needs to prioritise the queue: severity, current workflow state, title, affected resource, recency, and one bounded consequence summary. Checked evidence, recommendation, approval controls, verification state, history, and manual controls belong to the single selected issue review beside the queue; the collapsed list must not render those fields as an always-open checklist. Findings may be grouped only from API-owned identity facts: the same canonical resource, a shared parent node, or explicit correlated finding IDs. Grouping must not infer causality from title or description prose, and the queue's affected resource count must continue to count canonical resources rather than visual groups. A contextual Assistant handoff from that workflow opens throughfrontend-modern/src/components/AI/FindingsPanel.tsxand records no workflow starter today, so the first-partypulse_patrolmarker has no browser producer. If that handoff starts recording one, it must write content-free workflow prompt activity through the shared marker route with thepulse_patrolsurface before the drawer opens, with no finding IDs, prompt text, resource context, model output, or direct-action payloads in that marker. A compact Patrol work-group row may appear above the list only when it adds cross-source current-work grouping that the row title alone cannot express: pending approvals, failed governed actions, a failed/latest Patrol check, recurring active issues, or overdue scheduled protection. It must be data-only presentation from Patrol status, run history, approval state, and current finding composition; it must not become a status strip, trust strip, health summary, generic proof counter, or replacement for the issue row's action, evidence, approval, verification, and Assistant handoff controls. A calm Patrol queue must stay plain: the Open work description and the current-findings empty state may say that there are no current issues and may point to History for past outcomes, but the workspace must not render a calm-day protection-posture, verification-waiting, schedule-freshness, drift, trust, or proof strip just to restate that no current work exists. A calm-looking queue is not an all-clear when its checking evidence is stale.patrolControlPresentation.tsowns freshness derivation from the latest completed check, the server-authored Patrol interval, and the next scheduled check. Alongside current work, stale coverage may appear as the existing compact cross-source work-group row. On a calm queue, the current-findings empty state alone must become warning-toned so the same stale condition is not repeated; neither case may add a second protection, schedule, or proof strip. Monitor-context coverage posture is a separate presentation boundary, but it must not render as a generic proof strip on Proxmox overview or other monitor-first launch pages. A future monitor-specific Patrol affordance must be scoped to an operator action or selected Patrol context, point active work back to Patrol, omit drift/trust proof counters, and must not introduce a Patrol-page protection-posture list as a launch-page strip or generic Home summary. Runtime/setup findings are still active Patrol work, but setup-only runtime failures must read as one setup task rather than an infrastructure issue queue. The header may suppress its run control andSettingslink while setup is the only active work, but it must keep the Patrol mode selector available because the operator's autonomy boundary remains a primary product choice even before Patrol can run. The workspace must replace the generic findings row with a dedicated provider/runtime setup task, one current issue label, and the direct provider-settings action. It must not show runtime severity chips, loop-state chips, recurrence badges, expand chevrons, or finding filters in this state because those controls do not help the operator fix Patrol setup. The operational attention Inbox is independent of Patrol model readiness and its on/off switch. Keep that attention workbench available below the focused setup task when Patrol is off or its model needs setup; do not discard the setup task, turn a runtime finding into an infrastructure decision, or enable disabled Patrol controls merely to expose the independent queue. The Patrol page must not expose a generic Details/supporting-context evidence panel for nearby activity, learned correlations, or policy buckets. Those payloads may still feed Assistant context, backend investigation, and explicit run or finding records, but the default first-party Patrol page stays on the issue, consequence, and next action. Initial Patrol data refresh failures are degraded data state, not a route failure:usePatrolIntelligenceState.tsmust fail soft, keep the Patrol workspace visible, and letPatrolIntelligenceBanners.tsxshow one short stale-data retry banner without leaking raw transport errors. Watch-only and locked-control copy must describe Patrol as checking infrastructure and showing current issues, while the selected Watch only mode must describe the capability positively, such as Patrol checking infrastructure and reporting issues only. It must not frame the free/monitor boundary as evidence recording, proof collection, or a disabled version of remediation. Paid mode labels must stay short operator choices (Ask first,Safe auto-fix,Autopilot) and must not reintroduce Pro-matrix labels such asAsk before changes,Auto-fix safe issues, orPolicy autopilot. Plan-locked Patrol controls must keep the working surface on the positive Watch-only capability and must not surface paid modes, disabled paid-mode buttons, compact Pro badges, a paid-mode matrix, or any paid-mode disclosure. The free Patrol surface stays a complete, clean monitoring tool with no mention of paid Patrol capabilities; Pro discovery belongs in Settings, the website/docs, and contextual at-need prompts, not in the daily-use Patrol control surface. The single allowed contextual at-need prompt is the finding-level Pulse Pro investigation handoff: it may appear only in the expanded finding primary-action area, only for plan-locked installs, only on active critical or warning findings, only as one non-salesy capability line, with the upgrade action gated by the upgrade-prompt policy, and never as an ambient matrix, badge, or paid-mode disclosure. The selected mode must remain Watch only and the copy must not become a feature-matrix or absence explainer. Paid Patrol control handoffs that start or continue the same journey must reach Patrol through the route-backed/patrol?patrolControlStarter=patrol_control#patrol-controlaffordance.usePatrolIntelligenceState.tsowns consuming that coarse starter query before the initial Patrol data load, writing the same content-free workflow prompt activity through thepatrol_controlsurface, and then replacing the URL with the clean Patrol control anchor. The legacyoperationsLoopStarter=patrol_autonomyandoperationsLoopStarter=pulse_pro_activationvalues must remain accepted as compatibility aliases that normalize to the current Patrol control marker, and#operations-loopmay exist only as an inbound compatibility anchor. That route flag is only a first-party starter marker; it must not carry finding IDs, prompt arguments, resource context, model output, or completed-work proof. Direct Patrol control selection from the Patrol page is also a first-party starter for that paid Patrol operator journey. After a successful autonomy settings save,usePatrolIntelligenceState.tsmust record the same content-freepatrol_controlmarker when the effective autonomy level or full-control acknowledgement actually changes and the paid Patrol control feature is available, then refresh Patrol status, findings, approvals, and run history so the next Patrol operator step is visible without waiting for a later poll or page reload. Locked Community/runtime saves and repeated no-op selections must not record paid starter activity. That successful server-side transition out of Watch Only also starts one bounded reconciliation pass over already-active actionable findings, so the next Patrol step can appear without waiting for the issue to be detected again. The backend owns this behavior and retains the normal eligibility and concurrency gates; the browser marker remains entry-point telemetry only and must not become a second investigation trigger. The same journey may count a generic Patrol run or recency timestamp as readiness to start, but it must not advance the current operator state until it has issue-backed Patrol evidence: an active or resolved finding, investigation state, pending approval, governed action, verified fix, or Patrol status trust signal. A healthy no-finding run stays on the Patrol watch state instead of masquerading as Assistant-ready work. The current operator state must consume the canonical/api/agent/operations-loop/statusprojection through the shared agent-capabilities frontend client when that status is available; page-local Patrol counts may remain only as resilience fallback and UI affordance state for whether Patrol can run or which single finding can be opened. Patrol page components must not maintain a second progress state machine once the backend projection has loaded. The loaded and fallback current-work models must keep approved and rejected governed-action decisions distinct: approved decisions continue to the verified-outcome step, while a rejected only decision is a terminal no-execution outcome and must not strand the operator on a verification step that cannot run. The same model must treat active findings and pending approvals as current operator work. Older completed or resolved Patrol control proof carried by primarypatrolControl*fields may tailor history copy, but it must not make the primary action, title, or step status say the work is done while an active finding or approval remains. Current active findings must route the primary current-work action to the canonical finding primary action when exactly one active finding exposes one, or back into the Patrol findings workflow first when no direct action exists, even when the backend projection still saysopen_assistant; Assistant remains a contextual handoff from the selected finding or approval rather than the primary Patrol investigation CTA. The primary current-work state and compact progress label must describe current work state (ready,needs attention,approval needed,outcome verified,no active work) instead of repeating the selected mode; the Patrol mode selector/header owns current-mode copy, and any local Patrol work evidence must be Patrol-owned issue/work counts rather than legacy proof counts. No Patrol surface reads issue-evidence, governed-action decision, or verified-outcome counts today, sousePatrolIntelligenceState.tscomputes none of them. When no active finding or pending approval remains, terminal verified or rejected outcomes must read as history behind ano active workcurrent state; current-state copy must not ask operators to reconcile old approved work with the current autonomy boundary. Historical verified outcomes with no current operator action must not render a separate proof strip solely to link to history; the Patrol workspace owns the deliberate history review affordance. Resolved-only issue history and trust counters are not current operator work: they may support history or analytics copy, but they must not make the primary Patrol status say Patrol found a current issue when the active finding and pending-approval counts are zero. Compact Patrol summaries must label recurrence/trust counters as past evidence rather than placing bareregressedcopy beside current healthy or active-finding state, and health scores must be named as ahealth scoreinstead of rendering as unexplained95/100telemetry. The Patrol workspace must default to current operator work: current findings, active investigations, approval decisions, and selected finding snapshots. The Inbox, Protection and Activity workspace views are routes (/patrol,/patrol/protection,/patrol/activity) owned byfrontend-modern/src/features/patrol/patrolWorkspaceRouting.ts, so a link or bookmark opens the view it was copied from, any other path opens the Inbox, and the finding handoff from the Inbox navigates to Activity and scrolls to the findings once Activity has mounted. View switches never scroll the page. The Inboxattentionquery is read from the real address when leaving the Inbox and restored on return, because the attention workbench writes it straight to history and the router's copy can be stale. The route and page title must lead withPatrol, because operators understand Patrol as the recurring checking loop. The default workspace title underneath it may useOpen workso the page can explain current findings and approvals without renaming the destination. Patrol remains the watch/investigate/act/verify engine. The exception is a setup-only Patrol runtime failure: that state must use theFix Patrol setuptitle and setup description while rendering a dedicated setup task instead of the generic finding row. When the list is empty, Patrol-owned empty-state copy must say there are no current issues and may reference past regressions only as history, not as current work. Run history is evidence and audit trail, not a peer top-level mode; expose it through an explicit history review affordance, keep the ledger visually bounded, and return the user to the findings snapshot when a historical run is selected. Broad supporting context such as recent changes, correlations, and policy coverage stays off the Patrol page under the supporting-context rule above, even when a finding is active or a history snapshot is selected; the page has noDetailscontext affordance for it. Degraded health or historical recurrence alone must not surface a page-level forensic context block either. The default Patrol surface must stay simple: the header, control selector, and Open work workspace own the ordinary operator state. Patrol must not render a separate always-visible status/activity/health strip just to prove the loop exists. Actionable runtime, setup, or coverage failures may still surface as concise warnings, and detailed status/trust/history evidence belongs behind the queue, history, or explicit context affordances. Manual page data sync is a secondary read-model affordance, not a Patrol operation. The Patrol header may expose it only as explicit page data sync for status, queue, approvals, and run history; it must not read as another Patrol run, must not be labeledRefresh Patrol, and must not use an endlessly animated spinner that competes with the actual Run Patrol action. The Patrol page must still remain understandable when the broader intelligence summary is missing or slow: keep the page title, selected Patrol mode, and Open work label visible instead of reintroducing a generic status strip. Plan-locked Patrol mode copy must present the effective Watch only capability as the current product state: Patrol checks resources, detects issues, and records findings. The free Patrol working surface must not render a disabled paid-mode matrix, compact Pro badges, or any paid-mode disclosure; it stays clean of paid-feature surfacing entirely. Runtime-locked Pro installs may still show explicit blocking copy because the operator already has the entitlement and needs the correct runtime. User-facing copy names this choicePatrol mode; stable route markers, telemetry fields, and API wire names may retainpatrol_control,patrolControl*, and older autonomy aliases for compatibility. Patrol mode must default to a simple user choice when paid control is available: show the current mode, one short sentence, and the four available modes. The control-specific policy contract, hard limits, and who-approves-what details are useful, but they must sit behind an explicit details/limits affordance rather than appearing as a default matrix on every page load. Paid-control availability copy must frame that decision as choosing what Patrol may handle automatically. It must not describe the user's choice as deciding how far Patrol can go or how much control Patrol has, because those phrases imply raw authority rather than governed scope. The Patrol page header is part of that same boundary: when the install is plan-locked to Watch only, the header description must present the current install capability rather than a disabled Pro matrix. When a Pro operator selectsWatch only, the header must describe that selected mode as a no-change boundary, not as the whole Patrol product promise. Governed paid modes may use mode-specific watch/investigate/act/verify/record copy that matches the selected mode. ManualRun Patrolstate must distinguish the start request from follow-up status refresh:Startingis only the short-lived request-to-start phase, while accepted or streaming runs move into the run-in-progress state and must not stay blocked behind slower dashboard/status reloads. Operations-loop starter counts from that backend projection are evidence that the Assistant, Patrol mode/autonomy compatibility entry point, legacy Pro activation entry point, or Pulse MCP entry point was used. A first-party Patrol control starter may help telemetry and entry-point routing, but it must not render a separate ready-to-run proof strip. The visible ready state belongs to the header control andRun Patrolaction; it must not read as configuration proof such asPatrol mode ready. Legacy Pro activation starter aliases must stay compatibility evidence and must not render that ready-to-run strip by themselves. The Assistant step count from that projection is different: it is contextual collaboration evidence from Assistant context/tool usage or external-agent activity, and it should take precedence over starter counts when shown. Patrol must not use starter evidence to bypass the issue-evidence, governed-decision, or verification stages. The same first-party journey must not treat external-agent readiness as the operator's primary success condition. Pulse MCP contract availability still comes from the shared agent-capabilities manifest exposing the operations-loop workflow prompt and the required governed tools through the Pulse MCP surface contract, and loaded readiness still comes from the backend operations-loop status field after the server has checked for a non-expired API token covering at least one Pulse MCP-published capability scope. Patrol may use those facts for telemetry, settings handoff, and external-agent readiness, but the default Patrol page loop is governed operations: watch, investigate, act under policy, verify, and record. The first-party Patrol workflow state must not load manifest-backed MCP readiness or require MCP readiness props; Pulse Intelligence settings and external-agent surfaces own MCP setup/readiness, while API security owns only the scoped-token creation surface they link to. Patrol mode labels and details must match the backend execution policy: assisted mode may say it can run low-risk fixes explicitly allowed by policy, but it must not imply that warning severity alone makes a command safe; high-risk, critical, destructive, or unknown-risk fixes remain approval-bound unless the operator has selected a broader autonomy level. Compact Patrol mode labels must remain understandable mode decisions (Watch only,Ask first,Safe auto-fix,Autopilot), not shorthand such asAskorSafethat makes the operator infer what Patrol will do. The current-work and findings-workspace descriptions must derive from the active Patrol mode and lock state, not from a generic all-capability sentence. Watch-only installs must not advertise investigation, approvals, or fixes in the default findings copy. The default workspace description should tell the operator what Patrol-found problems will appear there and what Patrol may do under the selected mode, including whether the next row-level step is evidence review, approval, automatic action review, or verification result review; it must not describe internal queue mechanics, activation proof, or verification accounting. - Add or change Patrol findings, approvals, investigation, status-bar, or run-history presentation through
frontend-modern/src/components/AI/FindingsPanel.tsxandfrontend-modern/src/components/patrol/Patrol owns run-history labels, counts, status variants, and domain copy, but visible run-history, status-bar, and runtime-summary state badges must compose the sharedStatusIndicatorBadge, and resource/outcome/snapshot/scoped-run/status-bar/workspace-tab metadata chips must compose the sharedMetadataBadge. Patrol and AI finding loading indicators must compose the sharedLoadingSpinnerfor border-based spinner shell, size, tone, and accessibility behavior; icon-specific refresh rotation remains local icon state. Patrol run-history empty states own Patrol-specific copy through the Patrol presentation helper, but compact empty-state spacing, icon treatment, and text hierarchy must compose the frontend-primitives-ownedEmptyStatevariant="panel"instead of page-local centered icon/text shells. If Patrol needs a new badge shape, tone, loading indicator variant, or empty-state shell variant, extend the shared primitive and registry guard instead of adding page-local rounded pill spans, spinner spans, or empty-state wrappers.RunHistoryPanelis body content inside the Patrol workspace heading. It may show the selection hint and selected-run reset action, but it must not render a secondHistoryheading under the workspace'sPatrol historyheading. Current-findings empty states must reserve warning or error tones for active runtime/coverage/run problems; historical regressions without active findings remain informational history-review context, not an active-warning empty state. The default current-findings empty state must stay action-led and plain: use a verifiedNo current issuesstate only when Patrol evidence supports it, useRun Patrol to check everythingwhen coverage is incomplete, and do not reintroduceNothing needs attentionor all-clear phrasing for a view that is not fully verified. Degraded or incomplete checks should say Patrol could not finish a clean check and ask the operator to run Patrol to refresh current issues, rather than exposing verification/proof terminology. Visible Patrol summaries, runtime text, and run-history labels should use operator vocabulary such asPatrol check,Targeted check,Follow-up check,Last check, current issues, and outcomes. Backend fields may retain full-run, scoped-run, verification, and compatibility terminology where needed for cadence, audit, or API stability, but the default page must not ask ordinary operators to learn those internal proof distinctions before they can decide what to do next. A manual scoped Patrol request — such as an alert's "Have Patrol investigate" action — is one of those Targeted checks, not a new run kind: it must reuse the same scoped engine, run record, and run-history vocabulary as automatic alert-triggered work (governed by theai-runtimemanual Patrol route contract), so the operator still sees aTargeted checkrather than a route-specific label. That request uses synchronous admission rather than the background trigger queue. Success carries a named run; if Patrol is busy the caller receives an explicit already-running conflict and may retry, so a Targeted check can never display accepted while its work was actually dropped. Active Patrol finding expansion must stay action-led: description, impact, recurrence summary, primary action, Assistant handoff, approval, and manual controls are acceptable default content, but raw lifecycle telemetry belongs to explicit all/resolved/history/run-review contexts instead of the default current-issues expansion. Current active Patrol issue rows must also surface the canonical primary next action, when one exists, without requiring the operator to expand details first. The collapsed issue row is not a Patrol process log: it may show severity, resource, recency, recurrence, and actionable states such as approval required, investigation running, verification needed, failed fix, or setup attention, but it must not expose genericdetected,review finding, raw loop-state, investigation-status, investigation-outcome, or confidence badges on the default Patrol page. Patrol may hand off to governed operations that originated there. Its compact Actions handoff opens the canonical action ledger without copying ledger rows or action controls into Patrol. The ledger is also an auditable first-class workspace for operations originating in Patrol, Assistant, MCP, or manual controls./actionsdeep links stay stable and select Actions in shared navigation. Patrol approval and remediation actions own approval, denial, reapproval, review, and Assistant handoff semantics, but their visible action chrome must compose the sharedButtonprimitive for success, warning-solid, primary, secondary, ghost, disabled, focus, and compact action behavior instead of page-local button shells. - Keep remediation execution badge copy and severity styling aligned through
frontend-modern/src/components/patrol/RemediationStatus.tsxandfrontend-modern/src/utils/remediationPresentation.ts - Add or change Patrol header, status runtime-state presentation, or runtime provider action presentation through
frontend-modern/src/features/patrol/PatrolIntelligenceHeader.tsx,frontend-modern/src/features/patrol/PatrolIntelligenceBanners.tsx,frontend-modern/src/components/patrol/RunHistoryEntry.tsx,frontend-modern/src/utils/patrolRuntimePresentation.ts, andfrontend-modern/src/utils/patrolRuntimeActions.tsThe header's primary run control must not become an unexplained disabledRun Patrolbutton when provider/model readiness blocks manual Patrol. In that state it becomes a directFix setupaction to Provider & Models, while busy, disabled, unavailable, and already-running states can remain button states with their current reason attached. Patrol may show trigger mode and recent activity as compact factual context only inside explicit context/detail surfaces or actionable warnings sourced from Patrol run history andstatus.trigger_status; it must not reintroduce default status cards, suggested actions, or a separate activity tab to explain the same facts. Effective runtime blocks on event-triggered Patrol must pass through the samestatus.trigger_statuspresentation helper, but the default header and activity strip may surface them only when they explain an actionable manual Patrol block; while manual Patrol still works, a background-only trigger pause stays off the header, and no other surface renders it today. Patrol mode selection belongs to the Patrol page header, which has no schedule and model drawer. The Patrol model, schedule, and trigger tuning live on Settings > Pulse Intelligence > Patrol, which the header'sSettingslink opens when setup is not blocking, and save together through that page'sSave Patrol settingsbutton. The same page runs the model readiness check as its ownCheck Patrol modelaction, separate from that save. That settings page must not duplicate the four Patrol mode choices; it points back to the Patrol page for them. The Patrol model field must lead with the current selection orUse shared default; the full model catalog is power-user detail that opens only from the picker, not the default content of the page. When Patrol mode is available, the Patrol mode selector must keep the default view to the selected mode and one short sentence. It must not render a secondaryLimitsdisclosure, hard-limit matrix, or policy explainer on the primary operator surface; detailed policy configuration belongs in Patrol settings and governed action review, not beside the mode picker. That selected-mode sentence belongs inpatrolControlPresentation.ts, not inline header markup, so the paid operator contract stays testable and does not drift into another activation/proof checklist. Plan-locked watch-only installs must keep the working surface clean of paid-feature surfacing — no disabled paid-mode matrix, no Pro badges, and no paid-mode disclosure — because Pro discovery belongs outside the daily-use Patrol surface. Watch-only copy inpatrolPagePresentation.ts,patrolControlPresentation.ts, andpatrolAutonomyAvailability.tsmust describe Watch only in positive, capability-first language: Patrol checks infrastructure, records current issues, or records issues as it finds them. They must not repeat the same sentence across the header and mode control, repeatedly restate infrastructure-unchanged caveats in the default view, or imply Patrol's main value is a manual review chore. Plan-gated Patrol capabilities share that one availability presentation:patrolAutonomyAvailability.tsowns the precedence (hidden commercial surfaces, then runtime lock, then plan lock) and the only action labels (Open Pro downloads,Plans & Billing), while each capability supplies its lock state and copy. Hidden commercial surfaces win over the runtime lock, so demo and white-label sessions never see Pulse Pro runtime wording, and every caller (the Patrol header, the Patrol banners and Patrol settings) passes the session's realpresentationPolicyHidesCommercialSurfaces()andpresentationPolicyHidesUpgradePrompts()values instead of a constant. The Patrol settings Container update risk trigger (ai_alerts) usesgetPatrolAlertAnalysisAvailabilityPresentation, so a locked install sees why the trigger is unavailable beside the disabled switch: a higher license plan, a missing Pulse Pro runtime, or, when commercial surfaces are hidden, a neutral not-available line with no plan or Pro wording. Actions appear only when upgrade prompts are allowed. - Add or change Patrol header schedule and runtime presentation through
frontend-modern/src/features/patrol/PatrolIntelligenceHeader.tsx,frontend-modern/src/utils/aiPatrolSchedulePresentation.ts, andfrontend-modern/src/utils/patrolRuntimePresentation.ts. Patrol must not surface retired hosted-model credit badges or trial-like activation prompts in the normal self-hosted GA app, even when legacy transport fields are still present. - Keep Patrol and chat identifier-label presentation aligned through the shared
frontend-modern/src/utils/textPresentation.ts - Keep Patrol transport and payload changes aligned through the governed AI runtime and API contract transport surfaces
Forbidden Paths
- Reintroducing Patrol finding, investigation, approval, or run-history copy directly inside page components when canonical Patrol presentation helpers already own it
- Duplicating Patrol finding severity, lifecycle, alert-identity, or approval-risk derivation outside the governed Patrol presentation helpers
- Letting the Patrol page, local store, and findings UI drift into separate shadow truths for the same Patrol status or finding lifecycle state
- Recreating Patrol run-history, status-bar, runtime-summary, or workspace-tab status/metadata badge shells locally instead of composing
StatusIndicatorBadgeandMetadataBadge - Recreating border-based Patrol or AI finding loading spinner shells locally instead of composing
LoadingSpinner - Reading finding-review or run-history data with
createResource, or any read that suspends, instead ofcreateNonSuspendingQuery: the nearest Suspense boundary is the app's route boundary, whose fallback replaces the page and loses the reader's place. Rebuilding findings rows or an open review for a refresh that returned the same findings is forbidden for the same reason
Completion Obligations
- Update Patrol page, state, presentation helpers, and proof files together when Patrol UX semantics change
The Patrol route must source its Patrol findings from the direct Patrol
findings transport through the shared intelligence store. Unified findings
may remain available to cross-product AI surfaces, but the Patrol page,
selected-run findings panel, badges, and active-finding summaries must not
infer current Patrol evidence by filtering the unified threshold/AI feed.
The same source boundary owns loading and error state: Patrol findings must
render from
patrolFindings,patrolFindingsLoading, andpatrolFindingsErrorinstead of letting a pending unified findings request mask direct Patrol evidence that has already loaded. Background Patrol refreshes must preserve already-loaded findings instead of replacing the workspace with a blocking loading state. Selected run-history snapshots must render their recorded empty or unavailable finding state immediately; a global Patrol findings refresh may only block the selected run view while the run references finding ids that still need the direct Patrol findings payload. Patrol page refresh state must also separate background data loads from the operator-clicked Retry on the stale-data banner: background polls hold no busy state, and slow or stalled supporting intelligence reads may continue in the background, but they must not make Retry spin or stay disabled once Patrol findings and status remain visible. Retry is a status/history sync affordance; it must not read like another Patrol run or imply that it changes infrastructure. Patrol trigger-status copy in the default header and activity strip must stay actionable. Runtime policy pauses for alert/anomaly-triggered background checks, such as the local development safety guard, may explain a blocked manual run or advanced diagnostics, but must not be presented as ordinary operator guidance when manual Patrol still works. The Patrol page header labels this line asAutomation, notTrigger status, and when a run is already in progress the summary must say new automatic and manual runs are paused until the current run finishes. The Patrol enabled toggle label must remain distinct from run progress; a running Patrol still labels the toggle state asPatrol enabled, while the run button and current-issues list ownRunning/Patrol runningcopy.PatrolIntelligenceHeader.tsxowns thepatrol-controlroute target and theoperations-loopcompatibility anchor used by Patrol mode entry-point handoffs; the page must keep those anchors on the header's Patrol control section, which holds the Patrol on/off toggle and theMode and automationdisclosure with the Patrol mode selector (or, for plan-locked installs, the inlinePatrol modeline), rather than on a separate onboarding banner or generic Patrol container. Arriving on either anchor, with or without the starter query, opens that disclosure and scrolls the selector into view, so the entry points land on a visible Patrol mode selector; a plain/patrolvisit leaves the disclosure collapsed, and a disclosure the operator collapses after arriving stays collapsed until the route hash changes. The Patrol surface must preserve the issue-evidence rule: Patrol mode can start from a generic Patrol run state, but investigation, approval, verification, and external-agent parity require a real finding, investigation, or governed outcome signal. The native Patrol workspace must derive current work from Patrol status, findings, approvals, and run history rather than loading the authenticated operations-loop status projection. That projection may remain available to API, MCP, telemetry, and adjacent commercial surfaces, but it must not create a separate default proof strip or bypass the current-issues workflow. LegacypatrolAutonomy*andproActivation*fields may be consumed only at compatibility edges, not as first-party Patrol workspace state. Current active finding detail must use the current active-finding count for operator copy instead of the aggregate historical issue-evidence count, so a page with one live finding and older verified history reads as current work, not as a pile of old issues. The journey must also consumepatrolControlValueStatefrom that projection when present, falling back topatrolAutonomyValueStateand thenproActivationValueProofStateonly for compatibility. Agoverned_decision_recordedstate is a safe terminal rejection/decision to review, not a verified value outcome, and its primary action must return the operator to decision context rather than the resolved-outcome list. Averifiedstate may be presented as verified Patrol operations value; legacyverified_needs_mcppayloads must be interpreted as already verified first-party Patrol value with MCP readiness left as optional external-agent context. Run history is secondary review context: the default history panel must lead with recent snapshots and keep older runs behind an explicit expansion, while preserving full forensic access for operators who deliberately open it. Individual run entries must read as an operator action record first (All clear,Found N new issues,Fixed N issues,N issues still open, orPatrol needs attention) with checked-resource coverage as supporting detail. Trigger reason, duration, tool-call counts, tokens, triage flags, and raw tool traces are forensic context and must stay secondary to what Patrol did. - Keep Patrol-specific copy and badge logic inside the governed Patrol presentation helpers instead of page-local branches
Patrol renders no assessment copy today. If it returns, it must not present
an all-clear health prediction while active Patrol findings or Patrol
runtime issues are still present, and one shared presenter must own that
conflict resolution so the visible assessment title, description, and
compact metrics all speak from the same current findings state.
Patrol-owned runtime issues must stay
distinct from infrastructure findings in assessment copy rather than being
described as infrastructure warning findings about Patrol itself.
Historical Patrol trust regressions must also suppress a green all-clear in
the current findings empty state:
0 active findingsmeans no current Patrol work, while prior regressions remain Patrol history review context. Stale Patrol coverage must suppress the same green all-clear even when the last completed check found no issues. Freshness uses at least a 24-hour tolerance and otherwise allows two configured Patrol intervals before warning, so deliberately slower schedules are not mislabeled while an old default-schedule result cannot remain green indefinitely. Coverage caveats reconcile against run history before the health summary. Once runtime states (running, blocked, disabled, unavailable) and stale coverage have taken precedence, the current-findings empty state reads the latest completed full Patrol run first (getPatrolRunCoverage). When that run or any run after it ended with errors, or only targeted or follow-up runs have completed, the empty state withholds the all-clear (Check needed). When it ended without errors, checked real resources, finished within the last 24 hours, and no run after it failed, acoveragefactor in the overall-health summary does not withhold the all-clear, and a grade lowered by nothing but coverage factors does not read asPatrol needs review. The backend keeps itsRecent Patrol errorsfactor until three consecutive clean full runs lead its 24-hour coverage window or the erroring runs leave it (summarizeRecentPatrolCoverageininternal/ai/intelligence.go), so without that reconciliation a clean check would keep readingCheck neededuntil up to two more clean full runs followed it, about 12 hours at the default 6-hour interval. The summary's coverage factor still decides whenever run history cannot vouch for current coverage: no completed run, or a clean full run that checked no resources or finished more than 24 hours ago. An assessment readout that returns must apply the same reconciliation. Recency coverage copy comes from the shared presentation helper (getPatrolRecencyPresentation):checked N resourcesfor the latest completed run with a positive count, whatever its type or error state. It never saysverified. - Update this contract whenever a new Patrol-specific page, store, helper, or presentation component becomes canonical runtime surface area
- Keep retired hosted-model and trial-like Patrol acquisition copy out of the
normal self-hosted GA app. Patrol may parse legacy transport fields, but
header badges, runtime banners, empty states, and settings handoffs must
present provider setup as BYOK/local/self-managed rather than promising
managed credits or account-backed AI access.
Server-authored Patrol readiness from the status payload is part of the
Patrol product surface: warnings must be visible before a run starts, and
known not-ready states must keep recoverable provider/model settings saves
visible and actionable while blocking manual, scheduled, and scoped Patrol
runs instead of letting operators discover provider/model/tool
incompatibility through a failed run.
On the Patrol page, that state must render as
Patrol setup issueorPatrol setup warning, with provider/model context and the directOpen Provider & Modelsaction. Raw diagnostic terms such as preflight, tool-call observation, or readiness internals belong in Provider & Models and backend/test contracts, not in the first-party Patrol operator banner. - Keep customer-facing Patrol naming product-first while preserving the
operator-workbench job words inside the page: the daily work destination
leads with
Patrol, while summary copy, actions, empty states, and mode controls may describe findings, approvals, and work that needs attention. ReserveAIterminology for explicit provider/configuration settings, shared runtime internals, or other technical capability boundaries where the underlying ownership really is AI runtime rather than the Patrol product surface. - Keep Patrol brand icon accessibility contextual:
PulsePatrolLogoremains label-bearing when the icon stands alone, but Patrol headings and actions that already include visible Patrol text must render the logo as decorative so accessible names do not repeat asPulse Patrol Patrolor similar duplicated names. - Keep Patrol remediation copy operator-safe even while legacy transport
fields retain
auto_fixnaming for compatibility: header autonomy controls, Pro-locked helper text, investigation outcome labels, and run-history badges must present the paid capability as safe remediation or remediation actions, not as a broad automation promise. - Keep the Patrol store aligned with the shared structured investigation
record when transport carries one.
frontend-modern/src/stores/aiIntelligence.tsmay retaininvestigationRecordas data for Patrol presentation, and visible Patrol copy must flow through the governed Patrol investigation-context helper (buildPatrolInvestigationRecordPresentationinfrontend-modern/src/features/patrol/patrolInvestigationContextModel.ts), which summarizes action artifact commands by count only and never renders raw command text. Approval and execution authority stays with the governed approval/remediation surfaces. The finding, approval, remediation-plan, run-history, and assessment hand-offs into the browser Assistant drawer that this obligation used to govern were retired with the chat window on 2026-10-22, and Patrol surfaces must not grow a chat hand-off back. The backend chat runtime keeps its finding-context rules for clients that still send a Patrolfinding_id(seeai-runtime). Patrol is the scheduled probe, context assembler, and execution-governance owner; the configured LLM is the diagnostic and remediation-reasoning owner. Patrol runs must still call the configured model when deterministic triage is quiet, and unmatched deterministic signals may be returned as context for another model pass but must not be converted into Pulse-authored findings after the model declines to report them. Legacy unified AI-finding integration must likewise store model-reported findings as evidence and must not auto-generate remediation plans from finding metadata. The inline Patrol investigation surface must also treat a structuredinvestigationRecordas investigation data, even when the legacy investigation-detail endpoint has no separate session payload, so it must not render empty-state copy above a durable Patrol record. The Patrol-owned investigation surface must also expose the durable record'simpactandrollbackfields: the sharedfrontend-modern/src/components/patrol/InvestigationSection.tsxrenderer surfaces an explicitImpact not assessedplaceholder whenever an investigation record exists with no impact text, and a parallelRollback not specifiedplaceholder whenever rollback is empty, so the operator-visible gap is conspicuous rather than hidden. The record presentation built byfrontend-modern/src/features/patrol/patrolInvestigationContextModel.tsmay carry populated impact text but must omit the placeholder copy, leaving placeholder rendering to the full investigation surface.frontend-modern/src/components/AI/FindingsPanel.tsxis the canonical renderer for that operator-facing impact text on the unified findings surface: when an expanded finding card has populatedimpact, the panel renders anImpact:line betweenDescriptionandRecommendation. On non-Patrol findings views, the same panel may surfaceinvestigation_record.confidenceas a collapsed-row badge beside the investigation outcome. The default Patrol page keeps that process evidence in the expanded issue or run history so current issue rows stay readable. Finding rows must keep their disclosure control separate from inline manual controls: the row summary may be a keyboard-accessible expand/collapse button, but acknowledge, snooze, dismiss, and other per-finding actions must be sibling controls, not nested inside the disclosure button or a fake role-button wrapper.FindingsPanel.tsxalso renders thepreviousResolvedFixSummaryoperational-memory field directly on the expanded finding card with emerald-accented styling, so operators see "what worked last time" inline. The summary lives on the finding shell (UnifiedFinding/Finding), not on the per-record investigation presentation; the Patrol-owned investigation-context model must not absorb it into impact, verification, or rollback (those represent the current investigation, not history).FindingsPanel.tsxalso renders the deterministiccapacityForecasturgency line on the expanded finding card, projected throughpresentCapacityForecast(patrolCapacityForecastPresentation). That line is the operator's primary capacity-urgency signal: it states direction (Filling up / Stable / Declining), days-to-full, daily change rate, and current utilization from the backend-computed forecast, and it must take precedence over the model-authored description whenever a forecast is present. The panel must not invent, smooth, or client-side infer a forecast; a missing forecast simply means no urgency line renders. The Patrol page must not render a standalone Trust strip above the Findings/Runs tab bar or a parallel header trust line. Patrol renders no primary assessment readout today; the header control row and the attention workbench carry current operator state. If a readout returns, it owns current operator state and may include high-signal trust facts such asstate.patrolStatus()?.trust.regressed_at_least_once(the FindingsTrustSummary block on the patrol-status response) only as compact status text. New trust categories must extend theFindingsTrustSummarycontract first rather than inventing per-page keys. Expanded Patrol finding cards keep action density product-grade: one primary action is visible inline (the finding's governed primary action when it has one, otherwiseInvestigatefor an un-investigated active finding, which starts Patrol's investigation throughreinvestigateFinding), while operator management controls live behind a compact in-flowResolve or dismissmenu. That menu must render inside the expanded finding detail rather than as a clipped floating panel, and the per-finding "Create rule from this" action must remain disabled unless the finding has both a concrete resource and category for a scoped suppression rule. The confidence badge palette is provided bygetInvestigationConfidenceBadgeClassesinfrontend-modern/src/utils/aiFindingPresentation.ts: high is reassuringly emphasized, medium is neutral, low is a soft amber. Findings without an investigation record (or without a recorded confidence) must show no confidence badge rather than defaulting to one, mirroring the impact rule that absent metadata is not fabricated. An actionable active finding must always expose a forward path into the governed action loop at its own expanded row. Above Watch only, that is the inlineInvestigateintent. In Watch only, the same expanded-row slot instead carries a mode handoff owned bypatrolControlPresentation.ts:getPatrolProInvestigationHandofffor plan-locked installs, andgetPatrolWatchOnlyInvestigationNudgefor installs whose paid Patrol modes are already unlocked. The unlocked nudge names the Watch only boundary and offers a one-clickSwitch to Ask firstthat routes through the samehandleAutonomyChangesave path as the header mode selector, never a second mode mutation surface. Both handoffs stay limited to active critical/warning findings, are mutually exclusive by lock state, and the unlocked nudge must yield to theInvestigateintent once the effective mode leavesmonitor. The Patrol store owns the sticky expanded-history state for Resolved/All views and must keep that data bounded: once resolved findings are requested, subsequent Patrol finding loads continue to request include-resolved history with the 200-item history limit instead of unbounded historical payloads or a transient active-only refresh. Resource operator priority is a Patrol attention-queue tie-breaker, not a second queue model and not a severity rewrite.resource_criticalityfrom the Patrol findings API normalizes toUnifiedFinding.resourceCriticality;sortFindingsForAttentionQueuemay order same-severity findings by high/medium/default/low before runtime and recency, but severity, investigation outcome, approval state, and the direct Patrol findings source remain the canonical current-work model. The operator edits that priority and the associated note fromResourceOperatorStateSectionon the resource detail drawer, alongside maintenance/offline/remediation-lock state, so the drawer stays the single resource-level Patrol intent surface. The TS API client mirrors (UnifiedFindingRecord.impact,Finding.impact) and the store normalizers (normalizeUnifiedFindingRecord,normalizePatrolFindingRecord) must carry impact through alongside description and recommendation rather than dropping it; runtime-failure findings produced byinternal/ai/patrol_runtime_failure.goare the first source to depend on that path reaching the Patrol page surface. Assistant sessions saved from the retired Patrol assessment, finding, and run hand-offs may still exist server-side. Theirhandoff_summarymust not expose or restore Patrol-authored next-step titles, recommendation detail, action labels, or app-route hrefs; legacy stored recommendation fields are ignored rather than converted into hidden context. - Keep the normal Patrol status summary plain and operator-first rather
than a hero-style or decorative card surface. The default page renders no
status summary card or assessment strip today: the header control row
carries Patrol state, mode, trigger status, and recency. If a collapsed
status readout returns, it is a compact readout, not a headline block: show
the Patrol status label,
current operator state, concise high-signal trust posture such as
regressions when present, and score. Do not combine reassuring grade labels such as
Health Awith issue-state copy such asIssues detectedin the collapsed line. Do not add a normal-path assessment details expansion: assessment explanation, verification detail, activity mix, and supporting metrics belong in the owning Findings or Runs surfaces instead of reopening the compact strip into a sparse status panel.
Canonical operational attention workbench
The primary Patrol workspace is now
frontend-modern/src/features/patrol/PatrolAttentionWorkbench.tsx. It consumes
frontend-modern/src/stores/patrolAttention.ts and the typed attention API; it
must not derive lifecycle state from legacy Patrol findings. Active, open,
acknowledged, suppressed, stale/unknown, recent-resolved, calm, partial, and
unavailable states all come from the same backend projection. Navigation and
the queue consume the same active summary. Those six fixed lifecycle views are
frequent operator triage choices: wide layouts retain one-click segmented
choices with the backend-projected count in every label, while narrower
layouts use the shared labeled select fallback. The control must not become a
horizontally scrolling rail that leaves a lifecycle view clipped or hidden.
The default view owns only the ordered action queue. Legacy Patrol checks,
investigations, and run history remain available under collapsed supporting
context. The selected detail owns impact, related resources, evidence quality,
protection posture, timeline, next step, and resource navigation. Its
contextual Assistant handoff was removed with the retired chat window on
2026-10-22. Browser
proof is tests/integration/tests/91-operational-trust-attention-workbench.spec.ts.
The scan row must reduce evidence freshness/completeness into one plain phrase,
omit protection posture when its state is unavailable, and use operator language
for meaningful protection states. Unknown evidence freshness means the backing
source publishes no validity window (only availability-poller evidence does),
so it is not an operator-facing warning: the scan row surfaces an evidence
phrase only for states worth a glance (unavailable, incomplete, stale, or
window-backed current evidence) and stays quiet for complete evidence with
unknown freshness, mirroring the unavailable-protection row rule. The selected
detail retains the typed evidence and protection facts, but labels unknown
timing, protection state, provider job state, and history availability
explicitly instead of exposing ambiguous raw value pairs such as
Unknown / Complete; for complete evidence without a validity window it uses
the neutral muted Evidence recorded label and must not claim timing is
unavailable while per-envelope observation times render beside it.
Attached availability failures use this same queue and detail contract. Their
attention item keeps the owning canonical resource ID, the exact
availability-poller evidence ID, freshness, impact, and resource deep link;
Patrol must not create an endpoint-only finding family or route the operator to
a duplicate standalone check. A disconnected or expired availability
observation remains stale or unknown and must not be presented as recovered.
The attached-facet browser proof is
tests/integration/tests/92-operational-trust-availability-facet.spec.ts.
Phase 5 adds one deliberately narrow mutation without changing that ownership
model. A selected canonical docker-container-health item may show the shared
AI-runtime offer for the resource's declared Docker restart capability.
PatrolAttentionWorkbench may plan or reopen that exact action, but all
approval, execution, policy evidence, delivery, audit, and verification
controls remain in the shared ActionReviewDialog. Patrol never reconstructs
eligibility from copy or metadata and never closes the issue because the
action command or running-state postcondition succeeded. It reports confirmed,
contradicted, or inconclusive verification beside the still-open lifecycle
record until fresh detector-owned recovery evidence resolves it.
The review trigger must restore focus to the current rendered control after
action refresh replaces the selected detail node. Desktop and mobile browser
proof, including failed verification and reduced motion, remains
tests/integration/tests/91-operational-trust-attention-workbench.spec.ts.
The durable decision and proof record is
internal/records/operational-trust-governed-docker-restart-2026-07-19.md.
Reviewing a long decision on a phone must not lose the queue controls: the
selected-detail header with Back, Previous, and Next issue stays pinned while
the detail scrolls. The shell-level rule (opaque sticky header, overflow-clip
inbox section) is owned by the frontend-primitives attention workbench shell
contract.
Current State
AI Discovery removed (2026-10-11)
Patrol reads canonical resource evidence through the shared AI runtime. The retirement boundary applies to the removed service-identification layer, independently of the retained Watch only, Ask first, Safe auto-fix and Autopilot modes.
Patrol operator workflow
The Patrol 2.0 frontend now uses a one-task-at-a-time, decision-first
information hierarchy. The compact, borderless command row owns enabled
posture, effective mode, last/next check context, manual check, settings, and
the secondary mode disclosure without presenting a second primary CTA card.
The typed attention workbench is the only substantial default page surface on
desktop and mobile. Protection deliberately swaps in retained objectives;
Activity swaps in proof-constrained verified outcomes and the subordinate
Review and history handoff for universal governed actions and Patrol-specific
finding/run records. Empty continuity surfaces therefore never share the prime
viewport with current decisions.
The page introduction states the operator job—find the decision, choose the
next step, and retain a verified record—rather than repeating the command
header's monitoring posture. A non-zero canonical pending-action count is
current operator work, so the attention header must expose a direct
/actions approval-review handoff beside refresh instead of requiring the
operator to discover it only in history or navigation chrome. That handoff
does not merge governed action records into the attention list or invent an
attention count; the queue and approval inbox retain their separate canonical
projections.
The default loaded state is a full-width decision inbox with one headline that
states how many current decisions need the operator, one Start review action
for the highest-priority item, the
canonical pending-approval handoff when needed, and refresh. It must not repeat
the same facts as a metric strip, generic row state, generic Review label, or
empty recommended-item preview. A two-pane workspace appears only after the
operator selects or deep-links a decision; wide layouts retain the inbox beside
the full governed context. On narrow layouts the selected context intentionally
replaces the list until Back to list, making Patrol a true master/detail
workflow instead of stacking the detail above a second full queue. The command
row remains compact and visually secondary so the inbox and first decisions
enter the initial viewport.
The default queue now leads generated kind on resource titles with the
resource identity so repeated incident families remain scannable without
changing the backend record. The selected context keeps the consequence and
next step primary, moves contextual Assistant explanation beside that summary,
keeps the canonical resource identifier behind a copy affordance, suppresses
impact text that merely repeats the summary, and groups evidence, protection,
and lifecycle history behind one deliberate disclosure. Occurrence controls
remain visible, while durable threshold and finding-management guidance is
secondary disclosure. Selected metadata includes the latest observation age,
and action-result wording remains capability-neutral rather than assuming every
offer is a restart or container operation. This is progressive presentation of the same typed
record, not a loss of evidence or lifecycle truth.
Plan-locked Watch-only installs do not render an empty mode disclosure after the effective mode is already visible in the compact command row. Runtime- locked and configurable installs retain the mode disclosure and its repair or choice controls. The empty Protection mode offers bounded example outcomes that prefill the existing objective form without creating an objective until the operator reviews and submits it. Activity keeps Actions and Patrol records as separate subordinate handoffs, but the Patrol-record handoff does not expose the legacy findings count beside the canonical decision count. Its supporting copy explicitly distinguishes raw finding/run history from Inbox decisions, and its collapsed container must not leave a decorative border artifact behind.
Selecting the first item starts a bounded review session over the loaded
decision order. The selected context shows its current position and exposes
previous/next navigation on desktop and mobile; deterministic identity breaks
otherwise equal priority ties so polling cannot reshuffle equal decisions
arbitrarily. Position copy is a live projection of the selected identity and
loaded queue length, not a one-time string captured when detail first mounts.
The session retains its review order while fresh list responses
remove settled items and append genuinely new work. Acknowledging an occurrence
is presented as Mark reviewed: on success the item leaves the active inbox,
Patrol announces the remaining decision count, and advances to the next current
item. Temporary suppression uses the same advancement loop and explicitly says
when it ends and which state it hands the occurrence back to. Clearing the
final item returns to the calm inbox with an honest completion announcement.
Ending a suppression, early or at its expiry, puts the alert in Acknowledged
when it is acknowledged and in Open otherwise (unsuppressOperationalAlert),
and Acknowledged is not active attention. So for an issue marked reviewed
(operationalRecord.acknowledgement present) the suppression form's duration
reads End suppression after and the early-end control reads End suppression; an unreviewed issue keeps Return it to active attention after
and Return to active attention. The handled-view notice after ending it reads
the state the post-change reload reports for the item, Suppression ended. It stays reviewed. for Acknowledged and Returned to decision inbox otherwise,
so a detail read before the review changed elsewhere cannot misstate the
outcome; it falls back to the detail's acknowledgement only when the item is
gone from the reload. getAttentionSuppressionEndPresentation owns that copy
and PatrolAttentionWorkbench.test.tsx pins all three cases.
The attention queue orders genuine operator decisions by severity, actionable
approval/review state, and latest observation time. Collapsed rows expose the
severity word, bounded consequence, affected resource, and freshness; only
exceptional approval-needed or verification-result work adds another label.
Lifecycle state remains selected-detail truth instead of a repeated Open
badge, and ordinary queue membership is not restated as Review on every row.
Selecting an item opens one responsive decision context: the current summary, affected
resource, impact and recommended next step precede governed action review;
occurrence acknowledgement/suppression, evidence, protection posture, timeline,
resource navigation, and contextual Assistant explanation remain available
without displacing the primary decision. Narrow selection scrolls and focuses
that context before the queue so keyboard and screen-reader users do not have
to traverse the list again. At widths where the detail replaces the queue's
reading position, its visible close affordance is an explicit Back to list
control; wide layouts retain the compact close icon. Both controls clear the
deep link and restore focus to the originating queue row.
A resolved item whose latest close is an ownership_transferred transition did
not recover: its condition moved to another record, such as the linked Pulse
agent's own alert. The detail's state badge reads Moved in the info tone
instead of the green Resolved, and the transition's reason (where the
condition went, and that it is not a recovery) sits directly under the summary
rather than only inside Evidence and history (getAttentionHandoverClose in
patrolHomePresentation.ts). The timeline names that cause Ownership transferred, never Recovery evidence.
Any Patrol Assistant handoff that attaches recent changes must tell the same
close the same way: an alert_resolved change carrying alert_resolution
metadata reads as the alert engine's summary through the shared
formatResourceChangeHeadline, never as Alert resolved: .... No Patrol
handoff attaches recent changes today.
The active Patrol queue now uses compact severity-accented rows for
prioritisation and a single focused review panel for the selected issue. The
collapsed row carries severity, actionable state, title, resource and recency,
plus one consequence line; evidence, recommendation, approval, verification,
history, and manual controls render only in the selected review. The previous
seven-field always-visible row scaffold and duplicate Open work count badge
were retired. Active findings group through API-owned same-resource, parent
node, or explicit correlation relationships, while the workspace continues to
count the underlying affected resources. Component, presentation, and browser
journey proof live in FindingsPanel.links.test.tsx,
FindingsPanel.test.ts, aiFindingWorkType.test.ts, and
tests/integration/tests/78-monitor-first-patrol-workbench.spec.ts.
Patrol provider-repair actions now use the canonical Pulse Intelligence >
Provider & Models route /settings/pulse-intelligence/provider. The legacy
/settings/system-ai route remains a compatibility alias for old deep links,
not a href emitted by new Patrol setup, finding, run-history, or summary
repair actions.
The finding lifecycle timeline renders backend lifecycle event types through
the shared label map in
frontend-modern/src/utils/aiFindingPresentation.ts
(formatFindingLifecycleType), with unknown types falling back to the
identifier formatter. The content_replaced event — emitted by the
ai-runtime findings store when a same-key re-detection's text is
substantially different from the existing finding (a key collision; see the
ai-runtime contract's Current State entry) — is labeled "Re-detected with
different details" so the operator timeline explains the shift in plain
language; the event's metadata carries the previous and new titles.
FindingsPanel.test.ts (lifecycleLabels) pins the label.
The Patrol findings panel
(frontend-modern/src/components/AI/FindingsPanel.tsx) dropped its "Open
related infrastructure / workloads / storage / recovery" cross-jump chip
strip on 2026-05-16 alongside the platform-first migration. The
useResources lookup that fed those chips and the supporting
buildResolvedResourceSurfaceLinks helper from
frontend-modern/src/routing/resourceLinks.ts were retired in the same
pass; the expanded finding body now keeps investigation in-place through
getFindingPrimaryActionPresentation (the canonical action href) plus the
shared manual-controls helper. New finding-detail affordances must not
reanimate the legacy chip strip or build URLs against the retired top-level
routes.
The Patrol page, store, findings UI, and run-history presentation had been outside the governed subsystem map even though they are the top-level runtime surface for Patrol intelligence. This contract now owns that orchestration and presentation boundary while leaving shared transport and payload-shape ownership in the governed AI runtime and API contract surfaces.
The per-rule alert-trigger policy lives on Settings > Pulse Intelligence >
Patrol (PatrolSettingsContent in
frontend-modern/src/components/Settings/AISettings.tsx, form state and save
in useAISettingsState.ts), not on the Patrol page. The Patrol page header
has no trigger controls. Outside setup-only states it may show a one-line
status.trigger_status summary when there is something to note (queued
triggers, busy mode, alert or anomaly triggers off) and links to that settings
page, unless a provider setup block puts a Fix setup action in place of the
link. In the settings page's Triggers section, a
minimum-severity selector ("Investigate alerts at or above": Critical only /
Warning and critical) sits under the Alert-triggered Patrols toggle and
renders only while that toggle is on. The selector and the trigger toggles
edit the settings form only, and nothing is written until Save Patrol settings, which sends patrol_alert_trigger_min_severity in the page's single
AIAPI.updateSettings payload whenever it differs from the loaded value.
There is no optimistic write and no revert: a rejected save raises an error
toast and leaves the edit in the form to retry, and a successful save reloads
the form from the response. The selector reads
patrol_alert_trigger_min_severity from the settings response, defaulting to
critical-only, and must keep using the shared AI settings form rather than
forking a Patrol-local form or save path.
The Patrol page keeps the Patrol mode policy on its own header, not on
Settings > Pulse Intelligence > Patrol: the first configurable decision remains
what Patrol may handle automatically (Watch only, Ask first,
Safe auto-fix, Autopilot), and there must be only one visible chooser for
that decision.
Per-resource automatic-action scope is configured in the canonical resource
drawer, not duplicated on the Patrol page. The drawer may expose only
capabilities whose backend contract declares auto-authorization eligibility,
requires an explicit capability allowlist, and may collect an optional daily
time/timezone window. Patrol mode remains the tenant-wide upper bound: a
resource opt-in cannot widen Watch only or Ask first, admit elevated work in
Safe auto-fix, bypass the full-mode unlock, or override Never auto-remediate.
Pending Patrol actions snapshot the bounded capability, tenant Patrol, and
resource operator authorities actually consulted at planning into the
server-authored action policyDecision. Its typed reason codes and revisions
are explanatory evidence for Task 11, including unavailable, missing,
emergency-stop, mode, allowlist, Never, and window posture. Planning and
dispatch share one pure evaluator, but dispatch re-fetches current inputs and
persists a separate authorization lease; the snapshot cannot authorize an
automatic action or suppress current-policy revocation.
Commercial, runtime, and documentation copy that describes this same decision
must also use those visible labels and the umbrella name Patrol mode, not
the retired Only watch, Fix safe issues, Full control, or generic
Patrol control level vocabulary.
Provider model, run schedule, trigger tuning, readiness checks, and the saved
readiness result belong on Settings > Pulse Intelligence > Patrol; a save whose
response reports Patrol not ready or degraded raises a warning toast instead of
a success toast. In that page's Triggers section, the two alert-driven AI
toggles are told apart by scope rather than by near-identical names. The
genuinely general path is Alert-triggered Patrols, which runs a focused
Patrol investigation of the alert's own issue. The Pro-gated
AlertTriggeredAnalysis toggle presents as
"Container update risk" with copy scoped to container-update alerts, because the
enterprise AlertTriggeredAnalyzer only assesses docker-container-update
alerts and returns nil for every other alert type. New copy must keep the
container-update toggle scoped to its real Docker-update-risk capability instead
of drifting back to a generically named "Alert-Triggered Analysis" control that
collides with Patrol's own alert investigation.
The route file frontend-modern/src/pages/AIIntelligence.tsx is now also a
thin shell that delegates to the feature-owned
frontend-modern/src/features/patrol/PatrolIntelligenceSurface.tsx, so Patrol
runtime state and presentation no longer accumulate directly in the route
component itself. The governed customer-facing route for that shell is now
/patrol, while retired /ai browser entry points stay unregistered instead
of remaining as compatibility redirects or a second product path.
That route-shell ownership does not make AI the customer-facing Patrol
product name. Internal file, store, and transport names may still carry the
shared AI-runtime boundary where that is the real technical ownership, but the
operator-facing Patrol experience should present Patrol as the product and
avoid drifting back to generic AI Intelligence branding outside explicit
provider/settings affordances.
The feature surface now also keeps the same shell/runtime split internally:
frontend-modern/src/features/patrol/PatrolIntelligenceSurface.tsx owns feature
composition, the Patrol-owned section files under
frontend-modern/src/features/patrol/ own the header, banner, workspace, and
tab-panel render surfaces (the Inbox attention list, Protection objectives, and
the Activity tab's This week digest and recent work), and
frontend-modern/src/features/patrol/usePatrolIntelligenceState.ts owns the
page's shared Patrol state, transport, polling, and effect lifecycle. The shell
and the header, banner, and workspace surfaces must not re-accumulate those
Patrol API calls, timer orchestration, or store refresh semantics; the
attention list, objectives, recent work, and This week panels each own their
own typed read and refresh instead, and frontend-modern/src/stores/aiIntelligenceSummaryModel.ts now
owns the canonical summary normalization so Patrol consumers inherit one
governed recent-change and policy-posture snapshot instead of reintroducing
hook-local fallback logic.
The hook no longer returns the summary card's severity and fix tallies. Its
summaryStats accessor (critical, warning, and total active findings plus
fixed outcomes, counted client-side over the Patrol findings list) lost its
only reader when the Patrol summary card was deleted and has been removed,
together with the canonical-patrol/no-local-summary-card-presentation rule in
frontend-modern/scripts/canonical-platform-audit.mjs, whose regex matched only
text shaped like the deleted card's tint ternaries on
summaryStats().criticalFindings, warningFindings and fixedCount. The open-issue severity counts the page shows today come from
the Activity tab's This week card, which reads them from
GET /api/ai/patrol/digest (see that card's section below); a count surface
that returns must not revive a hook-local tally of the findings list.
That same Patrol hook boundary now consumes shared AI settings/model truth
through frontend-modern/src/stores/aiRuntimeState.ts instead of mounting its
own /api/settings/ai or /api/ai/models reads. Patrol-specific state still
owns local toggle optimism, run-status orchestration, and Patrol-only copy,
including runtime-availability messaging that stays Patrol-first in
operator-facing shells and uses provider/API-key wording only for the actual
provider settings boundary, but the underlying AI runtime catalog must stay shared
with chat and AI settings. The Patrol model selector on Settings > Pulse
Intelligence > Patrol (AIModelOverrideField with kind="patrol") reads that
same shared catalog and must remain
state-driven across async settings/catalog loading: a saved direct-provider
model such as deepseek:deepseek-v4-flash must render as that provider model
once the shared catalog supplies it, not fall back visually to the default
model or an unrelated OpenRouter entry because the field rendered before the
catalog request completed.
The Patrol page now also treats Patrol runtime availability as a first-class
render contract: any Patrol surface that presents runtime availability must
route through the shared frontend-modern/src/utils/patrolRuntimePresentation.ts
helper plus the backend runtime_state payload instead of inferring operator
state from the last healthy summary snapshot or run history alone.
Patrol renders no primary summary strip today. If one returns it stays
descriptive only: it surfaces the current Patrol assessment label and compact
counts, while action choices remain in the workspace, header controls, and the
LLM-driven Assistant chat.
frontend-modern/src/features/patrol/patrolInvestigationContextModel.ts
packages the Patrol finding, attention-item, and run handoffs, carrying only
bounded model-only context, resource references, and safe structured
approval/action references, and visible drawer copy must not promote
Pulse-authored next-step metadata, action chips, or suggested prompts as the
answer. Command payloads stay out of drawer chrome.
Run-history rows now follow that same Assistant handoff model. A selected
frontend-modern/src/components/patrol/RunHistoryEntry.tsx row may open
Assistant through
frontend-modern/src/features/patrol/patrolInvestigationContextModel.ts with a
visible Patrol run attached drawer briefing (bounded outcome and coverage
facts plus a redacted runtime failure summary when present) and safe run
identity metadata; the backend (internal/ai/patrol_assistant_handoff.go)
builds the model-only [Patrol Run Context] block and scoped resource
references from the run ID. The row must not create a second
prompt-only Assistant shortcut or imply that Assistant can retry Patrol,
change provider configuration, or execute remediation from run-history context.
That active-runtime label must stay operational rather than verdict-like: the
header chip should communicate that Patrol is enabled or available, not imply
that infrastructure health is currently good merely because the runtime is on.
That render rule now also has browser-level proof in
tests/integration/tests/18-patrol-runtime-state.spec.ts: when the backend
reports runtime_state=blocked, the real /patrol route must show Patrol as
paused, keep the blocked reason visible, disable manual Patrol runs, and
suppress stale healthy summary headlines such as Health A · 100/100 even if
the last summary payload still looks healthy. Legacy /ai entry points must
redirect into that same Patrol-owned shell rather than preserving a second
canonical route.
That same browser proof now covers where Patrol settings are saved. The
Patrol page has no settings drawer or popover: Patrol schedule, triggers, and
the Patrol model override live on Settings > Pulse Intelligence > Patrol
(Save Patrol settings), and providers and the shared default model on
Settings > Provider & Models. A rejected save there raises an error
notification carrying the backend's concrete license/validation reason
instead of generic fallback copy, and it offers no Assistant handoff. If a
Patrol settings popover or an Assistant handoff from a settings failure
returns, the handoff is model-only explanation context: raw command, script,
credential, and provider-detail payloads stay redacted, Assistant opens with
autonomousMode:false, and the popover closes so the operator is not left
behind it.
Patrol-control save-failure sessions saved by earlier builds keep the
compatible handoff_metadata.kind=patrol_configuration_failure plus only the
runtime-failure boolean needed for drawer/session presentation, so they restore
as a Patrol control issue without carrying raw provider, credential, command,
or retry payloads into the browser.
Successful Pulse Intelligence settings saves whose returned
patrol_readiness.status is not_ready or warning are still Patrol control
issues, not silent successes: Settings > Provider & Models, Patrol, Assistant
and Service context keep the saved non-secret values in the form and raise a
warning
toast (<page> settings saved, but Patrol is not ready or ... is degraded)
with the readiness summary, provider and model instead of a success toast
(getAISettingsPatrolReadinessSaveMessage in
frontend-modern/src/components/Settings/useAISettingsState.ts). A Patrol
on/off toggle save whose response reports not_ready raises the fixed warning
Patrol setting was saved, but Patrol is not ready to run. in either
direction, because readiness is evaluated independently of patrol_enabled.
Patrol renders no inline control-issue state or Assistant handoff for either
case.
A separate browser proof in
tests/integration/tests/78-monitor-first-patrol-workbench.spec.ts keeps the
authenticated launch workbench monitor-first. When the runtime has monitored
Proxmox resources, legacy infrastructure entry points must resolve to the
Proxmox monitoring lens before Patrol or Assistant chrome, while the stable
Patrol tab may still expose the open-work count. Calm-day copy such as No current issues and checked-resource coverage belongs inside the Patrol route
after the operator chooses Patrol; the monitor lens must not become a hidden
Patrol all-clear page.
The readiness contract now applies before Patrol work is admitted, not only
after a page render: recoverable Patrol provider/model settings saves must
persist and echo structured readiness cause metadata, manual run requests must
return the structured readiness reason if a stale UI still submits, and
scheduled or scoped alert/anomaly runs must skip before calling the model while
preserving the blocked reason and cause in Patrol status. When the
safe-remediation entitlement is not effective, the Patrol header must present
findings-only monitor as the effective mode and the Patrol control state
owner must refuse any investigation/remediation level when a save starts;
the monitor save it does send is accepted without the entitlement, and the
API clears stale full-mode unlock and Autopilot activation state on it, so an
expired or downgraded plan cannot turn a recoverable control review into a
Pro-only save failure. Patrol renders no inline error
surface for these failures today: switching Patrol on or off while it is not
ready raises a fixed warning notification, a failed Patrol mode save raises an error
notification, and neither offers an Assistant handoff. A provider or model save
in Settings > Provider & Models reports the readiness summary, provider and
model in its own save message.
The Patrol mode selector in that header must compose the shared
frontend-modern/src/components/shared/FilterButtonGroup.tsx instead of
rebuilding a local active-button group. When the header shows Patrol mode
options, it renders the selector in the segmented layout inside its Mode and automation disclosure; a constrained surface that hosts it may use the shared
prominent layout so all four mode labels remain readable without inventing a
Patrol-local selector. Patrol owns the default visible four-level
policy presentation (Watch only, Ask first, Safe auto-fix,
Autopilot), entitlement locks, and the rule that choosing the highest
Autopilot level opens the acknowledgement dialog and saves full only with a
recorded acknowledgement_id (the API derives the compatibility
full_mode_unlocked value itself), while saving any lower level lets the API
clear the Autopilot activation. The shared primitive owns pressed-state semantics,
disabled-option behavior, and active/inactive selector styling.
That same Patrol-owned presentation rule also applies to the findings empty
state: frontend-modern/src/components/AI/FindingsPanel.tsx must not treat
0 active findings as equivalent to "your infrastructure looks healthy" when
the Patrol runtime is blocked, disabled, or unavailable, or when the canonical
overall-health summary is degraded or not fully verified. The green healthy
empty state belongs only to an actually healthy Patrol summary, while degraded
coverage or paused-runtime states must surface the governing warning/error copy
through frontend-modern/src/utils/patrolEmptyStatePresentation.ts.
Patrol paywall actions now follow the same shared commercial navigation split.
frontend-modern/src/features/patrol/PatrolIntelligenceHeader.tsx,
frontend-modern/src/features/patrol/PatrolIntelligenceBanners.tsx, and
frontend-modern/src/features/patrol/usePatrolIntelligenceState.ts may resolve
commercial destinations from the shared license boundary, but they must leave
internal-versus-external navigation semantics to frontend-primitives once a
Patrol feature can resolve to either product-owned routes or public pricing.
That same Patrol-owned commercial boundary must also fail closed in public
demo and ordinary self-hosted runtimes. Patrol header, banner, approval, and
history-adjacent lock surfaces must remain informational unless the operator
is already in an entitled, hosted, or explicit commercial handoff context. The
browser-owned trigger for self-hosted suppression is the shared resolved
presentationPolicy from
/api/security/status, seeded by the backend capability fact
sessionCapabilities.demoMode plus the self-hosted upgrade policy. Patrol
surfaces must therefore suppress upgrade CTAs, trial nudges, checkout links,
and Pro-only helper copy from that shared policy instead of reviving local demo
heuristics or issuing early commercial reads before the policy resolves.
That same shared policy now also owns Patrol approval polling posture.
frontend-modern/src/stores/aiIntelligence.ts must fail
loadPendingApprovals() closed in public demo mode and return the canonical
empty queue from the shared store boundary itself, so dashboard and Patrol
shells do not probe /api/ai/approvals after the read-only demo policy has
resolved.
That shared store may retain all pending approvals for dashboard and Assistant
surfaces, but Patrol-owned presentation must consume only Patrol-scoped
approval selectors. frontend-modern/src/components/AI/FindingsPanel.tsx and
frontend-modern/src/components/patrol/ must not count or render generic
Assistant command approvals as Patrol finding approvals, and dashboard
action-required affordances must use generic approval actions when the pending
request is not tied to a Patrol finding.
That same store-owned demo boundary also covers remediation artifacts.
frontend-modern/src/stores/aiIntelligence.ts must fail
loadRemediationPlans() closed in public demo mode and
frontend-modern/src/components/AI/FindingsPanel.tsx must consume
aiIntelligenceStore.remediationPlans instead of issuing its own
AIAPI.getRemediationPlans() read, so the public Patrol page does not trigger
/api/ai/remediation/plans paywall probes after demo posture has resolved.
That same posture split now also centralizes Patrol commercial bootstrap.
frontend-modern/src/features/patrol/usePatrolIntelligenceState.ts and
frontend-modern/src/components/patrol/ApprovalSection.tsx must not mount
commercial trial or upgrade state merely because an ordinary self-hosted
operator opens Patrol. Authenticated Patrol shells inherit any allowed
commercial bootstrap from frontend-modern/src/useAppRuntimeState.ts, so
Patrol-specific hooks do not quietly retake ownership of commercial fetch
timing or reintroduce local trial-start actions.
Under ordinary self-hosted v6, Patrol commercial affordances must also honor
the shared presentationPolicy.hideUpgrade contract. A free self-hosted
install may show Patrol runtime availability and configuration gaps, but it
must not show Pro trial CTAs, upgrade links, paid helper copy, or a plan-lock
upsell banner in the default Patrol workflow unless hosted mode, an explicit
commercial handoff, or an active entitlement makes those actions relevant.
That degraded empty-state copy must also interpret the finding state rather
than replaying an overall_health.prediction sentence verbatim: when coverage
is incomplete, the findings panel should tell the operator to run Patrol to
complete coverage before trusting the all-clear. The page must not duplicate
the assessment prediction as a second independent status surface above current
issues.
No shared presenter derives a compact assessment, assessment shell, score
chip, assessment explanation, or recommended next step today. The helpers that
did (getPatrolAssessmentPresentation, getPatrolAssessmentShellPresentation,
getPatrolScoreChipLabel, getPatrolCompactAssessmentLabel,
getPatrolSummaryMetricState, getPatrolAssessmentAction and their siblings)
have had no production caller since the Patrol summary card was deleted
(several lost theirs months earlier) and are gone;
frontend-modern/src/utils/patrolSummaryPresentation.ts now owns only the
header recency line (getPatrolRecencyPresentation) and the run-history
coverage verdict the current-findings empty state reads
(getPatrolRunCoverage). If a summary card, metric strip, or
assessment readout returns, it must derive its state from one shared
Patrol-owned presenter rather than page-local logic, and keep these rules.
A secondary metric strip must not render No issues found while the governed
overall-health summary says coverage is incomplete or health still requires
attention. An assessment shell stays inside the shared Pulse card language:
the neutral bg-surface page-card base, with severity carried by compact
header accents, icon treatments, and badges rather than a tinted full-width
warning banner. A supporting score chip reads as an Assessment grade rather
than a Health grade when incomplete coverage or Patrol-owned runtime failures
dominate; Health belongs to verified healthy infrastructure states. An
Issues detected headline is never paired with a raw coverage-only
overall_health.prediction sentence from a separate source; active findings
and incomplete verification are described together in one message. When the
only active Patrol findings are synthetic Patrol service/runtime conditions
such as the ai-service provider-credit failure, the readout names a Patrol
runtime issue rather than implying infrastructure issues across the estate,
and with exactly one such finding it names the concrete failure, such as
Provider billing or quota issue. Any recommended next step comes from that
same presenter: pending approvals take priority over general triage,
coverage-incomplete states ask for a full check before any all-clear, runtime
impairment points the operator back to restoring Patrol visibility, and
healthy states fall back to continued scheduled monitoring rather than
inviting generic Assistant chat. When that recommendation has an immediate
governed operator path, the presenter declares a bounded action kind that maps
only to existing Patrol controls (run a full Patrol, review approval-scoped
findings, review active findings, or open Patrol provider settings), never to
page-local remediation, approval, or execution authority invented from
recommendation text.
If a summary card returns, that same runtime-owned assessment must expose the
fix path directly. When the primary Patrol issue is a Patrol runtime/provider
problem rather than an infrastructure finding, the summary card should offer a direct Open Patrol provider settings action instead of making the operator dig through the
findings list to discover where to correct provider configuration.
That same runtime-versus-infrastructure distinction should route through the
shared finding-presentation helper instead of being re-inferred separately by
any summary card and the findings list. The active finding row should surface
the same Patrol runtime classification with a runtime-qualified severity badge
such as Runtime issue or Runtime critical, rather than pairing a generic
infrastructure severity chip like warning with a second Patrol-runtime
label.
Runtime setup copy from that helper must stay neutral across watch-only and
paid control modes: it should explain that Patrol needs runtime or provider
setup before it can check infrastructure reliably, not promise investigation,
approval-backed fixes, or autonomous action from a locked install.
Patrol run history must follow the same operator-facing runtime failure
contract. Expanded erroring runs should show the backend-provided
error_summary, bounded error_detail, and the shared direct Open Patrol provider settings action near the run narrative, so a provider/model/tool
failure remains actionable even when the operator starts from the Runs tab
rather than the synthetic runtime finding.
Those run-history failure fields are customer/API-safe classified detail, not
raw provider payload storage. The backend must normalize both newly written
and already persisted Patrol run records before browser/API serialization, so
provider protocol fragments such as tool_choice, reasoning_content, raw
endpoint URLs, credential hints, or model-internal error strings do not leak
through run history while the operator still receives an actionable recovery
summary.
The Patrol surface must not keep presenting runtime-warning or runtime-issue
copy after a successful provider-backed Patrol run proves the selected
provider/model can run tool-backed analysis. Scoped success may still leave
estate coverage incomplete, but it must clear stale Patrol runtime impairment
state and suppress provider-only readiness warnings for live-proven
tool-capable models.
That same shared finding-presentation helper should also own Patrol finding
subject labels, so Patrol-owned synthetic service findings render as
Patrol runtime rather than leaking backend resource internals like
Pulse Patrol Service (service) into the primary findings row or assistant
handoff prompts.
That same title presentation contract should normalize Patrol-owned finding
titles too. The primary findings row, assistant handoff copy, and inline
approval surfaces should present runtime findings as Provider billing or quota issue
rather than repeating the product prefix or legacy Insufficient API credits
wording once the surrounding UI already makes the Patrol context explicit.
That same finding presentation contract should own the primary remediation path
for Patrol-owned runtime findings as well. Expanded runtime-finding rows should
lead with the shared getPatrolProviderSettingsAction() action (Check Patrol model), and that action must use the canonical Pulse Intelligence
route /settings/pulse-intelligence/patrol rather than the legacy
/settings/system-ai compatibility alias. Runtime/setup findings in the
default current-issues flow must stay primary-action-only: they should not add
a secondary chat button or a generic Manage menu beside the direct setup
action; a setup impairment should not read as a menu of workflows.
When setup is the only active Patrol work, the Patrol page should collapse that
state into one Fix Patrol setup workspace task with the direct
Open Provider & Models action; the readiness banner must not duplicate that
same action above it.
The current-issues list must consume that same canonical primary action for
exactly one active runtime finding, so the visible next step opens Patrol
provider settings directly instead of making the operator first click through a
generic findings review CTA.
The setup-only Patrol workspace must keep that same single-path focus: when
Patrol cannot check infrastructure because provider setup is blocked, the
workspace may show the current setup issue and the provider-settings action, but
must not expose run history as a competing action until Patrol can actually
check infrastructure or the operator has opened a specific run record.
That same contract must fail closed on manual lifecycle controls too. Patrol
runtime findings are Patrol-owned impairment signals, not ordinary estate
findings, so the findings list must not offer generic acknowledge, snooze,
dismiss, resolve, or suppress controls for them. The correct operator path is
to fix Patrol provider configuration in Pulse Intelligence > Provider & Models
settings and rerun Patrol, optionally adding context notes, rather than hiding
the runtime issue.
If a summary metrics strip returns, that same runtime-versus-infrastructure
split must carry through it. When Patrol-owned runtime issues are active, the
supporting metrics must stop counting them under generic infrastructure
Warnings or Active findings; the strip should break out Runtime issues
separately and reserve infrastructure finding counts for actual estate issues.
The findings list must respect that same trust priority. When Patrol-owned
runtime issues share a severity tier with ordinary infrastructure findings, the
runtime issue should sort first within that tier so Patrol blindness is not
buried under same-severity estate warnings.
Patrol renders no summary recency chip today; the page-header recency line is
the only Patrol recency surface, and getPatrolRecencyPresentation labels it.
When run history holds a completed run, the line reads Last check for the
most recent one of any type: full, targeted, or follow-up. Otherwise it falls
back to the status transport: Last check with last_patrol_at when that is
the only timestamp, when it is at least as recent as last_activity_at, or when
only the activity timestamp fails to parse; otherwise Last activity with
last_activity_at. The transport keeps the
distinction: last_patrol_at names the last completed full Patrol sweep,
while last_activity_at may advance on scoped work or fix-verification checks
without claiming a new full verification pass. The header must not revert to
a generic Last: timestamp.
If Patrol renders a summary surface again, it must also avoid reintroducing a
second compact assessment or verification layer beneath the primary card. Supporting metric strips
belong to counts and outcomes such as active findings, critical findings,
warnings, and fixes; they must not repeat Patrol assessment labels or
verification labels in a second row that competes with the primary governed
assessment and verification copy above.
The same supporting-chip rule applies to timing: such a primary summary card
may show health and active-finding support, but it should not add another recency
pill, because the header recency line already carries the governed activity
timestamp.
That same Patrol-owned run-history surface must keep platform-backed system
counts canonical too. When the backend distinguishes API-backed TrueNAS
systems from unified-agent hosts in Patrol run history, the run-history chips
and selected-run breakdown must render TrueNAS separately instead of
collapsing those systems back into the generic agent count.
That run-history distinction must not reopen a parallel raw truenas
resource-type contract in Patrol findings, scoped-run filters, or alert-backed
resource state. Those payloads stay canonical agent plus platform context,
while the separate TrueNAS count remains a run-history coverage detail.
If Patrol renders a summary card again, the same summary-card/metrics-strip
split also applies to findings counts: the primary assessment card may keep
health as supporting context, but active
findings, warning counts, and critical counts belong to the supporting metric
strip rather than being repeated as duplicate badges inside the primary card.
Patrol renders no check summary today. getPatrolRunCoverage reduces run
history to the coverage verdict the current-findings empty state reads:
complete (the latest completed full check ended cleanly, checked resources,
finished within the last 24 hours, and no check after it failed), incomplete
(it or a later check ended with errors, or only targeted or follow-up checks
completed), or unproven. Nothing computes a same-day activity mix:
getPatrolActivityBreakdown and its formatter went with the verification
presenter that was their only caller. The header recency line carries the
visible coverage phrase. If a
check summary returns with that summary surface, it must explain what Patrol
actually checked without turning coverage mechanics into the default product
language: whether Patrol recently completed a clean broad check, only ran
targeted alert or anomaly-triggered checks, or ended its most recent broad
check with errors. When same-day run history shows both a recent broad check
and a burst of targeted or follow-up activity, that surface should expose the
activity mix in check language instead of asking operators to reconcile a
Recently checked headline with a busy Patrol strip elsewhere on the page.
Fix-verification checks belong to that same explanation layer as follow-up
checks, not as evidence of a fresh full-estate sweep.
The same hierarchy keeps correlations, recent changes, and policy posture off
the Patrol page. They are secondary explanation for deeper investigation, so
the workspace offers no Details supporting-context disclosure for them in any
state, healthy or not: the selected finding or run record remains the Patrol
source of truth, and that nearby evidence must not return as a second parallel
Patrol workflow beside the findings and history controls.
Patrol's run and trigger context, by contrast, belongs in the secondary
Finding options and history workspace beside the findings and run history,
not as a default full-width strip that competes with the current issues. The
workspace and shared
frontend-modern/src/utils/patrolRunPresentation.ts helpers may carry latest
run kind/result, scoped-trigger state, and circuit-breaker warnings as factual
support when the user opens the relevant context or when the page must surface
an actionable warning. They must not make activity-mix labels, raw run-count
breakdowns, health scores, or loop-proof counters default-page content.
That same secondary area should simplify by consolidation rather than
deletion. Patrol should keep meaningful run and trigger facts available, but it
should stop repeating the same runtime story as a summary card, a metric row,
and a separate status strip all at once.
Do not reintroduce a separate Patrol status strip for this context. Compact
activity facts belong in run history, selected finding details, or explicit
secondary context, not as a second Patrol verdict label.
That same activity explanation should handle noisy Patrol behavior concretely.
When same-day history shows a mix of full sweeps, verification checks, and
scoped alert- or anomaly-triggered patrols, a returning verification/activity
surface should expose a compact breakdown of those run categories (Patrol
renders none today) instead of leaving
operators to infer why Patrol looked busy from an undifferentiated run count
alone.
The same operational layer should also surface scoped-trigger state directly.
If Patrol has queued scoped work, is in busy mode, or has one scoped trigger
source disabled, the governed summary should state that as factual runtime
context instead of forcing operators to cross-reference hidden settings or
infer it from missing runs.
That recent-activity copy also has to remain intelligible in compact or
plain-text renders: the latest-run segment must keep an explicit textual
separator between run kind and result, so degraded entries read as
Scoped run · error rather than collapsing into concatenated strings like
Scoped runerror.
Those runtime facts must stay aligned with Patrol mode copy. Settings > Pulse
Intelligence > Patrol, not the Patrol header, exposes alert-triggered and
anomaly-triggered scoped Patrols as separate controls, with the legacy aggregate
event-trigger toggle treated as compatibility-only transport rather than the primary product
model.
The findings empty state must also stay subordinate to the Patrol header
rather than mirroring its timing metadata. In the primary
Patrol page, frontend-modern/src/components/AI/FindingsPanel.tsx should
explain the absence of active findings without repeating Last activity,
Next run, or interval schedule details that already belong to the header and
verification hierarchy above.
That same empty-state contract must become run-record-aware when the user is
reviewing an explicit Patrol run. A selected run with an explicit empty
finding_ids record should explain that no findings were recorded for that run
and, when applicable, carry the canonical run coverage summary and issue caveat
instead of falling back to the generic No Patrol findings to display copy.
That same internal finding_ids scoping must apply to the findings control bar
too. When the user is looking at an explicit run record, filter pills and their
attention or approval counts must derive from that run-scoped finding set
rather than borrowing global Patrol finding counts from outside the selected
run.
That same run-scoped model must also apply to the Findings tab badge itself.
When the selected run carries an explicit empty finding_ids record, or when
the run lacks finding_ids entirely, the tab must fail closed instead of
borrowing global active-finding counts and tones from outside the selected run.
That same scoped count model must drive conditional findings filters too. The
Needs Attention and Approvals buckets, their counts, and the auto-reset
logic that returns the operator to Active when a bucket disappears must all
read from the same run-scoped count source rather than mixing run-record pills
with global queue truth.
That same fail-closed finding_ids rule applies to inline run-history findings
as well. Expanded run cards should route through the same run-aware findings
surface as the primary workspace, so legacy runs without finding_ids still
show an explicit finding-record-unavailable state instead of disappearing or
being coerced into an empty findings record.
That same rule applies to the primary findings workspace when a run is
selected. A selected run without finding_ids must not borrow global Patrol
findings, filter buckets, or queue counts; the findings surface should enter an
explicit finding-record-unavailable state instead.
That same unknown-record state should be visible in the selected-run shell too.
When the operator is reviewing a legacy run without finding_ids, the
selected-run banner should explicitly say that the finding record is unavailable
instead of implying a fully verifiable run-scoped findings view.
That same trust rule applies inside expanded run-history narratives. A legacy
run without finding_ids must not render an All clear conclusion
just because its aggregate counters are zero; the narrative should explicitly
state that run-specific findings could not be fully verified.
That same truthfulness rule applies to the expanded run outcomes strip. Legacy
runs without finding_ids must not render a green All clear outcome badge
from zero aggregate counters; they should show an explicit finding-record
unavailable state instead.
That same caveat belongs in compact latest-run summaries too. When the most
recent Patrol run lacks finding_ids, the status bar's latest-run segment
should say that the finding record is unavailable instead of
flattening the run into a plain healthy-looking summary.
That same caveat belongs in collapsed run-history rows. Legacy runs without
finding_ids must carry an explicit finding-record-unavailable marker in the
top row instead of looking like a clean zero-findings run until expanded.
That same rule applies to run-status badges. A legacy run without findings
records must not keep a green healthy badge when the surrounding UI is
saying findings verification is unavailable; the canonical run-status
presentation should downgrade that state to a neutral completed badge.
That same truthfulness rule applies to the run-history shell copy. The Recent patrol runs helper text must not present run review as a findings filter; it
should frame history as Patrol run records, and when visible runs include
legacy entries without finding_ids, or when the selected run itself lacks a
finding record, the shell should say so explicitly.
That same findings surface should keep its section chrome functional rather
than promotional. Inside the Patrol findings tab, the selected tab already
names the surface, so the findings card should not add another in-card product
header or marketing subtitle that simply repeats the tab-level context.
That same control bar should also stay proportional to the current findings
set. Sort controls belong only when there are multiple Patrol findings to
order; the empty state or single-finding state should not spend header space
on a no-op sort selector.
The same proportionality rule applies to the findings filter bar itself. When
there are no Patrol findings and no special approval or attention queues to
navigate, the findings surface should not render filter pills that lead only
to the same empty state.
Tab badges and finding metadata in that same surface also need explicit textual
separators rather than CSS-only spacing. Badge counts should preserve readable
plain-text output such as Findings 1 and Runs 30, and metadata trails
should use textual separators like · acknowledged 22d ago so copied or
extracted Patrol output does not collapse words together.
That same findings contract must preserve and use last_seen_at for active
Patrol findings. Recurring active issues should read as last seen ... and
sort by current observation recency rather than presenting only the original
detected_at, which makes still-active Patrol service issues look stale when
they were re-observed on recent runs.
That same finding row should avoid redundant state stacking. Active Patrol issue
rows must not add baseline detected or raw loop-state badges; non-Patrol
finding rows may still use loop-state badges only when they communicate a more
specific state than acknowledged/current observation metadata.
Collapsed finding-row badges now follow the shared metadata badge boundary:
frontend-modern/src/utils/aiFindingPresentation.ts owns Patrol-specific
status/source/severity/investigation/confidence/workflow state-to-tone mapping,
while frontend-modern/src/components/AI/FindingsPanel.tsx renders those chips
through MetadataBadge with the shared outlined compact appearance. Patrol
workflow chips may appear only for specific actionable or recorded states such
as Review approval, Verify outcome, and Outcome recorded. Plain active or
detected findings must not add passive Detected, Review finding, or other
generic workflow badges beside the severity badge. Grouped current findings
must use issue/resource language, not internal signal-count language. New
finding-row badges must extend the Patrol presentation helper and
MetadataBadge tone vocabulary rather than restoring local bordered xs spans.
The visible finding summary is also the default disclosure target for the
issue: clicking it, pressing Enter, pressing Space, or using the explicit
View details/Hide details control must open the same detail panel. Inline
approval, setup, and manual action controls stay separate siblings so those
actions do not accidentally toggle the issue details.
The inline investigation surface follows the same boundary:
frontend-modern/src/components/patrol/InvestigationSection.tsx must compose
MetadataBadge for live investigation status/outcome chips, durable Patrol
record status/outcome/confidence chips, and tool metadata chips. Patrol may
derive labels in patrolInvestigationContextModel.ts and tones in
aiFindingPresentation.ts, but the visible chip shell stays primitive-owned.
Approval and run tool-call detail chips follow the same rule:
frontend-modern/src/utils/approvalRiskPresentation.ts and
frontend-modern/src/utils/patrolRunPresentation.ts own risk/result labels and
semantic badge tones, while ApprovalBanner, ApprovalSection, and
RunToolCallTrace render those chips through MetadataBadge.
When Patrol is currently running, that strip should still stay factual rather
than switching to another verdict label: the runtime may add an explicit
in-progress indicator, but the primary activity label remains recent activity
instead of a competing Patrol-state verdict.
That latest run result must come from the effective run outcome, not the raw
status field alone: shared Patrol run presentation helpers must treat any run
with execution errors as an error result even when the stored status text is
still healthy, so run history and header activity surfaces do not present a
false green outcome for an incomplete Patrol execution.
hook-local fallback logic.
The Patrol header now also has explicit helper ownership for schedule and
runtime presentation. frontend-modern/src/utils/aiPatrolSchedulePresentation.ts
and frontend-modern/src/utils/patrolRuntimePresentation.ts are the canonical
owners for Patrol interval option labeling and runtime-state wording used by
frontend-modern/src/features/patrol/PatrolIntelligenceHeader.tsx; future
Patrol header work should extend those helpers instead of rebuilding schedule
labels, runtime copy, or retired managed-credit badges inline in the header
shell. That same header surface must normalize older hosted-model block reasons
back to provider or local-model setup guidance.
frontend-modern/src/utils/remediationPresentation.ts is now also the
canonical owner for remediation result badge copy and success/failure styling
used by frontend-modern/src/components/patrol/RemediationStatus.tsx, so
Patrol execution feedback does not drift into inline message branches inside
the component.
Patrol finding state must now also consume the canonical camelCase
alertIdentifier field and pending-approval expiry metadata end to end.
Frontend Patrol helpers may not keep shadow alert_identifier fallbacks or
drop expiresAt when deciding whether queued investigation fixes still need
operator attention.
Patrol intelligence seed context should also prefer the canonical
unified-resource timeline before falling back to the patrol-local change
detector so recent-change context stays aligned with the resource timeline
that powers the shared resource API.
Patrol-owned intelligence summaries should keep their recent-change counts
backed by the same canonical timeline when available instead of only counting
Patrol-local detector history.
The Patrol-backed /api/ai/intelligence/changes endpoint should also read
through the canonical intelligence facade first and only fall back to the
local detector when the unified timeline is unavailable, so the API payload
stays aligned with the same governed recent-change source.
Patrol-owned resource and global intelligence prompt contexts should also
render the canonical recent changes section before any patrol-local change
detector fallback so the prompt surface stays aligned with the shared
unified-resource timeline.
When that detector fallback is used, the Patrol runtime must render recent
changes through the shared memory presentation helper so the same heading,
resource prefixing, and change labels are reused across the Patrol and AI
fallback paths.
memory.ChangeDetector.GetChangesSummary now also delegates to that shared
helper, so the detector-owned summary API and the Patrol fallback prompt path
stay aligned on the same markdown shape.
Those same Patrol-owned prompt contexts now also surface a canonical
relationship section from unified-resource relationships, so edge labels,
directionality, and provenance stay aligned with the shared relationship model
instead of being reconstructed locally.
That relationship section is now rendered by the shared
internal/unifiedresources.FormatResourceRelationshipContext helper, so the
Patrol runtime only resolves the canonical relationship context rather than
formatting the relationship section itself.
Patrol-owned correlation context now also comes through the shared AI
intelligence facade before reaching the detector, so the learned correlation
surface is routed through the same canonical AI ownership boundary as recent
changes and relationship data instead of being pulled from the detector
directly in each caller.
The Patrol seed context and AI runtime prompt path now also share the same
correlation summary formatter from internal/ai/correlation, so learned-edge
wording and confidence/count annotations stay canonical across the prompt
surface instead of being rebuilt in each caller.
The Patrol page reads the canonical intelligence summary through the governed
AI client and store but renders no intelligence summary card: it passes that
summary's overall health to the Patrol findings panel, while recent changes,
learned correlations, and the broader learning counters stay off the page, so
the page does not present telemetry-style counts as a headline intelligence
story.
The shared AI summary payload also carries the canonical data-governance
posture snapshot that the runtime derives from unified resources, but the
Patrol page does not render its sensitivity, routing, and redaction
distribution; the posture rule below governs any return of those counts.
The resource drawer now carries canonical dependency and dependent
correlation context plus canonical correlation evidence through the
resource-intelligence payload, so the resource-level AI card can surface
relationship reachability and learned edge patterns directly from the AI
contract instead of inventing a second correlation summary.
The Patrol page renders no learned correlations or recent changes. The
resource drawer renders its resource-scoped correlations from the
resource-intelligence payload through the shared
frontend-modern/src/components/Infrastructure/ResourceCorrelationSummary.tsx
card and its latest canonical change through the shared
frontend-modern/src/components/Infrastructure/ResourceChangeSummary.tsx
card. Those cards own correlation ordering and truncation and the change
summary's layout and relative-time wording, so a caller of either card, Patrol
included, hands it raw lists instead of slicing or re-sorting them first. The
drawer's full Change history timeline is a separate list that sorts and
renders its own rows through the shared resourceChangePresentation.ts
helpers.
Patrol trial-entry surfaces are retired for normal self-hosted v6 GA.
ApprovalSection.tsx and usePatrolIntelligenceState.ts may link to explicit
plan, activation, recovery, support, or hosted handoff surfaces where
presentation policy allows, but they must not reintroduce local
startProTrial() status-code branches or trial-specific denial copy.
Pending Patrol fix approvals now also require a canonical urgency order across
the store and Patrol approval surfaces. frontend-modern/src/stores/aiIntelligence.ts,
frontend-modern/src/components/patrol/ApprovalBanner.tsx, and dashboard
approval consumers must treat the approval queue as soonest expiry first,
then higher risk, then older request time, rather than inheriting raw API
order. Approval-linked findings must follow that same ordering so multi-approval
Review actions jump to the most urgent finding instead of an arbitrary one.
Malformed or missing approval expiry timestamps must fail closed in the shared
approval-state utility: they are not live/actionable pending approvals and the
owning finding must return to the needs-attention path. If malformed approval
records still reach presentation helpers, they must sort after valid timestamps
and must not produce non-deterministic comparator results. Patrol approval
banners must apply the same fail-closed timestamp posture to visible countdown
copy instead of rendering invalid math such as NaN. The banner is a
contextual handoff, not a second decision surface: one pending approval
deep-links to the exact typed action when its canonical action id is present,
while multiple or legacy approvals lead to the open Actions inbox. It must not
approve, reject, or execute an action inside Patrol.
Patrol fix approvals also inherit the unified action-governance preflight
contract: queued fixes must keep their plan-level dry-run availability, safety
checks, verification steps, approval policy, and action id in the shared
approval/action-audit model instead of storing Patrol-only execution context.
The investigation approval adapter must seed the unified action-audit store
with planned and pending lifecycle evidence when it creates the approval, so
Assistant handoffs and resource timelines can hydrate the same canonical
action record before any operator decision or execution occurs. Those queued
fix records must carry pulse_patrol as the requester and lifecycle actor so
resource timelines preserve the product source of the proposal instead of
flattening proactive Patrol work into generic Assistant chat activity. Rejected
Patrol fix approvals must remain first-class Patrol outcomes: the backend
denial path records the shared action-audit decision, marks the owning finding
fix_rejected, and the Patrol control loop counts that state as a governed
action rejection while keeping approved-action verification separate. Pending
approval payloads and Patrol Assistant handoff actions must carry the same
requester identity as safe metadata, without copying the approval command
payload into Assistant.
That same store now owns the Patrol dashboard load bundle as well, so the
page refresh path stays aligned on a single orchestrated AI bundle instead of
repeating the individual summary, findings, and approval fetches inline.
Neither that bundle nor the Patrol refresh path fetches the global
learned-correlation list: the Patrol page renders no correlations, so
the store holds no copy of that list. Nor do they fetch the provider
circuit-breaker status: an open breaker already reaches the page as the
circuit_open Patrol runtime block on /api/ai/patrol/status, so the store
holds no separate breaker state.
The shared
frontend-modern/src/components/Infrastructure/ResourceChangeSummary.tsx and
frontend-modern/src/components/Infrastructure/ResourceCorrelationSummary.tsx
cards carry no resource-link default since the cross-resource drilldown links
were retired, so they render resource labels as plain text. A surface that
needs resource links passes buildResourceHref to the shared card instead of
rebuilding a local card wrapper.
The Patrol intelligence page renders no data-governance posture counts: they
left the page with its supporting-context block, and the shared posture card
that rendered them has been removed. If Patrol shows posture counts again, it
must render them through one shared unified-resource component instead of a
Patrol-local count loop, and the resource drawer keeps only per-resource
policy lines.
The Patrol page keeps health and findings primary and offers no recent-change
or learned-correlation inspector: its on-demand Details context block left
with the supporting-context section, so those expansion-lane concepts stay in
the resource drawer and backend investigation instead of reading as the
headline Patrol product story.
Patrol also derives no recent-change, correlation, or governed-resource count
summary. If such a summary returns, the payload-to-summary derivation belongs
in frontend-modern/src/features/patrol/patrolInvestigationContextModel.ts,
and the Patrol hook must not rebuild that count copy inline.
The Patrol page's run-history tab label is now also tightened to Runs, while
the underlying run-history panel remains canonical for run-record review,
internal finding_ids scoping, and tool-call inspection. That copy change is
intentional: run history is support context for Patrol findings, not a peer
primary workflow beside findings, and visible copy should frame selected runs
as Patrol records rather than snapshot filters.
Within that same run-history surface, coverage copy must stay canonical across
the header chips, narrative summary, and selected-run record. Scoped runs
must not present scope size and checked-resource count as contradictory
independent facts; the shared run presenter should collapse them into one
coverage statement such as Checked 1 of 2 scoped resources, and zero-coverage
scoped runs should fail closed as Checked 0 of N scoped resources rather
than drifting back to a scope-only headline.
That same normalization applies to supporting effort strips inside the expanded
run card. Once the run presenter is already carrying canonical coverage copy,
secondary chips must not reintroduce a raw Scoped to N resources variant that
re-opens the same ambiguity.
That same zero-coverage rule also applies to the expanded narrative sentence.
When Patrol checked none of a known scoped set, the run summary must still say
Checked 0 of N scoped resources rather than reverting to a generic Patrol completed sentence that hides the failed coverage.
The resource drawer formats recent changes through the canonical
frontend-modern/src/utils/resourceChangePresentation.ts formatter, and any
Patrol surface that shows recent changes must use the same formatter, so
recent-change kind and headline wording stays aligned wherever the canonical
timeline is surfaced.
If Patrol renders recent changes or attaches them to an Assistant handoff, it
must first apply a bounded explanation-layer normalization so same-state
timeline records describe the changed substate, such as Docker image status or
command posture, instead of surfacing no-op wording like an online to
online transition.
Canonical relationship semantics stay in the backend correlation path. The
Patrol page renders no relationships; the resource drawer presents them in its
Relationship map through the shared ResourceCorrelationSummary.tsx card
and frontend-modern/src/utils/resourceCorrelationPresentation.ts helpers
rather than a drawer-local relationship formatter.
The backend Patrol and AI runtime summaries now also share
internal/unifiedresources/change_presentation.go for the canonical
change-kind and provenance mapping, so the same resource-model semantics
drive both the backend summaries and the frontend presentation helpers.
That same helper now also owns the one-line recent-change summary text used
by the AI runtime prompt sections and Patrol seed context, so the change
wording itself stays canonical before the surrounding section headers are
applied.
The same helper now also owns the canonical recent-change section wrapper,
so the AI runtime prompt sections, including the Patrol intelligence context
and Assistant handoff resource timelines, share the same heading and resource
prefix rules instead of rebuilding that section locally.
The canonical shared AI resource context now also surfaces policy routing and
redaction hints from unified resources, so the runtime's export boundaries and
the resource drawer's governance rows read the same unified-resource policy
posture; the Patrol page renders no posture.
Patrol finding dismissal reasons and Patrol status labels now also route
through the shared frontend identifier-label helper, so the Patrol surfaces
do not keep their own underscore-stripping behavior separate from the rest
of the governed presentation helpers.
That same Patrol findings surface must also stop being a route dead end.
Expanded finding rows should resolve the backing unified resource and surface
canonical Infrastructure, Workloads, Storage, and Recovery handoffs
through frontend-modern/src/routing/resourceLinks.ts where those surfaces
exist, rather than forcing operators to pivot manually through search or
assistant prompts to continue investigating API-backed platforms such as
TrueNAS.
Patrol upgrade posture now follows the same runtime-versus-commercial split as
the rest of the app. Patrol runtime availability must stay on the
non-commercial capability store, while any paid handoff uses explicit plan,
activation, recovery, support, or hosted surfaces governed by presentation
policy. Patrol surfaces must not recombine those contracts into one entitlement
payload or revive trial-start selectors in leaf components.
Patrol findings presentation now also keeps runtime identity and action routing
on shared helpers. Findings shells may link or format from feature-owned
presentation helpers, but Patrol runtime severity, title cleanup, and primary
settings actions must stay keyed to the canonical Patrol service identity
instead of reimplementing those branches in links-only or leaf badge surfaces.
Finding dismissal reasons now carry distinct operational semantics, not just
copy variants. not_an_issue permanently suppresses (Suppressed=true);
expected_behavior acknowledges the finding forever without escalation;
will_fix_later is a real operational commitment — FindingsStore.Dismiss
populates Finding.RemindAt (default DefaultWillFixLaterRemindAfter, 7
days), and the next re-detection after RemindAt clears the dismissal and
records a reminded lifecycle event so the operator sees their commitment
lapsed instead of the finding being silently swallowed forever. Severity
escalation still wakes any dismissed finding regardless of reason. The
dismiss_finding LLM tool response surfaces the remind-at date in plain
language so Patrol's own conversational explanations stay aligned with this
contract.
Patrol's findings panel must also surface that commitment to operators on
the canonical Patrol surface, not only inside the LLM tool response. The
inline dismiss confirmation must preview the will_fix_later remind-at
deadline before the operator confirms (and explain the
expected_behavior and not_an_issue paths so all three feel
deliberate), and dismissed-as-will_fix_later rows must show the pending
Reminding <date> badge in an amber tone so the operator can see their
own commitment without expanding the row. The store-level
UnifiedFinding.remindAt field is the canonical source for both
surfaces; render code reads it from the store, the store normalizer
promotes it from remind_at on both the unified and patrol-direct
fetch paths.
That same dismiss confirmation must also surface a non-blocking
recurrence hint when the operator is about to dismiss a finding with
regressionCount > 1 as not_an_issue or expected_behavior (the two
"stay quiet forever" reasons). The hint must nudge the operator toward
the reminder-bearing will_fix_later path without blocking the dismiss,
and must NOT appear for will_fix_later itself or for findings with no
prior regression. This is the operator-facing half of "Pulse learns from
operator dismissal patterns" — a recurring issue should not be silently
buried just because the operator is moving fast on triage.
The collapsed finding row must also surface regressionCount as a small
pill next to the investigation-confidence badge whenever
regressionCount > 0, so a triaging operator scanning the list can spot
"this is not a one-off" without expanding each card. The pill stays
absent on fresh detections (count == 0) so the row stays clean for
ordinary findings, and the styling (amber tone) reads as a recurrence
signal rather than a generic muted note.
The Patrol surface must also expose a manual "Mark resolved" action on
active findings, calling the canonical /api/ai/patrol/resolve endpoint
through aiIntelligenceStore.resolveFinding. This closes the loop when
the operator has fixed the underlying issue out-of-band and shouldn't
have to wait for Pulse's auto-detection to clear it. The action is gated
to status === 'active' (the server rejects double-resolves) and is
visually distinct (emerald accent) from the destructive dismiss
controls; it must route through the shared store action so the refresh
and error UX stays uniform with acknowledge, snooze, and dismiss.
That same surface must also attribute closures honestly using the
autoResolved flag now plumbed through UnifiedFinding. Resolution
copy reads "Resolved by you
The investigation runtime hands the orchestrator a finding
pre-enriched with the operator-set state and operational memory it
needs to reason from. The aicontracts.Finding shape carries an
optional OperatorContext (intentionally offline, never
auto-remediate, maintenance window) and an OperationalMemory
projection (regression count, previous resolved fix summary, times
raised); MaybeInvestigateFinding populates both from the
in-process findings store and the operator-state provider before
calling the orchestrator. This is the data path that converts
"Pulse holds privileged context" into "Pulse uses privileged
context" — the orchestrator (in pulse-pro) reads the fields when
formatting its system prompt, so investigations on locked or
under-maintenance resources reason from the operator's
commitments instead of contradicting them.
The findings store also consumes per-resource operator-set state via
the narrow ResourceOperatorStateProvider interface installed by
SetResourceOperatorStateProvider. The API layer wires an adapter
that projects unified.ResourceOperatorState into a
ResourceOperatorStateProjection so internal/ai does not need to
import internal/unifiedresources. The projection returns every
operator-set signal in one call (maintenance window + the
IntentionallyOffline flag), and the new-finding path branches on
both: maintenance window suppression takes priority and emits
operator_state_cause: maintenance_window plus the
maintenance_end_at metadata; the IntentionallyOffline branch is
the indefinite fallback that emits operator_state_cause: intentionally_offline with no end-at field because the suppression
has no scheduled end. That branch, like canonical expected_offline,
silences only availability findings (the shared down condition class);
capacity, performance, backup, security, and disk-health findings on the
resource stay visible, matching the alert runtime. Only muted, retired
lifecycle, and active maintenance silence every finding. Both branches set DismissedReason = expected_behavior and write a UserNote naming the cause so the
operator can audit why future findings stayed quiet without
expanding each row. Default deployments without a provider behave
identically to before — operator-state suppression is opt-in.
The auto-dismiss is reversible. When a finding previously
auto-dismissed under operator_state_cause re-detects after the
suppression has lifted (maintenance window passed,
IntentionallyOffline cleared, or provider unwired), the
new-finding path wakes it with a suppression_lifted lifecycle
event carrying the previous cause.
The operator-facing FindingsPanel must also distinguish
auto-suppressed dismissals from manual operator dismissals on the
row. Both serialize as DismissedReason="expected_behavior", but
the auto-dismiss carries operator_state_cause lifecycle metadata.
A parallel "auto: maintenance" / "auto: intentionally offline"
badge sits next to the existing dismissed-reason badge so the
operator sees who closed the loop — Pulse on their behalf vs their
own decision. The badge routes through the canonical
getOperatorStateDismissCause and
formatOperatorStateDismissCauseLabel helpers; the lifecycle scan
mirrors the Go-side helper's newest-first contract so a manual
dismissal that supersedes an earlier auto-dismiss is reported as
manual. Time-bounded operator
commitments do not silently turn into permanent dismissals; manual
operator dismissals (no operator_state_cause metadata) are
unaffected by this wake path because the helper that detects the
cause stops at the first dismissed event when scanning newest
first, treating that as the authoritative state.
Patrol control may receive a starter count from the canonical operations-loop
status projection through patrolAutonomy* compatibility fields, with the
legacy entry-point starter count treated as the same entry-point context
when the primary field is absent. That count is only
journey copy; Patrol must still require active finding, pending approval,
governed action, or verified outcome evidence before it marks the Patrol issue
step complete or opens the Assistant handoff as a completed loop stage. Current
active findings and pending approvals must keep the journey on current work even
when older completed/resolved proof is present. The
projection may also report Patrol control completed-loop and resolved-loop
counts through compatibility fields, with legacy Pro activation counts as fallback aliases. Patrol may use
the completed-loop count only as content-free terminal decision detail after
the loop already has Patrol issue evidence, contextual collaboration, and
either a rejected governed decision or an approved governed decision with
verified outcome evidence. Patrol may use the resolved-loop count only as
stricter approved-and-verified detail after the loop also has an approved
governed decision and verified outcome evidence.
The typed ActionReference is the primary Patrol workflow model in both the
finding row and expanded action summary. Pending actions identify required
review; planned or approved actions identify runnable work; executing actions
say running; terminal actions present verified, failed, or honestly
inconclusive verification. Patrol owns that detection and investigation
context, while the dedicated Actions route is the canonical operator hub for
decision, execution, progress, and durable outcome history. The expanded
ApprovalSection renders the bounded plan, preflight, safety checks,
verification steps, and rollback availability, then deep-links by exact action
id into the shared Actions review. It must not call /api/actions decision or
execute mutations itself. Legacy ProposedFix and
ApprovalID data may explain historical records but must never reveal a raw
command, present an approve/run control, or reconstruct an executable action;
when the typed reference is absent the UI says action details are unavailable
and offers an Assistant handoff. Collapsed-row attention state must consult the
same investigation action reference, so it cannot claim there is no approval
while the expanded panel has one. Browser proof must exercise pending,
terminal-verified, and legacy-history states rather than judging only source.
The typed reference must retain the exact reviewed planHash so Patrol can
surface missing identity as an explicit replan-required state before handing
off. The Actions review remains the only browser surface that may expose
approve, reject, or run controls, and every mutation there passes the same
displayed hash through the canonical browser client; missing identity never
falls back to action id alone.
Backend Patrol finding reconciliation now reads ActionResultV2: execution
failed or known-not-run maps to fix failure; confirmed verification maps to
verified; contradicted verification maps to verification failure; and
not-attempted or inconclusive verification remains verification unknown. A
successful execution never overwrites contradictory verification. Task 11
still owns browser wording and proof for the distinct terminal states.
Docker/Podman Patrol remediation must have a production post-action observer,
not only a qualification-lab injection. The canonical action executor issues a
separate versioned, action-bound daemon observation after the typed mutation
receipt. Only fresh independent daemon evidence may advance the originating
investigation and finding to fix_verified; older agents, observation errors,
stale snapshots, digest or subject mismatch, and same-agent receipt evidence
remain verification unknown. This closes the prior structural dead end where
an unhealthy-container restart could execute in production but the executor
had no observer capable of satisfying Patrol's verified-outcome contract.
Running state alone is not recovery evidence for a container-health finding.
The version-2 observer must explicitly report healthy, or none when the
daemon confirms no health check exists; starting, unhealthy, omitted
health, and legacy protocol versions cannot advance the finding to
fix_verified. The agent may wait for a health transition within the bounded
action timeout, but it must never repeat the mutation while waiting.
Patrol now consumes the server-derived effective Autopilot mode. Requested
full is admitted only with a current persisted human acknowledgement and
exact activation for the same actor credential and organization; legacy
booleans, revocation, expiry, version rotation, and malformed evidence fall
back to approval mode before policy-authorized action submission. The accepted
limits explicitly allow inconclusive verification and never turn execution
success into outcome truth. Task 11 still owns acknowledgement presentation,
cancel/no-submit browser proof, and device coverage; M7 remains open until that
work and Task 12 certification are complete.
APT Patrol findings preserve the backend-owned finding key through the
canonical frontend store. Presentation recognizes only the exact bounded update
or cleanup observation envelope, validates non-negative safe integer counts,
finite 0..100 filesystem usage, and valid agent-observed/server-received
timestamps, and suppresses inventory hashes and fingerprints from the default
monitoring view. Invalid evidence fails closed to a refresh-before-acting
message. A reboot-required observation explicitly says that neither the finding
nor its action authorizes a reboot. Contradicted, inconclusive, or health-unknown
postconditions remain actionable; only canonical confirmed postcondition truth
may support resolution. Package-manager internals remain forensic detail rather
than the least-expert default.
Operational Trust attention queue completion
Patrol is the named monitor-first attention destination over one canonical operational lifecycle. Active, open, acknowledged, suppressed, stale/unknown, resolved, unavailable-evaluation, and honest calm states share one summary and detail projection. The selected detail owns reversible acknowledgement and bounded reasoned suppression, while Assistant remains explanation-only selected context. Evidence, impact, relationships, protection posture, lifecycle timeline, action origin, and verification truth remain linked to the same record. Mobile consumes the same list/detail and acknowledgement contracts; it does not revive the retired primary findings feed.
Accepted-run browser ownership
usePatrolIntelligenceState.ts treats a successful unscoped start response as
an accepted backend run identified by run_id, not as a request that remains
Starting until the first provider event. It schedules one reconciliation after
15 seconds, bounds the parallel status and history reads to 5 seconds, and
accepts either a matching running status or the matching durable run record as
authoritative. A provider/runtime error record remains a completed accepted run
outcome. Missing data, refresh failure, backend rejection, and browser/network
failure remain separate states and copy.
Autonomy writes use the complementary authoritative-read rule. A successful
PUT /api/ai/patrol/autonomy may be only a compact paid-runtime
acknowledgement, so usePatrolIntelligenceState.ts always reloads
GET /api/ai/patrol/autonomy before updating visible control state. The page
must not read optional nested autonomy fields from the write response or claim
Autopilot is active before the server-derived effective mode is loaded.
Reconciliation is generation-aware and cancellable. Route changes, retries, or superseding starts cancel the old timer; stale completions cannot overwrite the current run, and reconciliation never starts a replacement provider call. Patrol state may present investigation and proposed-action context, but all customer-infrastructure mutations remain exclusively in the canonical Actions review and lifecycle.
frontend-modern/src/features/patrol/__tests__/patrolRunAcceptance.test.ts
proves 0/15/30/60-second provider-event timing, recorded failures, bounded hung
reads, cancellation, and clean retry.
frontend-modern/src/features/patrol/__tests__/usePatrolIntelligenceState.test.ts
and frontend-modern/src/pages/__tests__/AIIntelligence.test.tsx prove typed
start-failure presentation and the accepted-run page transition.
Resource monitoring policy is actionable where noise appears
The resource drawer replaces the overloaded intentionally-offline toggle with canonical Monitoring and Lifecycle selectors. Normal, expected-offline, muted, active, and retired copy states their exact Alerts, Patrol, inventory, and automation effects. Provider-aware retirement copy makes clear that Proxmox, Kubernetes, vSphere, and container-runtime inventory is not deleted by a Pulse policy change and that the resource can be restored to active monitoring.
Active alert cards expose the same canonical policy through a compact
Monitoring action. It reads the current resource state, preserves maintenance,
criticality, notes, remediation settings, and capability allowlists, then
writes through @/api/resourceOperatorState; no alert-local mute document is
created. ResourceMonitoringPolicyAction.test.tsx and the resource operator
state section tests pin provider copy, expected-offline persistence, retirement,
and compatibility preservation.
Lasting decisions live on the attention detail
Two users in a row (discussions #1623 and #1699) could not find the durable
Patrol outcomes because they sat two levels below the Needs attention detail.
The selected detail in PatrolAttentionWorkbench.tsx now owns a Lasting decisions section beside the alert lifecycle controls. When a Patrol finding
mirrors the selected alert (backend-stamped mirrorsAlertId equal to the
item's operational record ID, joined by getLinkedPatrolFindings in
patrolHomePresentation.ts over the surface-supplied findings accessor;
before 24 October 2026 the join was resource plus kind, which cannot tell
apart two filesystem alerts on one host),
the section lists Remember as expected, Dismiss: Not an issue, Dismiss: Later,
and Create rule, each with one line stating what it does and how long it lasts
(PATROL_LASTING_DECISIONS). Choosing one opens an inline confirmation with an
optional note, or a required reason for a rule, and writes through the existing
finding actions (aiIntelligenceStore.dismissFinding,
createSuppressionRuleFromFinding); the alert lifecycle above is untouched.
A finding Patrol already remembers shows the remembered decision and a Reopen
path instead of re-offering the choice; to make that possible
usePatrolIntelligenceState.ts loads Patrol findings with dismissed and
resolved history included, because a dismissed finding is absent from the
active-only default set and the detail would otherwise claim Patrol has
nothing to remember. An alert with no mirrored finding says
plainly that Patrol has nothing to remember and points at alert thresholds,
because the only durable control for a bare alert is the alert configuration.
When Patrol has open findings on the same resource that do not restate the
alert (getPatrolFindingsOnSubject: active findings on the item's subject,
the list "Browse Patrol findings for this resource" opens), the guidance names
the finding (or the count) and says Patrol keeps it separate from the alert,
so the decision is made on the finding; it no longer claims Patrol has raised
nothing. The browse button appears only when that list is non-empty, so it
never opens an empty scope. The join works because the attention item's
subject is the unified resource ID findings carry (see ai-runtime, 24 October
2026); before, a Docker container alert's raw docker:<host>/<container>
reference scoped the list to nothing and the detail denied a finding Patrol
had raised on that container.
The scope carries the resource's name with its ID, and nothing above the
scoped list counts another resource's work: the Open work description names
the resource and counts its open findings (Patrol found 2 issues on <name>,
the rows the Active filter shows), the work groups count its approvals, failed
actions and recurring issues, and the findings filter's Needs Attention,
Approvals and Overdue chips each count that resource's findings in their own
subset. The approval banner shows only the approvals for the resource's
findings, so one about to expire keeps its countdown in the scope. The latest
check's health and coverage-stale groups describe every resource, so they stay
in the unscoped queue, and the page header keeps the last check. Before
24 October 2026 the scoped list sat under the whole queue's summary and
groups, so two rows read as 3 issues on 2 affected resources. Proof:
PatrolIntelligenceWorkspace.resourceScope.test.tsx, the
FindingsPanel resource scope cases in FindingsPanel.links.test.tsx,
ApprovalBanner.test.tsx and patrolControlPresentation.test.ts.
The temporary controls state in one visible line that acknowledgement and
suppression are short-term; the former More ways to manage this issue
disclosure is gone.
Flapping is one item, not many. Queue rows and the detail show the backend
flapping label with the transition count; the detail timeline renders a
one-line flapping summary and keeps every transition under Show all N transitions. FindingsPanel.tsx shows the same label on findings and demotes
active findings that mirror an active alert (isAlertMirroredFinding in
frontend-modern/src/utils/findingAlertIdentity.ts) into a collapsed N findings mirror an active alert group below the list, where their finding
options and investigation review remain available; dismissed and resolved views
keep them in place. Review selection resolves the canonical filtered findings,
including mirrors, independently of visual grouping. A completed investigation
with an uncertain diagnosis remains unresolved and keeps failed access evidence
visible in its transcript and the linked Assistant context. The rendered
selection regression lives in FindingsPanel.links.test.tsx; the desktop,
intermediate and narrow linked journey is exercised by
scripts/check-patrol-assistant-journey.mjs.
PatrolAttentionWorkbench.test.tsx pins the four decisions and their copy, the
rule reason requirement, the remembered-decision path, the alert-only
guidance with and without unlinked findings on the resource, and the flapping
collapse.
Open resource goes to the page that shows the resource
The attention detail's Open resource link sent every subject to
/standalone/machines?resource=, which lists only standalone agent hosts and
does not read ?resource=, so Docker, Proxmox, vSphere, TrueNAS and
Mail Gateway decisions opened a page without their resource. The workbench
now resolves subjectResourceId through ResourceAPI.getResource and builds
the link with buildResourcePagePath
(frontend-modern/src/features/platformNavigation/resourcePagePath.ts): the
platform comes from the registry resource's own platform evidence, or, while
that lookup runs or when the registry cannot resolve the record, from the
item's subjectResourceType hint in the alert display vocabulary. The page
then selects the resource where it can (?resource= on Proxmox and vSphere
workloads and Proxmox storage, the owning storage for <storage>/zfs-pool:...
records), filters by name where that is the page's only selection (Docker
containers, Kubernetes, Machines, Proxmox physical disks), and otherwise opens
the owning tab. A subject that names no platform hides the link rather than
opening a page without it (resourcePagePath.test.ts,
PatrolAttentionWorkbench.test.tsx).
Registry lookups for page links share one hook
The attention detail resolves subjectResourceId through
useResolvedResource, the abortable registry lookup the action review also
uses, so an answer for an earlier item is never applied to the current one
(useResolvedResource.test.ts). Open resource and the alert-only
thresholds link read the same resolved resource as before.
Alert-only guidance links to the subject's thresholds
A decision about a bare alert tells the operator to adjust when the alert
fires or turn it off under alert thresholds. Its Adjust alert thresholds
link used to open /alerts/thresholds, the top of the Proxmox tab, whatever
the subject was. The workbench now builds it with
buildResourceThresholdsPath
(frontend-modern/src/features/platformNavigation/resourcePagePath.ts) from
the same resolved subject as Open resource: the platform picks the
thresholds tab (standalone agents open Systems) and the resource's display
label, the one its thresholds row is built from, fills the thresholds search. A composed label such as Disk (node) and a physical
disk, which has no thresholds row of its own, open the tab unsearched rather
than a search that hides every row (resourcePagePath.test.ts,
PatrolAttentionWorkbench.test.tsx).
A used-up cost budget pauses Patrol visibly
Patrol distinguishes "Pulse declined to spend" from "the provider failed".
A 30-day budget refusal is the ErrCostBudgetExceeded sentinel with the
spent and limit figures, classified as the budget_exhausted failure cause,
never counted against the provider circuit breaker, and promoted into the
runtime block state so /api/ai/patrol/status reports blocked with a
blocked_reason that names the spend, the limit, and where to fix it. The
Patrol page's paused banner, header run control, and setup card resolve
their action from the block cause before the readiness cause, so an exhausted
budget lands on "Raise the cost budget" (Provider & Models) instead of the
model check, and the setup card subtitle says the pause is about spending,
not a failed tool check. patrolRuntimeActions.test.ts,
usePatrolIntelligenceState.test.ts, PatrolIntelligenceHeader.test.ts,
patrolControlPresentation.test.ts, and the internal/ai projection tests
pin those distinctions (issue #1789). The failure cause is persisted with the
finding and carried onto the unified finding as failureCause, and a provider
preflight success no longer clears a budget-exhausted runtime finding, so the
setup card still routes to the budget after a restart clears the in-memory
block state.
The paused banner's Blocked ... age reads the frontend-primitives shared
relative-time clock: each status re-read returns the same blocked_at while
Patrol stays paused, so the banner kept the age it had when Patrol first
paused. The selected run's Patrol run ... banner reads the clock for the same
reason, since the selected run stays as picked when run history is re-read. The
attention detail is read once per selection, so its fixed event times (the
acknowledgement, each timeline transition, each evidence observation) read the
clock while it stays open. Its Last seen and flapping window are latest
readings of a record that may have moved since, so they stay the ages at
read time, and the queue rows, summary, recent work, run history and digest
re-derive on their own 30- or 60-second re-reads.
Future times in Patrol count down instead of reading as ages, because the
past-only formatRelativeTime reads each of them as "just now" for their whole
duration. The attention detail's suppression line counts down to the expiry
with the exact time on hover and names the state expiry restores in the
early-end control's words, from the same
getAttentionSuppressionEndPresentation split on
operationalRecord.acknowledgement: an open issue reads Returns to active attention in 1d., one marked reviewed reads Suppression ends in 1d. It stays reviewed. (expiry restores Acknowledged, which is not active attention), and a
passed expiry reads Suppression has ended.
(getAttentionSuppressionExpiryLabel). The findings list reads Reminding in 6d for a will_fix_later reminder and snoozed, returns in 3h for a snooze,
both through formatTimeUntil on the shared clock with the exact time on
hover. A reminder reads Reminder overdue once the panel's overdue id list
holds it. That list is sampled on the shared clock and is what the Overdue
commitments chip and filter count, so the label, chip and filter agree: a row
mounted or re-read between the deadline and the tick that adds it reads
Reminder due, and a row already on screen keeps its last countdown until that
tick. The list only notifies when its ids change, so a clock tick that moves no
deadline past now does not rebuild the open Overdue rows. The hourly reminder
sweep then brings the finding back whether or not it still trips. An ended
snooze reads snooze ended until the next findings re-read drops the snoozed
status: GET /api/ai/patrol/findings sends no status, so the frontend
aiIntelligence store (normalizeFindingStatus) derives snoozed on each
read only while snoozed_until is ahead, and the finding then shows as Active
unless it has since resolved or been dismissed.
getFindingReminderPresentation and getFindingSnoozePresentation in
aiFindingPresentation.ts own the findings copy.
PatrolAttentionWorkbench.test.tsx, FindingsPanel.links.test.tsx and
FindingsPanel.test.ts pin it.
This week card answers what Patrol did for the customer
The Activity tab leads with PatrolWeeklyDigestCard ("This week"), rendered
above Verified outcomes and never inside the Inbox decision surface. It shows
six tiles in plain customer language: Patrol runs, New issues, Issues resolved,
Investigated, Fixes run, and Estimated spend, with the effective Patrol mode
sentence underneath, and it links to /actions only when Patrol-origin fixes
are waiting for approval. The card reads GET /api/ai/patrol/digest and must
not recompute counts from findings or run history client-side. Forensic
vocabulary (evidence classes, verdicts, model names, tool traces) stays out of
the card and remains in run history and the Actions audit. Empty history
renders "Patrol has not run in the last N days"; a truncated history says
"Since (older runs are no longer kept)"; a failed load says the summary
is unavailable rather than showing zeros. Proofs:
frontend-modern/src/features/patrol/__tests__/PatrolWeeklyDigestCard.test.tsx,
frontend-modern/src/features/patrol/__tests__/PatrolIntelligenceSurface.test.tsx,
frontend-modern/src/pages/__tests__/AIIntelligence.test.tsx (card ordering),
and the browser receipt in frontend-modern/browser-verification.json.
Issue explanation follows the customer-journey qualification boundary, which separates scripted interaction proof from provider reasoning, remediation and repeatable customer outcomes.
Unclassified and interrupted investigations (23 October 2026)
The Patrol page presents the two outcomes the backend records since
rcourtman/Pulse#3129 instead of dropping them as unknown.
frontend-modern/src/stores/aiIntelligence.ts keys the outcomes it accepts by
the InvestigationOutcome union in frontend-modern/src/api/patrol.ts, which
frontend-modern/src/api/ai.ts now reuses, so a value the union gains fails
type-check until the store accepts it.
unclassified, a finished run with no readable conclusion, reads "No clear
conclusion" in the warning tone. It joins the Needs Attention queue and sorts
beside needs_attention, keeps Re-investigate, and its workflow step asks the
operator to read the summary. interrupted, a run a restart or shutdown cut
short, reads "Interrupted — will retry" in the neutral tone. It stays out of
the attention queue, its collapsed row says "Will retry" rather than "Needs
review", and its run note renders as information, not as an error. Neither
counts as a failed fix. The This week card names both with the digest email's
wording and order, along with the digest's failed bucket for a run that
ended on an error with no outcome ("ended with an error"). When a week's
investigations have no worded outcome, the Investigated tile shows the count
alone: "No issues needed a closer look" and the watch-only sentence are kept
for a week with no investigations. The Patrol record's outcome badge uses the
shared outcome label, and like the investigation header the record shows its
run status only until the run has an outcome, so an interrupted run no longer
shows "Failed" beside "will retry". Proofs:
frontend-modern/src/stores/__tests__/aiIntelligence.test.ts,
frontend-modern/src/components/patrol/__tests__/InvestigationSection.test.tsx,
frontend-modern/src/features/patrol/__tests__/patrolInvestigationContextModel.test.ts
and frontend-modern/src/features/patrol/__tests__/PatrolWeeklyDigestCard.test.tsx.
Expired action continuity (2026-09-07)
An expired, unexecuted canonical action maps the investigation outcome to
needs_attention. It creates no recovery verification evidence. The durable
finding record and investigation retain the expired action identity and
original model evidence. Findings and the inline action history render a linked
action from that identity independently of the outcome vocabulary. Changing
from queued to needs-attention must not hide its Actions link or Assistant
handoff. The attached Assistant context suppresses unrelated empty-chat
starters and recent sessions. Starting a new conversation clears that context
and restores the ordinary welcome surface. Regression and current-browser
qualification are recorded in the customer-journey qualification document.
Patrol stopped handing work to the browser Assistant on 2026-10-22, when the
chat window was retired. Finding cards, approval rows, run history, and the
attention workbench lost their "Discuss", "Explain with Assistant", and
"Ask Assistant" actions; the inline Investigate action (a Patrol
re-investigation) and the governed approval controls stay. Alert Investigate
now starts a targeted Patrol run, so alert follow-up lands on the Patrol page.
patrolInvestigationContextModel.ts shrank to the investigation-record
presentation that InvestigationSection uses, and the Patrol tool transcript
block moved to frontend-modern/src/components/patrol/ToolExecutionBlock.tsx.
Failed run with a planned fix (23 October 2026)
An investigation can persist a canonical action plan and then fail, normally
on the final summary call. The orchestrator (in pulse-pro) keeps the plan's
outcome, normally fix_queued, on the failed run instead of timed_out or
interrupted, so the retry gates leave the finding alone rather than plan the
same fix again, and it refuses a manual re-investigation while the latest
run's outcome is fix_queued (409 action_pending). The Investigation section
matches: it offers no Re-investigate while the outcome is fix_queued,
whatever the run status, and the failed run's note renders as information, as
for an interrupted run, because the queued fix is what the operator acts on.
Once core reconciles the plan's approval, rejection or expiry, the outcome
changes and the usual rules apply again. Proof:
frontend-modern/src/components/patrol/__tests__/InvestigationSection.test.tsx.
Finding reviews keep their place across refreshes (23 October 2026)
The app shell re-reads Patrol findings every 30 seconds and the Patrol page
every 60. Each read parsed new objects, so FindingsPanel rebuilt every row
and remounted an open finding review. The remounted review read its
investigation with createResource, and that read suspended the nearest
Suspense boundary, the app's route boundary. Its "Loading view..." fallback
replaced the whole page, so someone reading a review on the Activity tab was
thrown back to the top. The same happened on opening a review or its thread,
on Re-investigate, and on every 5-second poll of a running investigation.
Now:
aiIntelligenceStorekeeps the object of every finding a read returns unchanged, and keeps the list when nothing changed.FindingsPanelkeeps a display group while its findings are the same objects (reuseIdenticalPatrolFindingDisplayGroups). It settles sort ties by finding id, because the API returns tied findings in no fixed order and a Patrol run stamps one time on every finding it sees. The open review reads its related findings through a getter, so it is redrawn only when its own finding changes.InvestigationSection,ApprovalSectionandInvestigationMessagesread throughcreateNonSuspendingQuery. The last answer stays on screen while the next loads, and a remounted review shows the retained answer at once.RunToolCallTracemoves to the same query. It did not suspend before, but only because each of its reads checkedloadingfirst.- The remounts had also re-read the review every 30 seconds. The mounted
review now does that itself through the query's own poll, which never
replaces a slow read still in flight: the investigation and its governed
action re-read every 30 seconds, and the investigation every 5 seconds while
it runs (
pollMstakes an accessor for that). A failed read keeps the last answer instead of replacing it with "none"; only a 404 means the finding has no investigation. The thread belongs to its run's session id, so a new run reads its own thread and a re-read of the same run leaves it alone. It is read again every 5 seconds while the run is live, once more when the run finishes, and 30 seconds after a failed read; a message that comes back unchanged keeps its row, and any tool output expanded in it. Re-investigate stays hidden until the first read answers, because until then a running investigation or a queued fix looks like none. - Rebuilding rows on every refresh had also kept their ages current. Rows and the review now stay mounted, so their ages (last seen, acknowledged, last investigated, regressions, lifecycle, an investigation's start and its thread's messages) read the shared relative-time clock.
A change to the open finding itself still redraws the review, which closes
its thread, but the page does not move. Proofs:
frontend-modern/src/components/AI/__tests__/FindingsPanel.refresh.test.tsx,
frontend-modern/src/components/AI/__tests__/FindingsPanel.test.ts,
frontend-modern/src/stores/__tests__/aiIntelligence.test.ts,
frontend-modern/src/hooks/__tests__/createNonSuspendingQuery.test.tsx, and the
InvestigationSection, ApprovalSection, InvestigationMessages and
RunToolCallTrace tests under frontend-modern/src/components/patrol/__tests__/.