livedesk 0.1.461 → 0.1.463

package/diagnostics/livedesk-mac-physical-gate-core.mjs

@@ -1,8 +1,97 @@
 import path from 'node:path';
+import { createHash } from 'node:crypto';
 
 const MAC_VIDEO_HELPER_NAME = 'livedesk-sck-h264';
 const MAC_AUDIO_HELPER_NAME = 'livedesk-sck-audio';
 
+// This physical gate intentionally uses the product's 960x540/30 Wall-sized
+// ScreenCaptureKit + required hardware VideoToolbox path. These values are hard
+// release ceilings, not a claim that untested Mac hardware is healthy. A real
+// physical run must remain below both the aggregate and exact-role limits.
+// CPU values are macOS `ps` percentages where 100 is one fully occupied core.
+export const MAC_ACTIVE_MOTION_RESOURCE_BUDGET = Object.freeze({
+  profile: 'screencapturekit-hardware-vt-960x540-30',
+  width: 960,
+  height: 540,
+  fps: 30,
+  minimumFps: 24,
+  minimumSteadySamples: 4,
+  minimumMotionObservationMs: 1_500,
+  minimumMotionFrameCount: 36,
+  minimumDistinctAccessUnits: 12,
+  minimumDistinctDecodedFrames: 2,
+  minimumNativeCounterDelta: 20,
+  maximumMotionHashSamples: 48,
+  maximumIdleRatio: 0.1,
+  ownedCpuPercentP95Max: 140,
+  ownedCpuPercentPeakMax: 200,
+  ownedRssBytesPeakMax: 512 * 1024 * 1024,
+  // The gate runs the same two unified launcher roots as production. Their
+  // Hub, RemoteFast, and SCK descendants must still fit the unchanged CPU/RSS
+  // envelope; process ceilings describe topology, not permission to be heavy.
+  ownedProcessCountPeakMax: 5,
+  ownedChildProcessCountPeakMax: 3,
+  captureHelperCountPeakMax: 1,
+  roleBudgets: Object.freeze({
+    'hub-launcher': Object.freeze({
+      processCountPeakMax: 1,
+      cpuPercentP95Max: 5,
+      cpuPercentPeakMax: 15,
+      rssBytesPeakMax: 96 * 1024 * 1024
+    }),
+    'hub-runtime': Object.freeze({
+      processCountPeakMax: 1,
+      cpuPercentP95Max: 35,
+      cpuPercentPeakMax: 60,
+      rssBytesPeakMax: 160 * 1024 * 1024
+    }),
+    'client-launcher': Object.freeze({
+      processCountPeakMax: 1,
+      cpuPercentP95Max: 10,
+      cpuPercentPeakMax: 25,
+      rssBytesPeakMax: 128 * 1024 * 1024
+    }),
+    'remote-fast': Object.freeze({
+      processCountPeakMax: 1,
+      cpuPercentP95Max: 50,
+      cpuPercentPeakMax: 85,
+      rssBytesPeakMax: 256 * 1024 * 1024
+    }),
+    'capture-helper': Object.freeze({
+      processCountPeakMax: 1,
+      cpuPercentP95Max: 80,
+      cpuPercentPeakMax: 125,
+      rssBytesPeakMax: 192 * 1024 * 1024
+    })
+  })
+});
+
+// Cold helper prime is not allowed a relaxed "temporary" resource envelope.
+// If source compilation exceeds the normal LiveDesk topology or load ceiling,
+// the release must ship a lighter/prebuilt helper rather than hiding the cost.
+export const MAC_STARTUP_PRIME_RESOURCE_BUDGET = Object.freeze({
+  profile: 'cold-sck-helper-prime-to-first-wall-frame',
+  minimumSamples: 2,
+  maximumDurationMs: 8_000,
+  ownedCpuPercentP95Max: MAC_ACTIVE_MOTION_RESOURCE_BUDGET.ownedCpuPercentP95Max,
+  ownedCpuPercentPeakMax: MAC_ACTIVE_MOTION_RESOURCE_BUDGET.ownedCpuPercentPeakMax,
+  ownedRssBytesPeakMax: MAC_ACTIVE_MOTION_RESOURCE_BUDGET.ownedRssBytesPeakMax,
+  ownedProcessCountPeakMax: MAC_ACTIVE_MOTION_RESOURCE_BUDGET.ownedProcessCountPeakMax,
+  ownedChildProcessCountPeakMax:
+    MAC_ACTIVE_MOTION_RESOURCE_BUDGET.ownedChildProcessCountPeakMax,
+  captureHelperCountPeakMax: MAC_ACTIVE_MOTION_RESOURCE_BUDGET.captureHelperCountPeakMax
+});
+
+export const MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL = 'unified-production-v1';
+
+const MAC_PRODUCT_RESOURCE_ROLES = new Set([
+  'hub-launcher',
+  'hub-runtime',
+  'client-launcher',
+  'remote-fast',
+  'capture-helper'
+]);
+
 function normalizeProcessText(value) {
   return String(value || '').trim().replaceAll('\\', '/');
 }
@@ -76,6 +165,137 @@ function finite(value, fallback = 0) {
   return Number.isFinite(parsed) ? parsed : fallback;
 }
 
+function boundedEvenlySpacedItems(items, limit) {
+  if (items.length <= limit) return [...items];
+  const selected = [];
+  for (let index = 0; index < limit; index += 1) {
+    const sourceIndex = Math.round(index * (items.length - 1) / Math.max(1, limit - 1));
+    selected.push(items[sourceIndex]);
+  }
+  return selected;
+}
+
+/**
+ * Produces fail-closed motion evidence from the exact received generation.
+ * It does not trust an operator label: two decoded pixel hashes, sustained
+ * frame delivery, changing encoded access units, and advancing native counters
+ * must all independently agree.
+ */
+export function buildMacActiveMotionProof(
+  frames = [],
+  {
+    decodedPixelHashes = [],
+    budget = MAC_ACTIVE_MOTION_RESOURCE_BUDGET
+  } = {}
+) {
+  const normalizedFrames = (Array.isArray(frames) ? frames : [])
+    .filter(frame =>
+      frame
+      && typeof frame === 'object'
+      && Number.isFinite(Number(frame.receivedAt))
+      && finite(frame.bytes ?? frame.payload?.byteLength ?? frame.payload?.length) > 0
+    );
+  const firstReceivedAt = finite(normalizedFrames[0]?.receivedAt);
+  const lastReceivedAt = finite(normalizedFrames.at(-1)?.receivedAt);
+  const observationMs = Math.max(0, lastReceivedAt - firstReceivedAt);
+  const hashCandidates = normalizedFrames.filter(frame =>
+    String(frame.payloadHash || '').trim() || frame.payload
+  );
+  const sampledFrames = boundedEvenlySpacedItems(
+    hashCandidates,
+    Math.max(1, Math.floor(finite(budget.maximumMotionHashSamples, 48)))
+  );
+  const accessUnitHashes = new Set(sampledFrames.map(frame =>
+    String(frame.payloadHash || '').trim()
+      || createHash('sha256').update(frame.payload).digest('hex')
+  ));
+  const telemetrySnapshots = normalizedFrames
+    .map(frame => frame.metadata || {})
+    .filter(metadata =>
+      finite(metadata.nativeCaptureTelemetryVersion) >= 4
+      && metadata.nativeCaptureTelemetryAvailable === true
+      && Number.isFinite(Number(metadata.nativeCaptureSampleCount))
+      && Number.isFinite(Number(metadata.nativeCompressionOutputCount))
+      && Number.isFinite(Number(metadata.nativeEncodedFrameCount))
+      && Number.isFinite(Number(metadata.nativeIdleSkippedFrameCount))
+      && Number.isFinite(Number(metadata.nativeBackpressureSkippedFrameCount))
+    );
+  const distinctTelemetry = [];
+  let previousTelemetryToken = '';
+  for (const metadata of telemetrySnapshots) {
+    const token = [
+      finite(metadata.nativeCaptureSampleCount),
+      finite(metadata.nativeCompressionOutputCount),
+      finite(metadata.nativeEncodedFrameCount),
+      finite(metadata.nativeIdleSkippedFrameCount),
+      finite(metadata.nativeBackpressureSkippedFrameCount)
+    ].join(':');
+    if (token === previousTelemetryToken) continue;
+    distinctTelemetry.push(metadata);
+    previousTelemetryToken = token;
+  }
+  const firstTelemetry = distinctTelemetry[0] || {};
+  const lastTelemetry = distinctTelemetry.at(-1) || {};
+  const counterDelta = key => Math.max(0, finite(lastTelemetry[key]) - finite(firstTelemetry[key]));
+  const captureSampleDelta = counterDelta('nativeCaptureSampleCount');
+  const compressionOutputDelta = counterDelta('nativeCompressionOutputCount');
+  const stdoutWriteDelta = counterDelta('nativeEncodedFrameCount');
+  // These two native fields are one-second window counts rather than lifetime
+  // counters. Sum only the de-duplicated telemetry windows; subtracting them
+  // could falsely turn a later smaller unhealthy window into zero.
+  const idleSkippedObserved = distinctTelemetry.reduce(
+    (sum, metadata) => sum + Math.max(0, finite(metadata.nativeIdleSkippedFrameCount)),
+    0
+  );
+  const backpressureSkippedObserved = distinctTelemetry.reduce(
+    (sum, metadata) => sum + Math.max(0, finite(metadata.nativeBackpressureSkippedFrameCount)),
+    0
+  );
+  const normalizedPixelHashes = (Array.isArray(decodedPixelHashes) ? decodedPixelHashes : [])
+    .map(value => String(value || '').trim())
+    .filter(Boolean)
+    .slice(0, 4);
+  const distinctDecodedPixelHashCount = new Set(normalizedPixelHashes).size;
+  const nativeCounterMinimum = Math.max(1, Math.floor(finite(budget.minimumNativeCounterDelta, 20)));
+  const maximumIdleSkipped = Math.max(
+    1,
+    Math.floor(captureSampleDelta * Math.max(0, finite(budget.maximumIdleRatio, 0.1)))
+  );
+  const proof = {
+    method: 'decoded-pixels-native-counters-and-bounded-access-unit-hashes',
+    operatorRequirement: 'continuous-visible-motion-on-each-tested-display',
+    observationMs: Math.round(observationMs),
+    frameCount: normalizedFrames.length,
+    sampledAccessUnitCount: sampledFrames.length,
+    distinctAccessUnitHashCount: accessUnitHashes.size,
+    telemetrySnapshotCount: telemetrySnapshots.length,
+    distinctTelemetrySnapshotCount: distinctTelemetry.length,
+    captureSampleDelta,
+    compressionOutputDelta,
+    stdoutWriteDelta,
+    idleSkippedObserved,
+    backpressureSkippedObserved,
+    maximumAllowedIdleSkipped: maximumIdleSkipped,
+    decodedPixelHashCount: normalizedPixelHashes.length,
+    distinctDecodedPixelHashCount
+  };
+  return {
+    ...proof,
+    detected: proof.observationMs >= finite(budget.minimumMotionObservationMs, 1_500)
+      && proof.frameCount >= finite(budget.minimumMotionFrameCount, 36)
+      && proof.sampledAccessUnitCount >= finite(budget.minimumDistinctAccessUnits, 12)
+      && proof.distinctAccessUnitHashCount >= finite(budget.minimumDistinctAccessUnits, 12)
+      && proof.distinctTelemetrySnapshotCount >= 2
+      && proof.captureSampleDelta >= nativeCounterMinimum
+      && proof.compressionOutputDelta >= nativeCounterMinimum
+      && proof.stdoutWriteDelta >= nativeCounterMinimum
+      && proof.idleSkippedObserved <= maximumIdleSkipped
+      && proof.backpressureSkippedObserved === 0
+      && proof.decodedPixelHashCount >= finite(budget.minimumDistinctDecodedFrames, 2)
+      && proof.distinctDecodedPixelHashCount >= finite(budget.minimumDistinctDecodedFrames, 2)
+  };
+}
+
 export function createAsyncSingleFlightSampler(sampleImpl) {
   if (typeof sampleImpl !== 'function') {
     throw new TypeError('An async sample function is required.');
@@ -182,15 +402,30 @@ function classifyMacLiveDeskRuntimeRecord(record) {
   return '';
 }
 
-function identifyMacLiveDeskRuntimeRecords(records, { ignorePids = [] } = {}) {
+function identifyMacLiveDeskRuntimeRecords(
+  records,
+  {
+    ignorePids = [],
+    ignoreDescendantsOfPids = []
+  } = {}
+) {
   const ignored = new Set(
     (Array.isArray(ignorePids) ? ignorePids : [])
       .map(Number)
       .filter(pid => Number.isInteger(pid) && pid > 1)
   );
+  const ignoredAncestorPids = normalizedOwnedPids(ignoreDescendantsOfPids);
+  const recordsByPid = new Map(records.map(record => [record.pid, record]));
   const results = [];
   for (const record of records) {
-    if (ignored.has(record.pid)) continue;
+    if (
+      ignored.has(record.pid)
+      || [...ignoredAncestorPids].some(ancestorPid =>
+        record.pid === ancestorPid || hasAncestorPid(record, ancestorPid, recordsByPid)
+      )
+    ) {
+      continue;
+    }
     const kind = classifyMacLiveDeskRuntimeRecord(record);
     if (!kind) continue;
     results.push({
@@ -218,6 +453,34 @@ function hasAncestorPid(record, ancestorPid, recordsByPid) {
   return false;
 }
 
+function isUnifiedLauncherRoleRecord(record, role) {
+  if (classifyMacLiveDeskRuntimeRecord(record) !== 'unified-runtime') return false;
+  const commandLine = normalizeProcessText(record?.commandLine);
+  const escapedRole = String(role || '').replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+  return new RegExp(
+    `(?:--force-role|--role)(?:=|\\s+)${escapedRole}(?:\\s|$)`
+      + `|(?:^|\\s)(?:hub|manager|client)(?:\\s|$)`,
+    'i'
+  ).test(commandLine)
+    && (
+      role === 'hub'
+        ? /(?:--force-role|--role)(?:=|\s+)(?:hub|manager)(?:\s|$)|(?:^|\s)(?:hub|manager)(?:\s|$)/i
+          .test(commandLine)
+        : /(?:--force-role|--role)(?:=|\s+)client(?:\s|$)|(?:^|\s)client(?:\s|$)/i
+          .test(commandLine)
+    );
+}
+
+function classifyOwnedMacProductRole(record, ownerRole, isRoot) {
+  if (isRoot) return `${ownerRole}-launcher`;
+  const kind = classifyMacLiveDeskRuntimeRecord(record);
+  if (kind === 'hub-runtime') return 'hub-runtime';
+  if (kind === 'client-agent') return 'remote-fast';
+  if (kind === 'capture-helper') return 'capture-helper';
+  if (kind) return kind;
+  return `${ownerRole}-owned-descendant`;
+}
+
 function normalizedOwnedPids(values) {
   return new Set(
     (Array.isArray(values) ? values : [])
@@ -234,17 +497,15 @@ export function buildMacDiagnosticResourceSample(
   psOutput,
   {
     diagnosticPid = 0,
-    hubPid = 0,
-    agentPid = 0,
-    decoderPids = []
+    hubLauncherPid = 0,
+    clientLauncherPid = 0,
+    observerPids = []
   } = {}
 ) {
   const records = parseMacProcessResourceRecords(psOutput);
   const recordsByPid = new Map(records.map(record => [record.pid, record]));
   const normalizedDiagnosticPid = Number(diagnosticPid);
-  const normalizedHubPid = Number(hubPid);
-  const normalizedAgentPid = Number(agentPid);
-  const ownedDecoderPids = normalizedOwnedPids(decoderPids);
+  const ownedObserverPids = normalizedOwnedPids(observerPids);
   const helpers = records.filter(isMacCaptureHelperRecord);
   // The public `npx livedesk diagnose mac-physical` coordinator is itself
   // classified as a unified LiveDesk runtime. Exclude only that exact,
@@ -253,44 +514,106 @@ export function buildMacDiagnosticResourceSample(
   const liveDeskRecords = identifyMacLiveDeskRuntimeRecords(records, {
     ignorePids: [normalizedDiagnosticPid]
   });
-  const hubRecord = recordsByPid.get(normalizedHubPid);
-  const agentRecord = recordsByPid.get(normalizedAgentPid);
-  const hubOwned = classifyMacLiveDeskRuntimeRecord(hubRecord) === 'hub-runtime';
-  const agentOwned = classifyMacLiveDeskRuntimeRecord(agentRecord) === 'client-agent';
+  const roots = [
+    {
+      ownerRole: 'hub',
+      pid: Number(hubLauncherPid),
+      role: 'hub-launcher'
+    },
+    {
+      ownerRole: 'client',
+      pid: Number(clientLauncherPid),
+      role: 'client-launcher'
+    }
+  ].map(root => {
+    const record = recordsByPid.get(root.pid);
+    return {
+      ...root,
+      record,
+      owned: Number.isInteger(root.pid)
+        && root.pid > 1
+        && isUnifiedLauncherRoleRecord(record, root.ownerRole)
+    };
+  });
   const ownedLiveDeskPids = new Set();
-  if (hubOwned) ownedLiveDeskPids.add(normalizedHubPid);
-  if (agentOwned) ownedLiveDeskPids.add(normalizedAgentPid);
-  const helperOwnership = new Map();
-  for (const helper of helpers) {
-    const owned = agentOwned && hasAncestorPid(helper, normalizedAgentPid, recordsByPid);
-    helperOwnership.set(helper.pid, owned);
-    if (owned) ownedLiveDeskPids.add(helper.pid);
-  }
-
-  const resourceRecords = [];
-  const addResource = (record, role, ownedByDiagnostic) => {
+  const resourceRecordsByPid = new Map();
+  const addResource = (
+    record,
+    role,
+    ownedByDiagnostic,
+    {
+      ownerRole = '',
+      ownership = 'unowned',
+      productProcess = false
+    } = {}
+  ) => {
     if (!record) return;
-    resourceRecords.push({
+    resourceRecordsByPid.set(record.pid, {
       role,
       pid: record.pid,
       ownedByDiagnostic: ownedByDiagnostic === true,
+      ownerRole,
+      ownership,
+      productProcess: productProcess === true,
       cpuPercent: Math.round(record.cpuPercent * 100) / 100,
       rssBytes: record.rssBytes
     });
   };
-  addResource(hubRecord, 'hub', hubOwned);
-  addResource(agentRecord, 'remote-fast', agentOwned);
-  for (const decoderPid of [...ownedDecoderPids].sort((left, right) => left - right)) {
-    addResource(recordsByPid.get(decoderPid), 'decoder', true);
+
+  for (const root of roots) {
+    addResource(root.record, root.role, root.owned, {
+      ownerRole: root.ownerRole,
+      ownership: 'exact-root',
+      productProcess: true
+    });
+    if (!root.owned) continue;
+    ownedLiveDeskPids.add(root.pid);
+    for (const record of records) {
+      if (record.pid === root.pid || !hasAncestorPid(record, root.pid, recordsByPid)) continue;
+      addResource(
+        record,
+        classifyOwnedMacProductRole(record, root.ownerRole, false),
+        true,
+        {
+          ownerRole: root.ownerRole,
+          ownership: 'exact-descendant',
+          productProcess: true
+        }
+      );
+      if (classifyMacLiveDeskRuntimeRecord(record)) {
+        ownedLiveDeskPids.add(record.pid);
+      }
+    }
+  }
+
+  for (const observerPid of [...ownedObserverPids].sort((left, right) => left - right)) {
+    // ffmpeg exists only to observe diagnostic key frames. It is retained in
+    // report-safe telemetry when explicitly requested, but it is never product
+    // CPU/RSS/process evidence and therefore never enters owned aggregates.
+    addResource(recordsByPid.get(observerPid), 'diagnostic-observer', false, {
+      ownerRole: 'diagnostic',
+      ownership: 'exact-observer',
+      productProcess: false
+    });
   }
   for (const helper of helpers.sort((left, right) => left.pid - right.pid)) {
-    addResource(helper, 'capture-helper', helperOwnership.get(helper.pid) === true);
+    if (resourceRecordsByPid.has(helper.pid)) continue;
+    addResource(helper, 'capture-helper', false, {
+      ownerRole: 'unowned',
+      ownership: 'unowned',
+      productProcess: true
+    });
   }
 
+  const resourceRecords = [...resourceRecordsByPid.values()];
   return {
+    ownershipModel: MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL,
     sampledAt: new Date().toISOString(),
     totalLiveDeskProcessCount: liveDeskRecords.length,
     captureHelperCount: helpers.length,
+    ownedProductProcessCount: resourceRecords.filter(record =>
+      record.ownedByDiagnostic === true && record.productProcess === true
+    ).length,
     unownedLiveDeskPids: liveDeskRecords
       .filter(record => !ownedLiveDeskPids.has(record.pid))
       .map(record => record.pid)
@@ -322,6 +645,9 @@ export function summarizeMacDiagnosticResourceSamples(
       role,
       pid,
       ownedByDiagnostic: record?.ownedByDiagnostic === true,
+      ownerRole: String(record?.ownerRole || ''),
+      ownership: String(record?.ownership || ''),
+      productProcess: record?.productProcess !== false,
       cpuPercentSamples: [],
       rssBytesPeak: 0
     });
@@ -338,12 +664,18 @@ export function summarizeMacDiagnosticResourceSamples(
           role,
           pid,
           ownedByDiagnostic: true,
+          ownerRole: String(record?.ownerRole || ''),
+          ownership: String(record?.ownership || ''),
+          productProcess: record?.productProcess === true,
           cpuPercentSamples: [],
           rssBytesPeak: 0
         };
         grouped.set(key, summary);
       }
       summary.ownedByDiagnostic = summary.ownedByDiagnostic && record.ownedByDiagnostic === true;
+      summary.productProcess = summary.productProcess && record.productProcess === true;
+      if (summary.ownerRole !== String(record?.ownerRole || '')) summary.ownerRole = 'mixed';
+      if (summary.ownership !== String(record?.ownership || '')) summary.ownership = 'mixed';
       summary.cpuPercentSamples.push(Math.max(0, finite(record.cpuPercent)));
       summary.rssBytesPeak = Math.max(summary.rssBytesPeak, Math.max(0, finite(record.rssBytes)));
     }
@@ -357,6 +689,9 @@ export function summarizeMacDiagnosticResourceSamples(
         role: summary.role,
         pid: summary.pid,
         ownedByDiagnostic: summary.ownedByDiagnostic,
+        ownerRole: summary.ownerRole,
+        ownership: summary.ownership,
+        productProcess: summary.productProcess,
         sampleCount: summary.cpuPercentSamples.length,
         cpuPercentSamples,
         cpuPercentP95: Math.round(percentile95(summary.cpuPercentSamples) * 100) / 100,
@@ -369,6 +704,72 @@ export function summarizeMacDiagnosticResourceSamples(
     .map(sample => Math.max(0, Math.round(finite(sample.totalLiveDeskProcessCount))));
   const captureHelperCountSamples = normalizedSamples
     .map(sample => Math.max(0, Math.round(finite(sample.captureHelperCount))));
+  const productResourceSamples = normalizedSamples.map(sample => {
+    const ownedProcesses = (Array.isArray(sample.processes) ? sample.processes : [])
+      .filter(record =>
+        record?.ownedByDiagnostic === true
+        && record?.productProcess === true
+      );
+    return {
+      cpuPercent: ownedProcesses.reduce(
+        (sum, record) => sum + Math.max(0, finite(record?.cpuPercent)),
+        0
+      ),
+      rssBytes: ownedProcesses.reduce(
+        (sum, record) => sum + Math.max(0, finite(record?.rssBytes)),
+        0
+      ),
+      processCount: ownedProcesses.length,
+      childProcessCount: ownedProcesses.filter(record =>
+        String(record?.ownership || '') === 'exact-descendant'
+      ).length
+    };
+  });
+  const ownedCpuPercentSamples = productResourceSamples
+    .map(sample => Math.round(sample.cpuPercent * 100) / 100)
+    .slice(-120);
+  const ownedRssBytesSamples = productResourceSamples
+    .map(sample => Math.round(sample.rssBytes))
+    .slice(-120);
+  const ownedProcessCountSamples = productResourceSamples
+    .map(sample => sample.processCount)
+    .slice(-120);
+  const ownedChildProcessCountSamples = productResourceSamples
+    .map(sample => sample.childProcessCount)
+    .slice(-120);
+  const roles = [...MAC_PRODUCT_RESOURCE_ROLES].map(role => {
+    const cpuPercentSamples = [];
+    let rssBytesPeak = 0;
+    let processCountPeak = 0;
+    let sampleCount = 0;
+    for (const sample of normalizedSamples) {
+      const roleProcesses = (Array.isArray(sample.processes) ? sample.processes : [])
+        .filter(record =>
+          record?.ownedByDiagnostic === true
+          && String(record?.role || '') === role
+        );
+      if (roleProcesses.length === 0) continue;
+      sampleCount += 1;
+      processCountPeak = Math.max(processCountPeak, roleProcesses.length);
+      cpuPercentSamples.push(Math.round(roleProcesses.reduce(
+        (sum, record) => sum + Math.max(0, finite(record?.cpuPercent)),
+        0
+      ) * 100) / 100);
+      rssBytesPeak = Math.max(rssBytesPeak, roleProcesses.reduce(
+        (sum, record) => sum + Math.max(0, finite(record?.rssBytes)),
+        0
+      ));
+    }
+    return {
+      role,
+      sampleCount,
+      processCountPeak,
+      cpuPercentSamples: cpuPercentSamples.slice(-120),
+      cpuPercentP95: Math.round(percentile95(cpuPercentSamples) * 100) / 100,
+      cpuPercentPeak: Math.round(Math.max(0, ...cpuPercentSamples) * 100) / 100,
+      rssBytesPeak: Math.round(rssBytesPeak)
+    };
+  });
   const unownedLiveDeskPids = [...new Set(
     normalizedSamples.flatMap(sample =>
       (Array.isArray(sample.unownedLiveDeskPids) ? sample.unownedLiveDeskPids : [])
@@ -377,12 +778,28 @@ export function summarizeMacDiagnosticResourceSamples(
     )
   )].sort((left, right) => left - right);
   return {
+    ownershipModel: normalizedSamples.length > 0
+      && normalizedSamples.every(sample =>
+        sample.ownershipModel === MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL
+      )
+      ? MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL
+      : '',
     sampleCount: normalizedSamples.length,
     totalLiveDeskProcessCount: totalLiveDeskProcessCountSamples.at(-1) || 0,
     totalLiveDeskProcessCountPeak: Math.max(0, ...totalLiveDeskProcessCountSamples),
     captureHelperCountPeak: Math.max(0, ...captureHelperCountSamples),
+    ownedCpuPercentSamples,
+    ownedCpuPercentP95: Math.round(percentile95(ownedCpuPercentSamples) * 100) / 100,
+    ownedCpuPercentPeak: Math.round(Math.max(0, ...ownedCpuPercentSamples) * 100) / 100,
+    ownedRssBytesSamples,
+    ownedRssBytesPeak: Math.max(0, ...ownedRssBytesSamples),
+    ownedProcessCountSamples,
+    ownedProcessCountPeak: Math.max(0, ...ownedProcessCountSamples),
+    ownedChildProcessCountSamples,
+    ownedChildProcessCountPeak: Math.max(0, ...ownedChildProcessCountSamples),
     unownedLiveDeskPids,
-    processes
+    processes,
+    roles
   };
 }
 
@@ -494,7 +911,19 @@ function check(id, ok, detail) {
 export function classifyMacPhysicalGate(snapshot = {}) {
   const schemaVersion = Math.floor(finite(snapshot.schemaVersion));
   const requestedFps = Math.max(1, finite(snapshot.requestedFps, 30));
-  const minimumFps = requestedFps * 0.8;
+  const motion = snapshot.motion || {};
+  const activeMotionProfileMatches = motion.required === true
+    && motion.kind === 'active'
+    && finite(motion.width) === MAC_ACTIVE_MOTION_RESOURCE_BUDGET.width
+    && finite(motion.height) === MAC_ACTIVE_MOTION_RESOURCE_BUDGET.height
+    && requestedFps === MAC_ACTIVE_MOTION_RESOURCE_BUDGET.fps
+    && finite(motion.minimumCaptureFps) === MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumFps
+    && motion.idleCadenceWaiverAllowed === false;
+  const activeMotionOperatorConfirmed = motion.operatorConfirmed === true
+    && motion.operatorRequirement === 'continuous-visible-motion-on-each-tested-display';
+  const minimumFps = requestedFps === MAC_ACTIVE_MOTION_RESOURCE_BUDGET.fps
+    ? MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumFps
+    : requestedFps * 0.8;
   const helper = snapshot.helper || {};
   const monitor = snapshot.monitor || {};
   const modifier = snapshot.modifier || {};
@@ -518,6 +947,8 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     && typeof captureStages[name] === 'object'
     && captureStages[name].telemetry
     && typeof captureStages[name].telemetry === 'object'
+    && captureStages[name].motionProof
+    && typeof captureStages[name].motionProof === 'object'
     && Number.isFinite(Number(captureStages[name].deliveredFps))
   );
   const stageEvaluations = requiredStageNames.map(name => {
@@ -529,9 +960,74 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     const deliveredFps = Math.max(0, finite(stage.deliveredFps));
     const idleSkipped = Math.max(0, finite(stageTelemetry.idleSkipped));
     const backpressureSkipped = Math.max(0, finite(stageTelemetry.backpressureSkipped));
-    // One incidental idle skip must never mask a 3-4 fps regression. A static
-    // screen is treated as intentionally idle only when most of a current
-    // one-second capture window was suppressed and keepalive output remained.
+    const encodeFramesInFlight = finite(stageTelemetry.encodeFramesInFlight, -1);
+    const pendingEncodeFrameCount = finite(stageTelemetry.pendingEncodeFrameCount, -1);
+    const encodeTimestampOwnerCount = finite(
+      stageTelemetry.encodeTimestampOwnerCount,
+      -1
+    );
+    const encodeTimestampOwnerHighWatermark = finite(
+      stageTelemetry.encodeTimestampOwnerHighWatermark,
+      -1
+    );
+    const videoToolboxActiveSessionCount = finite(
+      stageTelemetry.videoToolboxActiveSessionCount,
+      -1
+    );
+    const videoToolboxSessionHighWatermark = finite(
+      stageTelemetry.videoToolboxSessionHighWatermark,
+      -1
+    );
+    const outputOldestAgeMs = finite(stageTelemetry.outputOldestAgeMs, -1);
+    const outputDropped = finite(stageTelemetry.outputDropped, -1);
+    const nativeAndPipeResidenceAgeMs = finite(
+      stageTelemetry.nativeAndPipeResidenceAgeMs,
+      -1
+    );
+    const handoffDropped = finite(stageTelemetry.handoffDropped, -1);
+    const handoffRecoveryRequests = finite(
+      stageTelemetry.handoffRecoveryRequests,
+      -1
+    );
+    const handoffOldestAgeMs = finite(stageTelemetry.handoffOldestAgeMs, -1);
+    const annexBAllocations = finite(stageTelemetry.annexBAllocations, -1);
+    const annexBPayloadCopies = finite(stageTelemetry.annexBPayloadCopies, -1);
+    const annexBPayloadCopiedBytes = finite(
+      stageTelemetry.annexBPayloadCopiedBytes,
+      -1
+    );
+    const pipePayloadAllocations = finite(stageTelemetry.pipePayloadAllocations, -1);
+    const pipePayloadCopies = finite(stageTelemetry.pipePayloadCopies, -1);
+    const pipePayloadCopiedBytes = finite(stageTelemetry.pipePayloadCopiedBytes, -1);
+    const motionProof = stage.motionProof || {};
+    const motionProven = motionProof.method
+        === 'decoded-pixels-native-counters-and-bounded-access-unit-hashes'
+      && motionProof.operatorRequirement === 'continuous-visible-motion-on-each-tested-display'
+      && motionProof.detected === true
+      && finite(motionProof.observationMs)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumMotionObservationMs
+      && finite(motionProof.frameCount)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumMotionFrameCount
+      && finite(motionProof.sampledAccessUnitCount)
+        <= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.maximumMotionHashSamples
+      && finite(motionProof.distinctAccessUnitHashCount)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumDistinctAccessUnits
+      && finite(motionProof.distinctTelemetrySnapshotCount) >= 2
+      && finite(motionProof.captureSampleDelta)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumNativeCounterDelta
+      && finite(motionProof.compressionOutputDelta)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumNativeCounterDelta
+      && finite(motionProof.stdoutWriteDelta)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumNativeCounterDelta
+      && finite(motionProof.idleSkippedObserved)
+        <= finite(motionProof.maximumAllowedIdleSkipped, -1)
+      && finite(motionProof.backpressureSkippedObserved) === 0
+      && finite(motionProof.decodedPixelHashCount)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumDistinctDecodedFrames
+      && finite(motionProof.distinctDecodedPixelHashCount)
+        >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumDistinctDecodedFrames;
+    // This is the active-motion physical gate. Idle throttling remains a valid
+    // runtime optimization, but it cannot waive any active cadence floor.
     const idleDominant = captureFps >= minimumFps
       && backpressureSkipped === 0
       && idleSkipped >= Math.max(10, captureFps * 0.6);
@@ -544,18 +1040,65 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       deliveredFps,
       idleSkipped,
       backpressureSkipped,
+      encodeFramesInFlight,
+      pendingEncodeFrameCount,
+      encodeTimestampOwnerCount,
+      encodeTimestampOwnerHighWatermark,
+      videoToolboxActiveSessionCount,
+      videoToolboxSessionHighWatermark,
+      outputOldestAgeMs,
+      outputDropped,
+      nativeAndPipeResidenceAgeMs,
+      handoffDropped,
+      handoffRecoveryRequests,
+      handoffOldestAgeMs,
+      annexBAllocations,
+      annexBPayloadCopies,
+      annexBPayloadCopiedBytes,
+      pipePayloadAllocations,
+      pipePayloadCopies,
+      pipePayloadCopiedBytes,
       idleDominant,
-      telemetryCurrent: finite(stageTelemetry.version) >= 2
+      motionProof,
+      motionProven,
+      telemetryCurrent: finite(stageTelemetry.version) >= 5
         && Number.isFinite(Number(stageTelemetry.ageMs))
         && finite(stageTelemetry.ageMs) <= 3_000,
       hardwareAccelerated: stageTelemetry.hardwareAccelerated === true,
+      nativeEncodeOwnershipBounded: encodeFramesInFlight >= 0
+        && encodeFramesInFlight <= 2
+        && pendingEncodeFrameCount >= 0
+        && pendingEncodeFrameCount <= 1
+        && encodeTimestampOwnerCount >= 0
+        && encodeTimestampOwnerCount <= 2
+        && encodeTimestampOwnerHighWatermark >= encodeTimestampOwnerCount
+        && encodeTimestampOwnerHighWatermark <= 2
+        && videoToolboxActiveSessionCount === 1
+        && videoToolboxSessionHighWatermark === 1,
       captureAtTarget: captureFps >= minimumFps,
-      compressionKeepsUp: (idleDominant && compressionFps >= 1)
-        || (captureFps > 0 && compressionFps >= captureFps * 0.8),
-      stdoutKeepsUp: (idleDominant && stdoutFps >= 1)
-        || (compressionFps > 0 && stdoutFps >= compressionFps * 0.8),
-      deliveredAtTarget: (idleDominant && deliveredFps >= 1)
-        || deliveredFps >= minimumFps
+      compressionKeepsUp: compressionFps >= minimumFps,
+      stdoutKeepsUp: stdoutFps >= minimumFps,
+      deliveredAtTarget: deliveredFps >= minimumFps,
+      backpressureFree: backpressureSkipped === 0,
+      currentFrameQueuesBounded:
+        outputOldestAgeMs >= 0
+        && outputOldestAgeMs <= 120
+        && outputDropped === 0
+        && stageTelemetry.outputAwaitingKeyFrame === false
+        && nativeAndPipeResidenceAgeMs >= 0
+        && nativeAndPipeResidenceAgeMs <= 250
+        && handoffDropped === 0
+        && handoffRecoveryRequests === 0
+        && handoffOldestAgeMs >= 0
+        && handoffOldestAgeMs <= 120,
+      payloadCopyAccountingCurrent:
+        stageTelemetry.copyTelemetryAvailable === true
+        && annexBAllocations > 0
+        && annexBPayloadCopies >= annexBAllocations
+        && annexBPayloadCopiedBytes > 0
+        && pipePayloadAllocations > 0
+        && pipePayloadCopies >= pipePayloadAllocations
+        && pipePayloadCopiedBytes > 0
     };
   });
   const stageMetricDetail = metric => stageEvaluations
@@ -570,44 +1113,198 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     && stageEvaluations.every(stage => stage.stdoutKeepsUp);
   const deliveredAtTarget = stageEvidenceAvailable
     && stageEvaluations.every(stage => stage.deliveredAtTarget);
+  const backpressureFree = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.backpressureFree);
+  const currentFrameQueuesBounded = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.currentFrameQueuesBounded);
+  const payloadCopyAccountingCurrent = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.payloadCopyAccountingCurrent);
+  const activeMotionProven = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.motionProven);
+  const nativeEncodeOwnershipBounded = stageEvidenceAvailable
+    && stageEvaluations.every(stage => stage.nativeEncodeOwnershipBounded);
   const helperPids = Array.isArray(helper.observedPids)
     ? helper.observedPids.map(Number).filter(pid => Number.isInteger(pid) && pid > 1)
     : [];
   const resources = snapshot.resources || {};
   const baselineResources = resources.baseline || {};
+  const startupPrimeResources = resources.startupPrime || {};
   const steadyResources = resources.steadyCapture || {};
   const cleanupResources = resources.afterCleanup || {};
   const steadyProcesses = Array.isArray(steadyResources.processes)
     ? steadyResources.processes
     : [];
   const sampledSteadyProcesses = steadyProcesses
-    .filter(processInfo => finite(processInfo?.sampleCount) > 0);
+    .filter(processInfo =>
+      finite(processInfo?.sampleCount) > 0
+      && processInfo?.productProcess === true
+    );
   const sampledSteadyRoles = new Set(
     sampledSteadyProcesses.map(processInfo => String(processInfo?.role || ''))
   );
+  const expectedRoleOwnership = new Map([
+    ['hub-launcher', ['hub', 'exact-root']],
+    ['hub-runtime', ['hub', 'exact-descendant']],
+    ['client-launcher', ['client', 'exact-root']],
+    ['remote-fast', ['client', 'exact-descendant']],
+    ['capture-helper', ['client', 'exact-descendant']]
+  ]);
+  const resourceOwnershipLabelsCurrent = sampledSteadyProcesses.every(processInfo => {
+    const expected = expectedRoleOwnership.get(String(processInfo?.role || ''));
+    if (!expected) {
+      return ['hub', 'client'].includes(String(processInfo?.ownerRole || ''))
+        && String(processInfo?.ownership || '') === 'exact-descendant';
+    }
+    return String(processInfo?.ownerRole || '') === expected[0]
+      && String(processInfo?.ownership || '') === expected[1];
+  });
   const resourceTelemetryAvailable = finite(baselineResources.sampleCount) > 0
+    && finite(startupPrimeResources.sampleCount) > 0
     && finite(steadyResources.sampleCount) > 0
     && finite(cleanupResources.sampleCount) > 0;
-  const resourceOwnershipCurrent = finite(baselineResources.totalLiveDeskProcessCountPeak) === 0
-    && sampledSteadyRoles.has('hub')
-    && sampledSteadyRoles.has('remote-fast')
-    && sampledSteadyRoles.has('capture-helper')
+  const steadyOwnedProcessCounts = Array.isArray(steadyResources.ownedProcessCountSamples)
+    ? steadyResources.ownedProcessCountSamples.map(value => Math.max(0, Math.round(finite(value))))
+    : [];
+  const steadyOwnedChildCounts = Array.isArray(steadyResources.ownedChildProcessCountSamples)
+    ? steadyResources.ownedChildProcessCountSamples
+      .map(value => Math.max(0, Math.round(finite(value))))
+    : [];
+  const exactSteadyTopologyCurrent =
+    steadyOwnedProcessCounts.length >= MAC_ACTIVE_MOTION_RESOURCE_BUDGET.minimumSteadySamples
+    && steadyOwnedChildCounts.length === steadyOwnedProcessCounts.length
+    && steadyOwnedProcessCounts.every(
+      count => count === MAC_ACTIVE_MOTION_RESOURCE_BUDGET.ownedProcessCountPeakMax
+    )
+    && steadyOwnedChildCounts.every(
+      count => count === MAC_ACTIVE_MOTION_RESOURCE_BUDGET.ownedChildProcessCountPeakMax
+    );
+  const resourceOwnershipCurrent =
+    resources.ownershipModel === MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL
+    && baselineResources.ownershipModel === MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL
+    && startupPrimeResources.ownershipModel === MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL
+    && steadyResources.ownershipModel === MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL
+    && cleanupResources.ownershipModel === MAC_PHYSICAL_RESOURCE_OWNERSHIP_MODEL
+    && finite(baselineResources.totalLiveDeskProcessCountPeak) === 0
+    && exactSteadyTopologyCurrent
+    && [...MAC_PRODUCT_RESOURCE_ROLES].every(role => sampledSteadyRoles.has(role))
     && sampledSteadyProcesses.every(processInfo => processInfo?.ownedByDiagnostic === true)
+    && resourceOwnershipLabelsCurrent
     && (!Array.isArray(steadyResources.unownedLiveDeskPids)
       || steadyResources.unownedLiveDeskPids.length === 0);
   const resourceDrained = finite(cleanupResources.totalLiveDeskProcessCount) === 0
     && finite(cleanupResources.totalLiveDeskProcessCountPeak) === 0
+    && finite(cleanupResources.ownedProcessCountPeak) === 0
+    && finite(cleanupResources.ownedChildProcessCountPeak) === 0
+    && finite(cleanupResources.ownedRssBytesPeak) === 0
     && (!Array.isArray(cleanupResources.processes) || cleanupResources.processes.length === 0)
     && (!Array.isArray(cleanupResources.unownedLiveDeskPids)
       || cleanupResources.unownedLiveDeskPids.length === 0);
+  const resourceReturnedToBaseline = finite(cleanupResources.ownedProcessCountPeak)
+      <= finite(baselineResources.ownedProcessCountPeak)
+    && finite(cleanupResources.ownedChildProcessCountPeak)
+      <= finite(baselineResources.ownedChildProcessCountPeak)
+    && finite(cleanupResources.ownedRssBytesPeak)
+      <= finite(baselineResources.ownedRssBytesPeak);
   const resourceHelperPeak = Math.max(
     finite(helper.maxConcurrent),
     finite(steadyResources.captureHelperCountPeak)
   );
+  const resourceBudget = MAC_ACTIVE_MOTION_RESOURCE_BUDGET;
+  const startupPrimeBudget = MAC_STARTUP_PRIME_RESOURCE_BUDGET;
+  const startupPrimeObserved = {
+    samples: Math.max(0, Math.round(finite(startupPrimeResources.sampleCount))),
+    durationMs: Math.max(0, finite(startupPrimeResources.durationMs, -1)),
+    ownedCpuPercentP95: Math.max(0, finite(startupPrimeResources.ownedCpuPercentP95)),
+    ownedCpuPercentPeak: Math.max(0, finite(startupPrimeResources.ownedCpuPercentPeak)),
+    ownedRssBytesPeak: Math.max(
+      0,
+      Math.round(finite(startupPrimeResources.ownedRssBytesPeak))
+    ),
+    ownedProcessCountPeak: Math.max(
+      0,
+      Math.round(finite(startupPrimeResources.ownedProcessCountPeak))
+    ),
+    ownedChildProcessCountPeak: Math.max(
+      0,
+      Math.round(finite(startupPrimeResources.ownedChildProcessCountPeak))
+    ),
+    captureHelperCountPeak: Math.max(
+      0,
+      Math.round(finite(startupPrimeResources.captureHelperCountPeak))
+    )
+  };
+  const startupPrimeWithinBudget =
+    startupPrimeObserved.samples >= startupPrimeBudget.minimumSamples
+    && startupPrimeObserved.durationMs > 0
+    && startupPrimeObserved.durationMs <= startupPrimeBudget.maximumDurationMs
+    && startupPrimeObserved.ownedCpuPercentP95
+      <= startupPrimeBudget.ownedCpuPercentP95Max
+    && startupPrimeObserved.ownedCpuPercentPeak
+      <= startupPrimeBudget.ownedCpuPercentPeakMax
+    && startupPrimeObserved.ownedRssBytesPeak
+      <= startupPrimeBudget.ownedRssBytesPeakMax
+    && startupPrimeObserved.ownedProcessCountPeak
+      <= startupPrimeBudget.ownedProcessCountPeakMax
+    && startupPrimeObserved.ownedChildProcessCountPeak
+      <= startupPrimeBudget.ownedChildProcessCountPeakMax
+    && startupPrimeObserved.captureHelperCountPeak
+      <= startupPrimeBudget.captureHelperCountPeakMax
+    && (!Array.isArray(startupPrimeResources.unownedLiveDeskPids)
+      || startupPrimeResources.unownedLiveDeskPids.length === 0);
+  const resourceRoleObservations = Object.fromEntries(
+    (Array.isArray(steadyResources.roles) ? steadyResources.roles : [])
+      .map(roleInfo => [String(roleInfo?.role || ''), roleInfo])
+      .filter(([role]) => MAC_PRODUCT_RESOURCE_ROLES.has(role))
+  );
+  const resourceRoleChecks = Object.entries(resourceBudget.roleBudgets).map(([role, roleBudget]) => {
+    const observed = resourceRoleObservations[role] || {};
+    return {
+      role,
+      available: finite(observed.sampleCount) >= resourceBudget.minimumSteadySamples,
+      processCountPeak: Math.max(0, Math.round(finite(observed.processCountPeak))),
+      cpuPercentP95: Math.max(0, finite(observed.cpuPercentP95)),
+      cpuPercentPeak: Math.max(0, finite(observed.cpuPercentPeak)),
+      rssBytesPeak: Math.max(0, Math.round(finite(observed.rssBytesPeak))),
+      budget: roleBudget
+    };
+  });
+  const resourceRolesWithinBudget = resourceRoleChecks.every(roleInfo =>
+    roleInfo.available
+    && roleInfo.processCountPeak <= roleInfo.budget.processCountPeakMax
+    && roleInfo.cpuPercentP95 <= roleInfo.budget.cpuPercentP95Max
+    && roleInfo.cpuPercentPeak <= roleInfo.budget.cpuPercentPeakMax
+    && roleInfo.rssBytesPeak <= roleInfo.budget.rssBytesPeakMax
+  );
+  const resourceBudgetObserved = {
+    steadySamples: Math.max(0, Math.round(finite(steadyResources.sampleCount))),
+    ownedCpuPercentP95: Math.max(0, finite(steadyResources.ownedCpuPercentP95)),
+    ownedCpuPercentPeak: Math.max(0, finite(steadyResources.ownedCpuPercentPeak)),
+    ownedRssBytesPeak: Math.max(0, Math.round(finite(steadyResources.ownedRssBytesPeak))),
+    ownedProcessCountPeak: Math.max(0, Math.round(finite(steadyResources.ownedProcessCountPeak))),
+    ownedChildProcessCountPeak: Math.max(
+      0,
+      Math.round(finite(steadyResources.ownedChildProcessCountPeak))
+    ),
+    captureHelperCountPeak: Math.max(0, Math.round(resourceHelperPeak))
+  };
+  const resourceWithinBudget = resourceBudgetObserved.steadySamples
+      >= resourceBudget.minimumSteadySamples
+    && resourceBudgetObserved.ownedCpuPercentP95 <= resourceBudget.ownedCpuPercentP95Max
+    && resourceBudgetObserved.ownedCpuPercentPeak <= resourceBudget.ownedCpuPercentPeakMax
+    && resourceBudgetObserved.ownedRssBytesPeak <= resourceBudget.ownedRssBytesPeakMax
+    && resourceBudgetObserved.ownedProcessCountPeak <= resourceBudget.ownedProcessCountPeakMax
+    && resourceBudgetObserved.ownedChildProcessCountPeak
+      <= resourceBudget.ownedChildProcessCountPeakMax
+    && resourceBudgetObserved.captureHelperCountPeak
+      <= resourceBudget.captureHelperCountPeakMax
+    && resourceRolesWithinBudget;
   const highCpuProcesses = steadyProcesses
     .filter(processInfo =>
-      finite(processInfo?.cpuPercentP95) >= 80
-      || finite(processInfo?.cpuPercentPeak) >= 100
+      processInfo?.productProcess === true
+      && (
+        finite(processInfo?.cpuPercentP95) >= 80
+        || finite(processInfo?.cpuPercentPeak) >= 100
+      )
     )
     .map(processInfo => ({
       role: String(processInfo?.role || ''),
@@ -657,12 +1354,88 @@ export function classifyMacPhysicalGate(snapshot = {}) {
   const lifecycleRegistryFresh = Number.isFinite(lifecycleCompletedAtMs)
     && Number.isFinite(registrySampledAtMs)
     && registrySampledAtMs >= lifecycleCompletedAtMs;
+  const videoToolboxSessionMaxConcurrent = finite(
+    helper.videoToolboxSessionMaxConcurrent,
+    -1
+  );
+  const videoToolboxSessionFinalCount = finite(
+    helper.videoToolboxSessionFinalCount,
+    -1
+  );
+  const nativeTerminalLifecycle = helper.nativeTerminalLifecycle || {};
+  const finalHelperIdentity = lifecycle.finalHelperIdentity || {};
+  const finalHelperStartedAtMs = Date.parse(String(finalHelperIdentity.startedAt || ''));
+  const finalHelperObservedAtMs = Date.parse(String(finalHelperIdentity.observedAt || ''));
+  const finalStopRequestedAtMs = Date.parse(String(lifecycle.finalStopRequestedAt || ''));
+  const finalStopAcknowledgedAtMs = Date.parse(String(lifecycle.finalStopAcknowledgedAt || ''));
+  const terminalObservedAtMs = Date.parse(
+    String(nativeTerminalLifecycle.terminalObservedAt || '')
+  );
+  const nativeTerminalOwnerBound =
+    Number.isInteger(Number(finalHelperIdentity.observationId))
+    && finite(finalHelperIdentity.observationId) > 0
+    && Number.isInteger(Number(finalHelperIdentity.processId))
+    && finite(finalHelperIdentity.processId) > 1
+    && Number.isInteger(Number(finalHelperIdentity.osProcessId))
+    && finite(finalHelperIdentity.osProcessId) > 1
+    && finite(finalHelperIdentity.osProcessId) === finite(finalHelperIdentity.processId)
+    && helperPids.includes(finite(finalHelperIdentity.osProcessId))
+    && String(finalHelperIdentity.profileName || '').startsWith('macos-screencapturekit')
+    && Number.isFinite(finalHelperStartedAtMs)
+    && Number.isFinite(finalHelperObservedAtMs)
+    && finalHelperObservedAtMs >= finalHelperStartedAtMs
+    && String(finalHelperIdentity.streamPurpose || '') === 'wall'
+    && finite(finalHelperIdentity.captureGeneration)
+      === finite(lifecycle.restoredWallGeneration)
+    && String(finalHelperIdentity.streamId || '').length > 0
+    && String(finalHelperIdentity.streamId || '')
+      === String(lifecycle.finalStopStreamId || '')
+    && finite(nativeTerminalLifecycle.observationId)
+      === finite(finalHelperIdentity.observationId)
+    && finite(nativeTerminalLifecycle.processId)
+      === finite(finalHelperIdentity.processId)
+    && String(nativeTerminalLifecycle.profileName || '')
+      === String(finalHelperIdentity.profileName || '')
+    && Date.parse(String(nativeTerminalLifecycle.startedAt || '')) === finalHelperStartedAtMs
+    && Number.isFinite(finalStopRequestedAtMs)
+    && Number.isFinite(finalStopAcknowledgedAtMs)
+    && finalStopRequestedAtMs >= finalHelperObservedAtMs
+    && finalStopAcknowledgedAtMs >= finalStopRequestedAtMs
+    && lifecycleCompletedAtMs >= finalStopAcknowledgedAtMs
+    && Number.isFinite(terminalObservedAtMs)
+    && terminalObservedAtMs >= finalStopRequestedAtMs
+    && terminalObservedAtMs <= lifecycleCompletedAtMs
+    && registrySampledAtMs >= terminalObservedAtMs;
+  const nativeTerminalClean = nativeTerminalLifecycle.terminalTelemetryAvailable === true
+    && nativeTerminalLifecycle.terminalClean === true
+    && finite(nativeTerminalLifecycle.terminalTelemetryVersion) >= 5
+    && finite(nativeTerminalLifecycle.terminalEncodeFramesInFlight, -1) === 0
+    && finite(nativeTerminalLifecycle.terminalPendingEncodeFrameCount, -1) === 0
+    && finite(nativeTerminalLifecycle.terminalEncodeTimestampOwnerCount, -1) === 0
+    && finite(nativeTerminalLifecycle.terminalEncodeTimestampOwnerHighWatermark, -1) >= 1
+    && finite(nativeTerminalLifecycle.terminalEncodeTimestampOwnerHighWatermark, -1) <= 2
+    && finite(nativeTerminalLifecycle.terminalVideoToolboxActiveSessionCount, -1) === 0
+    && finite(nativeTerminalLifecycle.terminalVideoToolboxSessionHighWatermark, -1) === 1
+    && Number.isFinite(Date.parse(String(nativeTerminalLifecycle.terminalObservedAt || '')));
   const checks = [
     check(
       'report-schema',
-      schemaVersion === 3,
+      schemaVersion === 4,
       `v${schemaVersion || 'missing'}`
     ),
+    check(
+      'active-motion-profile',
+      activeMotionProfileMatches,
+      `${finite(motion.width)}x${finite(motion.height)}@${requestedFps} `
+        + `motion=${String(motion.kind || '-')} waiver=${motion.idleCadenceWaiverAllowed === true}`
+    ),
+    check(
+      'active-motion-operator',
+      activeMotionOperatorConfirmed,
+      activeMotionOperatorConfirmed
+        ? motion.operatorRequirement
+        : 'pass --confirm-active-motion after starting continuous motion on both displays'
+    ),
     check(
       'diagnostic-run',
       !runError,
@@ -712,6 +1485,13 @@ export function classifyMacPhysicalGate(snapshot = {}) {
         + `max=${finite(lifecycle.registryMaxConcurrent, -1)} `
         + `final=${finite(lifecycle.registryFinalHelperCount, -1)}`
     ),
+    check(
+      'capture-lifecycle-sequential-restarts',
+      finite(lifecycle.registryHelperStartCount, -1) === 4
+        && finite(lifecycle.registryHelperStopCount, -1) === 4,
+      `starts=${finite(lifecycle.registryHelperStartCount, -1)} `
+        + `stops=${finite(lifecycle.registryHelperStopCount, -1)} expected=4/4`
+    ),
     check(
       'capture-lifecycle-stop',
       lifecycle.controlStopConfirmed === true
@@ -734,6 +1514,16 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       stageEvidenceAvailable,
       stageEvidenceAvailable ? requiredStageNames.join(',') : 'initial and switched stages required'
     ),
+    check(
+      'active-motion-proof',
+      activeMotionProven,
+      stageEvaluations.map(stage =>
+        `${stage.name}=${stage.motionProven ? 'proven' : 'unproven'} `
+        + `pixels=${finite(stage.motionProof.distinctDecodedPixelHashCount)} `
+        + `au=${finite(stage.motionProof.distinctAccessUnitHashCount)} `
+        + `native=${finite(stage.motionProof.captureSampleDelta)}`
+      ).join(' ')
+    ),
     check(
       'native-profile',
       snapshot.platformProfile === 'macos-screencapturekit-nv12-videotoolbox',
@@ -760,6 +1550,18 @@ export function classifyMacPhysicalGate(snapshot = {}) {
         .map(stage => `${stage.name}=${stage.hardwareAccelerated ? 'hardware' : 'not-confirmed'}`)
         .join(' ')
     ),
+    check(
+      'native-encode-ownership',
+      nativeEncodeOwnershipBounded,
+      stageEvaluations.map(stage =>
+        `${stage.name}=inFlight:${stage.encodeFramesInFlight}`
+        + `/pending:${stage.pendingEncodeFrameCount}`
+        + `/timestampOwners:${stage.encodeTimestampOwnerCount}`
+        + `/timestampOwnerHigh:${stage.encodeTimestampOwnerHighWatermark}`
+        + `/vt:${stage.videoToolboxActiveSessionCount}`
+        + `/high:${stage.videoToolboxSessionHighWatermark}`
+      ).join(' ')
+    ),
     check(
       'screencapturekit-fps',
       captureAtTarget,
@@ -791,7 +1593,37 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       'delivered-fps',
       deliveredAtTarget,
       `${stageMetricDetail('deliveredFps')} target=${requestedFps}`
-        + `${idleOptimized ? ' idle-dominant-stage' : ''}`
+        + `${idleOptimized ? ' idle-detected-active-gate' : ''}`
+    ),
+    check(
+      'encode-backpressure',
+      backpressureFree,
+      stageEvaluations
+        .map(stage => `${stage.name}=${stage.backpressureSkipped}`)
+        .join(' ')
+    ),
+    check(
+      'current-frame-queue-pressure',
+      currentFrameQueuesBounded,
+      stageEvaluations.map(stage =>
+        `${stage.name}=nativeDrop:${stage.outputDropped}`
+        + `/nativeOldest:${stage.outputOldestAgeMs}`
+        + `/nativeAwait:${stage.telemetry.outputAwaitingKeyFrame === true ? 1 : 0}`
+        + `/age:${stage.nativeAndPipeResidenceAgeMs}`
+        + `/handoffDrop:${stage.handoffDropped}`
+        + `/recovery:${stage.handoffRecoveryRequests}`
+        + `/handoffOldest:${stage.handoffOldestAgeMs}`
+      ).join(' ')
+    ),
+    check(
+      'payload-copy-accounting',
+      payloadCopyAccountingCurrent,
+      stageEvaluations.map(stage =>
+        `${stage.name}=annexB:${stage.annexBAllocations}`
+        + `/${stage.annexBPayloadCopies}/${stage.annexBPayloadCopiedBytes}`
+        + ` pipe:${stage.pipePayloadAllocations}`
+        + `/${stage.pipePayloadCopies}/${stage.pipePayloadCopiedBytes}`
+      ).join(' ')
     ),
     check(
       'single-helper',
@@ -799,17 +1631,70 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       `max=${resourceHelperPeak} pids=${helperPids.join(',') || '-'}`
     ),
     check('helper-drained', finite(helper.finalCount) === 0, `final=${finite(helper.finalCount)}`),
+    check(
+      'single-videotoolbox-session',
+      videoToolboxSessionMaxConcurrent === 1
+        && videoToolboxSessionFinalCount === 0,
+      `max=${videoToolboxSessionMaxConcurrent} final=${videoToolboxSessionFinalCount} `
+        + 'proof=one-session-per-exact-helper'
+    ),
+    check(
+      'videotoolbox-terminal-cleanup',
+      nativeTerminalClean,
+      `available=${nativeTerminalLifecycle.terminalTelemetryAvailable === true} `
+        + `clean=${nativeTerminalLifecycle.terminalClean === true} `
+        + `v=${finite(nativeTerminalLifecycle.terminalTelemetryVersion)} `
+        + `inFlight=${finite(nativeTerminalLifecycle.terminalEncodeFramesInFlight, -1)} `
+        + `pending=${finite(nativeTerminalLifecycle.terminalPendingEncodeFrameCount, -1)} `
+        + `timestampOwners=${finite(nativeTerminalLifecycle.terminalEncodeTimestampOwnerCount, -1)} `
+        + `timestampOwnerHigh=${finite(nativeTerminalLifecycle.terminalEncodeTimestampOwnerHighWatermark, -1)} `
+        + `vt=${finite(nativeTerminalLifecycle.terminalVideoToolboxActiveSessionCount, -1)} `
+        + `high=${finite(nativeTerminalLifecycle.terminalVideoToolboxSessionHighWatermark, -1)}`
+    ),
+    check(
+      'videotoolbox-terminal-owner',
+      nativeTerminalOwnerBound,
+      `observation=${finite(finalHelperIdentity.observationId)}/${finite(nativeTerminalLifecycle.observationId)} `
+        + `pid=${finite(finalHelperIdentity.processId)}/${finite(nativeTerminalLifecycle.processId)} `
+        + `os=${finite(finalHelperIdentity.osProcessId)}`
+        + `/${helperPids.includes(finite(finalHelperIdentity.osProcessId)) ? 'observed' : 'missing'} `
+        + `profile=${String(finalHelperIdentity.profileName || '-') === String(nativeTerminalLifecycle.profileName || '-') ? 'match' : 'mismatch'} `
+        + `generation=${finite(finalHelperIdentity.captureGeneration)}/${finite(lifecycle.restoredWallGeneration)} `
+        + `purpose=${String(finalHelperIdentity.streamPurpose || '-')} `
+        + `stream=${String(finalHelperIdentity.streamId || '') === String(lifecycle.finalStopStreamId || '') ? 'match' : 'mismatch'} `
+        + `stop=${String(lifecycle.finalStopRequestedAt || '-')} `
+        + `terminal=${String(nativeTerminalLifecycle.terminalObservedAt || '-')}`
+    ),
     check(
       'process-telemetry',
       resourceTelemetryAvailable,
       resourceTelemetryAvailable
-        ? `baseline=${finite(baselineResources.sampleCount)} steady=${finite(steadyResources.sampleCount)} cleanup=${finite(cleanupResources.sampleCount)}`
-        : 'baseline, steady-capture, and after-cleanup samples are required'
+        ? `baseline=${finite(baselineResources.sampleCount)} prime=${finite(startupPrimeResources.sampleCount)} steady=${finite(steadyResources.sampleCount)} cleanup=${finite(cleanupResources.sampleCount)}`
+        : 'baseline, cold startup-prime, steady-capture, and after-cleanup samples are required'
+    ),
+    check(
+      'startup-prime-resource-budget',
+      resourceTelemetryAvailable && startupPrimeWithinBudget,
+      `samples=${startupPrimeObserved.samples}/${startupPrimeBudget.minimumSamples} `
+        + `duration=${startupPrimeObserved.durationMs}/${startupPrimeBudget.maximumDurationMs}ms `
+        + `cpu-p95=${startupPrimeObserved.ownedCpuPercentP95}`
+        + `/${startupPrimeBudget.ownedCpuPercentP95Max}% `
+        + `cpu-peak=${startupPrimeObserved.ownedCpuPercentPeak}`
+        + `/${startupPrimeBudget.ownedCpuPercentPeakMax}% `
+        + `rss=${startupPrimeObserved.ownedRssBytesPeak}`
+        + `/${startupPrimeBudget.ownedRssBytesPeakMax} `
+        + `processes=${startupPrimeObserved.ownedProcessCountPeak}`
+        + `/${startupPrimeBudget.ownedProcessCountPeakMax} `
+        + `children=${startupPrimeObserved.ownedChildProcessCountPeak}`
+        + `/${startupPrimeBudget.ownedChildProcessCountPeakMax}`
     ),
     check(
       'resource-ownership',
       resourceTelemetryAvailable && resourceOwnershipCurrent,
-      `baseline=${finite(baselineResources.totalLiveDeskProcessCountPeak)} `
+      `model=${String(resources.ownershipModel || '-')} `
+        + `labels=${resourceOwnershipLabelsCurrent ? 'exact' : 'invalid'} `
+        + `topology=${exactSteadyTopologyCurrent ? '5/3' : `${steadyOwnedProcessCounts.join(',') || '-'}/${steadyOwnedChildCounts.join(',') || '-'}`} `
+        + `baseline=${finite(baselineResources.totalLiveDeskProcessCountPeak)} `
         + `steady=${finite(steadyResources.totalLiveDeskProcessCountPeak)} `
         + `unowned=${Array.isArray(steadyResources.unownedLiveDeskPids) ? steadyResources.unownedLiveDeskPids.join(',') || '-' : '-'}`
     ),
@@ -819,6 +1704,36 @@ export function classifyMacPhysicalGate(snapshot = {}) {
       `final=${finite(cleanupResources.totalLiveDeskProcessCount)} `
         + `peak=${finite(cleanupResources.totalLiveDeskProcessCountPeak)}`
     ),
+    check(
+      'active-motion-resource-budget',
+      resourceTelemetryAvailable && resourceWithinBudget,
+      `samples=${resourceBudgetObserved.steadySamples}/${resourceBudget.minimumSteadySamples} `
+        + `cpu-p95=${resourceBudgetObserved.ownedCpuPercentP95}`
+        + `/${resourceBudget.ownedCpuPercentP95Max}% `
+        + `cpu-peak=${resourceBudgetObserved.ownedCpuPercentPeak}`
+        + `/${resourceBudget.ownedCpuPercentPeakMax}% `
+        + `rss=${resourceBudgetObserved.ownedRssBytesPeak}`
+        + `/${resourceBudget.ownedRssBytesPeakMax} `
+        + `processes=${resourceBudgetObserved.ownedProcessCountPeak}`
+        + `/${resourceBudget.ownedProcessCountPeakMax} `
+        + `children=${resourceBudgetObserved.ownedChildProcessCountPeak}`
+        + `/${resourceBudget.ownedChildProcessCountPeakMax} `
+        + resourceRoleChecks.map(roleInfo =>
+          `${roleInfo.role}:cpu=${roleInfo.cpuPercentP95}/${roleInfo.budget.cpuPercentP95Max}`
+          + ` rss=${roleInfo.rssBytesPeak}/${roleInfo.budget.rssBytesPeakMax}`
+          + ` proc=${roleInfo.processCountPeak}/${roleInfo.budget.processCountPeakMax}`
+        ).join(' ')
+    ),
+    check(
+      'resource-baseline-return',
+      resourceTelemetryAvailable && resourceReturnedToBaseline,
+      `processes=${finite(baselineResources.ownedProcessCountPeak)}`
+        + `->${finite(cleanupResources.ownedProcessCountPeak)} `
+        + `children=${finite(baselineResources.ownedChildProcessCountPeak)}`
+        + `->${finite(cleanupResources.ownedChildProcessCountPeak)} `
+        + `rss=${finite(baselineResources.ownedRssBytesPeak)}`
+        + `->${finite(cleanupResources.ownedRssBytesPeak)}`
+    ),
     check('two-monitors', finite(monitor.count) >= 2, `count=${finite(monitor.count)}`),
     check(
       'monitor-generation',
@@ -862,6 +1777,8 @@ export function classifyMacPhysicalGate(snapshot = {}) {
   const failed = checks.filter(item => !item.ok);
   const bottleneckByCheck = {
     'report-schema': 'report-schema',
+    'active-motion-profile': 'active-motion-profile',
+    'active-motion-operator': 'active-motion-operator',
     'diagnostic-run': 'diagnostic-run',
     'diagnostic-cleanup': 'diagnostic-cleanup',
     'capture-lifecycle-order': 'capture-lifecycle-order',
@@ -869,22 +1786,34 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     'capture-lifecycle-pause': 'capture-pause-resume',
     'capture-lifecycle-helper': 'capture-helper-lifecycle',
     'capture-lifecycle-registry': 'capture-helper-registry',
+    'capture-lifecycle-sequential-restarts': 'capture-helper-restart-storm',
     'capture-lifecycle-stop': 'capture-stop',
     'first-frame': 'capture-startup',
     'monitor-first-frame': 'monitor-restart',
     'capture-stage-evidence': 'capture-stage-evidence',
+    'active-motion-proof': 'active-motion-not-proven',
     'native-profile': 'capture-fallback',
     'telemetry-current': 'native-telemetry-stale',
     'hardware-videotoolbox': 'videotoolbox-software',
+    'native-encode-ownership': 'videotoolbox-ownership',
     'screencapturekit-fps': 'screencapturekit',
     'videotoolbox-fps': 'videotoolbox',
     'stdout-fps': 'native-stdout',
     'delivered-fps': 'agent-or-transport',
+    'encode-backpressure': 'videotoolbox-backpressure',
+    'current-frame-queue-pressure': 'current-frame-queue-pressure',
+    'payload-copy-accounting': 'payload-copy-accounting',
     'single-helper': 'duplicate-helper',
     'helper-drained': 'stale-helper',
+    'single-videotoolbox-session': 'videotoolbox-ownership',
+    'videotoolbox-terminal-cleanup': 'videotoolbox-terminal-cleanup',
+    'videotoolbox-terminal-owner': 'videotoolbox-terminal-owner',
     'process-telemetry': 'process-telemetry',
+    'startup-prime-resource-budget': 'startup-prime-resource-budget',
     'resource-ownership': 'resource-ownership',
     'resource-drained': 'resource-not-drained',
+    'active-motion-resource-budget': 'resource-budget',
+    'resource-baseline-return': 'resource-not-returned',
     'two-monitors': 'monitor-topology',
     'monitor-generation': 'monitor-generation',
     'monitor-native-identity': 'monitor-binding',
@@ -899,7 +1828,16 @@ export function classifyMacPhysicalGate(snapshot = {}) {
     processTelemetry: {
       available: resourceTelemetryAvailable,
       highLoad: highCpuProcesses.length > 0,
-      highLoadProcesses: highCpuProcesses
+      highLoadProcesses: highCpuProcesses,
+      budget: { ...resourceBudget },
+      observed: resourceBudgetObserved,
+      startupPrime: {
+        budget: { ...startupPrimeBudget },
+        observed: startupPrimeObserved,
+        withinBudget: startupPrimeWithinBudget
+      },
+      roles: resourceRoleChecks,
+      returnedToBaseline: resourceReturnedToBaseline
     },
     checks
   };