[READ] Report endpoints drifted from a per-field baseline (patch/agent/OS/profile).

Answers "which endpoints have drifted from the fleet?" With no baseline it derives one by fleet majority (the most common value per field is treated as intended), so it works before any gold image is declared. Pass 'endpoints' for pure analysis, or a target to pull live inventory.

Args: baseline: Field→intended-value map; omit to derive the fleet majority. fields: Inventory fields to check (default agentVersion, patchLevel, osBuild, profileId). endpoints: Injected inventory rows; skips live collection. target: Endpoint-management target name from config; omit for the default. limit: Max drifted endpoints to return (default 200).

Returns dict: {totalEndpoints, baselineSource, baseline, fieldsChecked, driftedCount, compliantCount, driftByField, driftedEndpoints:{items[], returned, limit, truncated}}. driftedCount is the full count; when driftedEndpoints.truncated is true, re-run with a higher limit.

Example: drift_report(endpoints=[{"hostname":"tc01","patchLevel":"2026-06"}, {"hostname":"tc02","patchLevel":"2026-05"}]).

[WRITE][risk=high] Assign a config profile to an endpoint (reversible).

Captures the prior profile before switching, so the harness records an undo (reassign the prior profile) and a faithful audit trail. Pass dry_run=True to preview: it resolves the same path and reads the same before-state as the real call, so it reports the profile that would actually be replaced and refuses on the same grounds the write would.

Args: endpoint_id: Endpoint id as returned by endpoint_list. profile_id: Config profile to assign. dry_run: If True, preview without assigning. target: Endpoint-management target name from config; omit for the default.

[READ] One managed endpoint by id, normalised to the stable shape.

Args: endpoint_id: Endpoint id (or uuid/mac) as returned by endpoint_list. target: Endpoint-management target name from config; omit for the default.

[READ] Composite per-endpoint health score (0-100), worst endpoints first.

Answers "which endpoints are worst?" by folding the fleet signals into one ranked view: it deducts points for each risk signal (offline, stale, patch-behind, agent-behind) and cites every deduction in the endpoint's 'reasons'. Pure analysis over injected inventory rows (the shape from endpoint_list) — no live connection is used. With no baseline, the patch and agent baselines are derived by fleet majority, so it works before a gold image is declared.

Args: endpoints: Injected inventory rows (id, hostname, online, lastSeenHours, agentVersion, patchLevel) to score. Required — no live pull. stale_hours: An endpoint whose lastSeenHours >= this is 'stale' (default 24). baseline: Intended {'agentVersion', 'patchLevel'}; omit to derive the fleet majority. limit: Max worst-first endpoints to return (default 50).

Returns dict: {endpointsEvaluated, baseline:{agentVersion, patchLevel, source}, summary:{healthy, degraded, critical}, worst:{items:[{endpoint, score, band, reasons[]} ...worst-first], returned, limit, truncated}, note}. The summary always counts the whole fleet; when worst.truncated is true, re-run with a higher limit to see further down the ranking.

Example: endpoint_health_score(endpoints=[ {"hostname":"tc01","online":True,"agentVersion":"12.6","patchLevel":"2026-06"}, {"hostname":"tc02","online":False,"agentVersion":"12.5","patchLevel":"2026-05"}]).

[READ] List all managed endpoints (id, hostname, OS, agent/patch, online).

Args: target: Endpoint-management target name from config; omit for the default.

[WRITE][risk=medium] Request an endpoint reboot (no safe inverse).

Records the endpoint's prior online state for the audit trail; a reboot cannot be undone, so no undo descriptor is offered. Pass dry_run=True to preview — for an operation with no inverse, knowing whether the endpoint is even online (and how long since it was last seen) before committing is the whole value of asking first.

Args: endpoint_id: Endpoint id as returned by endpoint_list. dry_run: If True, preview without rebooting. target: Endpoint-management target name from config; omit for the default.

[READ] Detect login storms + rank the slowest login/boot contributors.

Answers "is this a morning login storm, and which endpoints/users are dragging login and boot times?" Groups logins into storm episodes (>= min_concurrent within a window_s sliding window) and flags sessions slower than the thresholds — every flag is reported with its number, not a verdict. Pass 'sessions' for pure analysis, or a target to pull live via session_list.

Args: since_hours: Live look-back window when sessions is omitted (default 24). window_s: Sliding window that defines "concurrent" logins (default 300). min_concurrent: Logins within a window that constitute a storm (default 10). slow_login_ms: Login duration (ms) flagged as slow (default 30000). slow_boot_ms: Boot duration (ms) flagged as slow (default 90000). sessions: Injected session records — {endpoint, user, login_ms, boot_ms, timestamp (ISO-8601), result}; skips live collection. target: Endpoint-management target name from config; omit for the default. limit: Max rows in each returned list (default 25).

Returns dict: {totalSessions, sessionsReceived, inputTruncated, stormCount, storms:{items:[{start, end, count, peakConcurrent, spanS, distinctUsers, distinctEndpoints, avgLoginMs}], returned, limit, truncated}, slowLoginCount, slowestByLogin:{items[], ...}, slowestByBoot:{items[], ...}, failedLogins, thresholds}. Each list is a truncation envelope — when its 'truncated' is true, re-run with a higher limit; stormCount is the full episode count.

Example: login_storm_analysis(sessions=[{"endpoint":"tc01","user":"a", "login_ms":42000,"timestamp":"2026-07-12T08:00:00Z"}, ...]).

[READ] One-shot fleet health: online/offline, stale endpoints, version spread.

Call this first to triage a managed-endpoint fleet before drilling into a specific endpoint, login storm, or drift report.

Args: target: Endpoint-management target name from config; omit for the default.

[READ] Patch-compliance SLA measure: % of the fleet on the target patch level.

Reframes patch_status (the patch-level distribution) as an SLA/compliance verdict: what fraction of the fleet is on the target level, whether that meets the SLA, and which endpoints are non-compliant. Compliance is an exact string match on patchLevel — a transparent check, not a version-semantics parser. Injected-only: pass 'endpoints' (inventory rows); no live collection.

Args: endpoints: Injected inventory rows to evaluate (e.g. from endpoint_list). target_patch: Desired patch level; omit to use the fleet-majority level. sla_pct: Compliance SLA threshold percent; default 95.0. limit: Max non-compliant endpoints to return (default 200).

Returns dict: {endpointsEvaluated, targetPatch, targetSource, slaTargetPct, complianceRatePct, compliantCount, verdict, nonCompliantCount, nonCompliant:{items[], returned, limit, truncated}, note}. The rate is always computed over the whole fleet, never over the capped list.

Example: patch_compliance(endpoints=[{"hostname":"tc01","patchLevel":"2026-06"}, {"hostname":"tc02","patchLevel":"2026-05"}], target_patch="2026-06").

[READ] Patch-level distribution + which endpoints are behind the target level.

Args: target_patch: Desired patch level; omit to use the fleet-majority level. endpoints: Injected inventory rows; skips live collection. target: Endpoint-management target name from config; omit for the default. limit: Max behind-endpoints to return (default 200).

Returns dict: {totalEndpoints, targetPatch, targetSource, distribution, behindCount, behind:{items[], returned, limit, truncated}}. behindCount is the full count; when behind.truncated is true, re-run with a higher limit.

[READ] Recent login/boot sessions (endpoint, user, login_ms, boot_ms, result).

Args: since_hours: Look-back window in hours (1..720, default 24). target: Endpoint-management target name from config; omit for the default.

[WRITE][risk=medium] Apply a recorded undo by dispatching its inverse tool.

The inverse runs through its own governed tool, so its real risk tier is recorded there. Pass dry_run=True to preview the inverse call without executing it. A token can only be applied once.

Args: undo_id: The undoId from undo_list (or an _undo_id in a write result). dry_run: If True, preview the inverse tool + params without running it. target: Passed through to the inverse tool when it accepts a target.

[READ] List recorded, not-yet-applied undo tokens (most recent first).

Each entry names the original tool, the inverse tool that undo_apply would run, and a human note. Use the undoId with undo_apply.

Each entry carries effectVerified. False means the original write lost its response, so the change it reverses is PROBABLE, not confirmed — check the live state before applying, and do not report the result as a restore of a state that may never have been reached.

Args: limit: Max rows to return (1..500, default 50). target: Unused (undo state is host-local); accepted for CLI uniformity.

Returns dict: {undos[], returned, limit, truncated}. One extra row is fetched, so 'truncated' is measured rather than guessed from the returned count happening to equal the limit; re-run with a higher limit when true.