@aopslabs/aops 0.3.23 → 0.3.24

package/agent-assets-release/agent-assets/core/647c6e84fbc48f9a36945d81660f4d2a5241f58a53a18054365bfc16868b0f09/manifest.json

@@ -117,6 +117,6 @@
   },
   "schemaVersion": 1,
   "standard": "aops-community-core-v1",
-  "version": "0.3.23",
-  "versionId": "community-core-0.3.23"
+  "version": "0.3.24",
+  "versionId": "community-core-0.3.24"
 }

package/agent-assets-release/agent-assets/inventory.json

@@ -10,8 +10,8 @@
     "name": "aops",
     "optional": false,
     "packageSha256": "647c6e84fbc48f9a36945d81660f4d2a5241f58a53a18054365bfc16868b0f09",
-    "version": "0.3.23",
-    "versionId": "community-core-0.3.23"
+    "version": "0.3.24",
+    "versionId": "community-core-0.3.24"
   },
   "gateway": {
     "byteLength": 621,
@@ -22,7 +22,7 @@
   "kind": "aops-community-agent-assets-inventory-v1",
   "schemaVersion": 1,
   "source": {
-    "commit": "ca16ea2f40b73185a126494df49ad4883c091fd5",
+    "commit": "608842f09f9479d542bac1bb6aa5034dd0002fd4",
     "repository": "git+https://github.com/eeemzs/aops-platform",
     "root": "apps/aops-cli/assets/agent-assets"
   }

package/agent-assets-release/agent-assets-release.json

@@ -11,8 +11,8 @@
       "name": "aops",
       "optional": false,
       "packageSha256": "647c6e84fbc48f9a36945d81660f4d2a5241f58a53a18054365bfc16868b0f09",
-      "version": "0.3.23",
-      "versionId": "community-core-0.3.23"
+      "version": "0.3.24",
+      "versionId": "community-core-0.3.24"
     },
     "files": [
       {
@@ -123,7 +123,7 @@
       {
         "byteLength": 3978,
         "ref": "agent-assets/core/647c6e84fbc48f9a36945d81660f4d2a5241f58a53a18054365bfc16868b0f09/manifest.json",
-        "sha256": "c8131d55a080c16afdb08d6203b8a63251fbaad3fde7411ca0c52db3579030cb"
+        "sha256": "ac7e50f6d7ee959d309784edadeed6138980307f47c895cc79f3684bb91ea566"
       },
       {
         "byteLength": 621,
@@ -133,7 +133,7 @@
       {
         "byteLength": 926,
         "ref": "agent-assets/inventory.json",
-        "sha256": "c16355c67f2ca0a0b9cd7c5dc0e9fe0f0292dea4d7ab4430bf49f8cad26e644c"
+        "sha256": "eabd4cb45defd761d6c91b5383f80351a59162d49fa3996a47e134e7965fb2ab"
       },
       {
         "byteLength": 281,
@@ -149,7 +149,7 @@
     },
     "inventory": {
       "ref": "agent-assets/inventory.json",
-      "sha256": "c16355c67f2ca0a0b9cd7c5dc0e9fe0f0292dea4d7ab4430bf49f8cad26e644c"
+      "sha256": "eabd4cb45defd761d6c91b5383f80351a59162d49fa3996a47e134e7965fb2ab"
     },
     "kind": "aops-community-agent-assets-release-v1",
     "projection": {
@@ -158,7 +158,7 @@
     },
     "root": "agent-assets",
     "schemaVersion": 1,
-    "setSha256": "d603ef7fb337dd0b9b69f7b955989ec6ec80a7c4cb98f0b27183010d06146f29"
+    "setSha256": "554203cf8d06ba4ca792e79a5a616b3ceaaa3c50b840e65745d87433cc43ce95"
   },
   "evidence": {
     "signature": {
@@ -166,10 +166,10 @@
     }
   },
   "kind": "aops-community-agent-assets-bundle-v1",
-  "releaseVersion": "0.3.23",
+  "releaseVersion": "0.3.24",
   "schemaVersion": 1,
   "source": {
-    "commit": "ca16ea2f40b73185a126494df49ad4883c091fd5",
+    "commit": "608842f09f9479d542bac1bb6aa5034dd0002fd4",
     "repository": "git+https://github.com/eeemzs/aops-platform",
     "root": "apps/aops-cli/assets/agent-assets"
   }

package/agent-assets-release/agent-assets-release.sigstore.json

@@ -4,13 +4,13 @@
     "x509CertificateChain": {
       "certificates": [
         {
-          "rawBytes": "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"
+          "rawBytes": "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"
         }
       ]
     },
     "tlogEntries": [
       {
-        "logIndex": "2496923676",
+        "logIndex": "2501603598",
         "logId": {
           "keyId": "wNI9atQGlz+VWfO6LRygH4QUfY/8W4RFwiT5i5WRgB0="
         },
@@ -18,31 +18,28 @@
           "kind": "hashedrekord",
           "version": "0.0.1"
         },
-        "integratedTime": "1786955059",
+        "integratedTime": "1787050507",
         "inclusionPromise": {
-          "signedEntryTimestamp": "MEQCIAwYgvet0QhdU+0sab339djURwhc02dqUeczR3Djxeh6AiAYzJi/wt5yn4jH6fMxUNy6yEibNhUcI1Utlv/YT3pxTQ=="
+          "signedEntryTimestamp": "MEQCIBmNzj9XxKBpaqvsYHJdQuuBJmC3CFTb1ymB/wT4v2FrAiB+PXmrkgK7nivM0W5CFuPrGdQanm94uTZlSYKfkantQA=="
         },
         "inclusionProof": {
-          "logIndex": "2375019414",
-          "rootHash": "1IhSyO9LuJsXp4+LouxnhVNk1qxoEN5K6R+qlT5JcAw=",
-          "treeSize": "2375019420",
+          "logIndex": "2379699336",
+          "rootHash": "YBqB3LPP7z3XiaRq2ot4MJFVi+bFDVkUMph/hC1IDfU=",
+          "treeSize": "2379699344",
           "hashes": [
-            "1lcDoWCuU0ZryC48fV92JsWXiKUrGP6K+N0l1S2cwic=",
-            "6KU0t9wzQ9UTCRK4LjUzN/Cn2ppRpEIA/VgSSSXsOa4=",
-            "uNcm+KnEMiXph9+jKRwgdEy10pxYy3OCZCywcXWm+sY=",
-            "QbsTY+/VuDNOabZRMUBLWZ05IBVJBiPYAgPj6iCXXpo=",
-            "DGdyZuKSWMLmOqAq+rDuvDzFZGyQTg0FAr9uvQLw3/c=",
-            "PvgmuENb2EpHATFzVEb76dlVMxZbkulfujl8lX9OuXk=",
-            "CioIeHI5xrZZmT44FUv/Q8SArLvHBnR0gsvIV7rAE+M=",
-            "zKkaTQOlbK1wYyjYfIrAK6O94yREtvgSj8+whe+Gp1Q=",
-            "/zBUG2Mf+Idzcv4QJncssZ1EK2C9oTWoWcIrBlnTSDc=",
-            "H7rj+52anAGwsH2w7iJw9RikbV9kCMiHVjWb9g8EtVw=",
-            "DIZ1PKLUjpkt6Pzn4ex1eYRKdMPYOdlax0lMduqv+bA=",
-            "M37U32DNWM5gQ+tJGFZkumfFxm+SWzWZIyxGrkd+ecA=",
-            "YPztLJ/GLmbbWAUdMzJlIzYK0VbVVauzuvV9Q4L7HPk=",
-            "3Q5lN6yq8podpJsAKbBJqSGNs+rmiL9QwZbQ0UH+3zQ=",
-            "fA/Fxwaq7dI1l5khmfZO/yXBJ/beTLDtlbUbvr3BnMI=",
-            "D2gSVC/Ew66euzf7kcNDzk5ThToLAkj5W34g+R2yIAQ=",
+            "njwwRR8CkW8qKsjNsTk2DmWb1d0QYVnDjoaFjnNiZcM=",
+            "VqADwLGk4e4wYy+SINhpx8di8xs/yXzC+8hp57515DQ=",
+            "KNNPpwh23nPcjbq8p5KBXjTXlnGR4xCBaYpvJypOGIM=",
+            "WeDaME+8oVrLbuTd5pesPBQyNEAJI32luWOTYeZlAvg=",
+            "lVWszKQLwZ+PwxkyaYfq05JuVEF7HtUP2bXechNYO1w=",
+            "PMq4/z5Dji4lnm1dN9aik+bf21gQHuaV0DvEF2DRfK4=",
+            "jw/BXoahnA99/KDbOEXR342svCgXlI8fBQ1EdfoP0rY=",
+            "V2ZRaYqGvqopvORHedITMz+sBSInRp6SKdmpIyoE4c0=",
+            "2ccjkNTG2bujC4xzJzdJCckwqIh5Q4aSWapj9M4EG/Y=",
+            "TyajcYUKvFL3MiVt2E0QMAVavx7MDeqclu7zuKIHKWA=",
+            "hwAkEuPLcomSOf+KiIMjdoM4HdEqmumZzGAuuolVGdk=",
+            "lVKLLzp8tNcT7yWZhGMjc/Cer1kKYS71H/n0sNutLzk=",
+            "1dSZjpCCNpV0knAvzBTUqXzpyGFhCaJkg0vBf6yDS/s=",
             "9PAe2QaxB0ZutC/Y+HQKC6Wnag9Df+yGa0xYuRz5f1w=",
             "dGyfnQgNT9mPiDmeuOaMmiIIn2XY7kncEgQ/mDW3SJU=",
             "1OEC0KMekWr1AbpIDYXYCOXzf6aK8hYAK01U3ypm0is=",
@@ -50,10 +47,10 @@
             "xH/DCseLHr9eKoYT8qsORZK7zVdEGYWHuVtsVrD95wY="
           ],
           "checkpoint": {
-            "envelope": "rekor.sigstore.dev - 1193050959916656506\n2375019420\n1IhSyO9LuJsXp4+LouxnhVNk1qxoEN5K6R+qlT5JcAw=\n\n— rekor.sigstore.dev wNI9ajBFAiA/3xFOdX6QXZNZjx3kpJ1y2m7/Gmg1PFYxxFZYff3nfgIhAPM8qWzmZyTzffF5m2aClQ6Szz3wyHoMwommTTu5yUFr\n"
+            "envelope": "rekor.sigstore.dev - 1193050959916656506\n2379699344\nYBqB3LPP7z3XiaRq2ot4MJFVi+bFDVkUMph/hC1IDfU=\n\n— rekor.sigstore.dev wNI9ajBGAiEA74PW9f4HTjAKRYHz4Up0pM3rkbma8803/TlH/8V0IF0CIQC2DmHPhZ7X0Jf8QQNood1Ud3VsmTmJpY7aXZYQ2el1/A==\n"
           }
         },
-        "canonicalizedBody": "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"
+        "canonicalizedBody": "eyJhcGlWZXJzaW9uIjoiMC4wLjEiLCJraW5kIjoiaGFzaGVkcmVrb3JkIiwic3BlYyI6eyJkYXRhIjp7Imhhc2giOnsiYWxnb3JpdGhtIjoic2hhMjU2IiwidmFsdWUiOiIzY2Q0YzYzYjI3YzdhYWI1NGVmMGFjZTllYmNkNTQ5YzgyNjYyZTc1ZDUzNmVjNjRjMjcyNzNmZDRhMDUwZTM1In19LCJzaWduYXR1cmUiOnsiY29udGVudCI6Ik1FVUNJUUNpb2d4R01HMkkrZ1ZudnBNanhUa0I4cTR2cEc3TFFPQjJEdVJVb3YzQmV3SWdQZG15WkpQandKZnJscDdRazM0aTltN3hYWUV5SU5PSzZGbmp0VzF0aDQ4PSIsInB1YmxpY0tleSI6eyJjb250ZW50IjoiTFMwdExTMUNSVWRKVGlCRFJWSlVTVVpKUTBGVVJTMHRMUzB0Q2sxSlNVaGtSRU5EUW5aeFowRjNTVUpCWjBsVlNUUm1VakU0VUdScFVuaFBPRVpoY1VkTmVtRnhORGQyV2tKUmQwTm5XVWxMYjFwSmVtb3dSVUYzVFhjS1RucEZWazFDVFVkQk1WVkZRMmhOVFdNeWJHNWpNMUoyWTIxVmRWcEhWakpOVWpSM1NFRlpSRlpSVVVSRmVGWjZZVmRrZW1SSE9YbGFVekZ3WW01U2JBcGpiVEZzV2tkc2FHUkhWWGRJYUdOT1RXcFpkMDlFUlRSTlZFRXhUbFJCTTFkb1kwNU5hbGwzVDBSRk5FMVVSWGRPVkVFelYycEJRVTFHYTNkRmQxbElDa3R2V2tsNmFqQkRRVkZaU1V0dldrbDZhakJFUVZGalJGRm5RVVZuZDFCNk5qZGhNMnh5WldFeVkzQlllakprTTJ3NGQyZFJZVWRyWWpsdGFHSmhSRklLU1RWTFNXSk5LMGxVY1RJMGNGWkRkbXg1VkdwUU4xRTNZMWd6VTJoSFVFeFZiR0pzTWxGQmNFTjZTbnBNVUROWFpVdFBRMEpvYTNkbloxbFdUVUUwUndwQk1WVmtSSGRGUWk5M1VVVkJkMGxJWjBSQlZFSm5UbFpJVTFWRlJFUkJTMEpuWjNKQ1owVkdRbEZqUkVGNlFXUkNaMDVXU0ZFMFJVWm5VVlZOTUVoWENuQklUMHAzVm1oT01sWjJjaTgzWkcweVNsUlZlVGM0ZDBoM1dVUldVakJxUWtKbmQwWnZRVlV6T1ZCd2VqRlphMFZhWWpWeFRtcHdTMFpYYVhocE5Ga0tXa1E0ZDJSQldVUldVakJTUVZGSUwwSkhiM2RoU1ZwdFlVaFNNR05JVFRaTWVUbHVZVmhTYjJSWFNYVlpNamwwVERKV2JGcFhNVFpqZVRsb1lqTkNlZ3BNV0VKeldWaFNiV0l6U25STWVUVnVZVmhTYjJSWFNYWmtNamw1WVRKYWMySXpaSHBNTTA1d1dqSTBkR05JVm1saVIyeHFURmRHYmxwWE5UQk1WMFo2Q21NeVZqQmplVFUxWWxkNFFXTnRWbTFqZVRsdldsZEdhMk41T1hSWlYyeDFUVVJyUjBOcGMwZEJVVkZDWnpjNGQwRlJSVVZMTW1nd1pFaENlazlwT0hZS1pFYzVjbHBYTkhWWlYwNHdZVmM1ZFdONU5XNWhXRkp2WkZkS01XTXlWbmxaTWpsMVpFZFdkV1JETldwaU1qQjNTSGRaUzB0M1dVSkNRVWRFZG5wQlFncEJaMUZTWkRJNWVXRXlXbk5pTTJSbVdrZHNlbU5IUmpCWk1tZDNUbWRaUzB0M1dVSkNRVWRFZG5wQlFrRjNVVzlPYWtFMFQwUlJlVnBxUVRWYWFtc3dDazU2Ykd0T1ZGRjVXVzFHYWsxWFNtbE9iVVpvVGxSQmVrNUhVbXROUkVGM1RXMWFhMDVFUVhoQ1oyOXlRbWRGUlVGWlR5OU5RVVZGUWtOT1ZHRlhaSFVLU1VkV05GbFhUakJKU0VJeFdXMTRjRmw1UWtKVU1VSlVTVWRHYmxwWE5UQkpSMFo2WXpKV01HTjZRV2xDWjI5eVFtZEZSVUZaVHk5TlFVVkdRa0pTYkFwYVYxWjBaVzVOZGxsWE9YZGplVEYzWWtkR01GcHRPWGxpVkVGa1FtZHZja0puUlVWQldVOHZUVUZGUjBKQk9YbGFWMXA2VERKb2JGbFhVbnBNTWpGb0NtRlhOSGRQZDFsTFMzZFpRa0pCUjBSMmVrRkNRMEZSZEVSRGRHOWtTRkozWTNwdmRrd3pVblpoTWxaMVRHMUdhbVJIYkhaaWJrMTFXakpzTUdGSVZta0taRmhPYkdOdFRuWmlibEpzWW01UmRWa3lPWFJOU0ZsSFEybHpSMEZSVVVKbk56aDNRVkZyUldGQmVHMWhTRkl3WTBoTk5reDVPVzVoV0ZKdlpGZEpkUXBaTWpsMFRESldiRnBYTVRaamVUbG9Zak5DZWt4WVFuTlpXRkp0WWpOS2RFeDVOVzVoV0ZKdlpGZEpkbVF5T1hsaE1scHpZak5rZWt3elRuQmFNalIwQ21OSVZtbGlSMnhxVEZkR2JscFhOVEJNVjBaNll6SldNR041TlRWaVYzaEJZMjFXYldONU9XOWFWMFpyWTNrNWRGbFhiSFZOUkdkSFEybHpSMEZSVVVJS1p6YzRkMEZSYjBWTFozZHZUbXBCTkU5RVVYbGFha0UxV21wck1FNTZiR3RPVkZGNVdXMUdhazFYU21sT2JVWm9UbFJCZWs1SFVtdE5SRUYzVFcxYWF3cE9SRUZrUW1kdmNrSm5SVVZCV1U4dlRVRkZURUpCT0UxRVYyUndaRWRvTVZscE1XOWlNMDR3V2xkUmQwNTNXVXRMZDFsQ1FrRkhSSFo2UVVKRVFWRndDa1JEWkc5a1NGSjNZM3B2ZGt3eVpIQmtSMmd4V1drMWFtSXlNSFphVjFac1lsaHdla3d5Um5aalNFMTBZMGQ0YUdSSFduWmpiVEIzVDBGWlMwdDNXVUlLUWtGSFJIWjZRVUpFVVZGeFJFTm5NazFFWnpST1JFcHRUVVJzYlU5VVVUTlBWMUV4VGtSS2FWbFhUWGhaYlVreVdWZEZNVTFFVFRCYVIxRjNUVVJCZVFwYWJWRXdUVUk0UjBOcGMwZEJVVkZDWnpjNGQwRlJORVZGVVhkUVkyMVdiV041T1c5YVYwWnJZM2s1ZEZsWGJIVk5RbTlIUTJselIwRlJVVUpuTnpoM0NrRlJPRVZFUVhkTFRWUk5lRTVxU1RGT1ZFRjVUbXBCY0VKbmIzSkNaMFZGUVZsUEwwMUJSVkZDUW5OTlIxZG9NR1JJUW5wUGFUaDJXakpzTUdGSVZta0tURzFPZG1KVE9XeGFWMVowWlc1TmQwZFJXVXRMZDFsQ1FrRkhSSFo2UVVKRlVWRk1SRUZyZUUxRWEzcE5WRUV6VG5wUmQyUm5XVXRMZDFsQ1FrRkhSQXAyZWtGQ1JXZFNiMFJIV205a1NGSjNZM3B2ZGt3eVpIQmtSMmd4V1drMWFtSXlNSFphVjFac1lsaHdla3d5Um5aalNFMTBZMGQ0YUdSSFduWmpiVEIyQ2t4dFpIQmtSMmd4V1drNU0ySXpTbkphYlhoMlpETk5kbU15Ykc1aWFURjNaRmRLYzJGWFRYUlpWMlJzWW01UmRGbFlUbnBhV0ZKNlRHNXNkR0pGUW5rS1dsZGFla3d5YUd4WlYxSjZUREl4YUdGWE5IZFBRVmxMUzNkWlFrSkJSMFIyZWtGQ1JYZFJjVVJEWnpKTlJHYzBUa1JLYlUxRWJHMVBWRkV6VDFkUk1RcE9SRXBwV1ZkTmVGbHRTVEpaVjBVeFRVUk5NRnBIVVhkTlJFRjVXbTFSTUUxRFJVZERhWE5IUVZGUlFtYzNPSGRCVWxGRlJYZDNVbVF5T1hsaE1scHpDbUl6WkdaYVIyeDZZMGRHTUZreVozZFhkMWxMUzNkWlFrSkJSMFIyZWtGQ1JsRlNUa1JGZEc5a1NGSjNZM3B2ZGt3eVpIQmtSMmd4V1drMWFtSXlNSFlLV2xkV2JHSlljSHBNTWtaMlkwaE5kR05IZUdoa1IxcDJZMjB3ZGxsWFRqQmhWemwxWTNrNWVXUlhOWHBNZWsxNVRWUkpOVTFFVVRGT1JFRXlUREpHTUFwa1IxWjBZMGhTZWt4NlJYZEdkMWxMUzNkWlFrSkJSMFIyZWtGQ1JtZFJTa1JCWkhkamJXd3lXVmhTYkUxR1NVZERhWE5IUVZGUlFtYzNPSGRCVW1kRkNsSkJlRU5qYlZaM1lucHdiRnBYVm5SbGJrNUJUVlJCTlUxNlJYZE9lbU13VERKR2RtTklUWFJqUjNob1pFZGFkbU50TVVGTlZFMTRUbXBKTVU1VVFYa0tUbXB3ZVZwWFdUWmpiVlp0WTNrNWIxcFhSbXRqZVRsMFdWZHNkVTFKUjB0Q1oyOXlRbWRGUlVGa1dqVkJaMUZEUWtoM1JXVm5RalJCU0ZsQk0xUXdkd3BoYzJKSVJWUktha2RTTkdOdFYyTXpRWEZLUzFoeWFtVlFTek12YURSd2VXZERPSEEzYnpSQlFVRkhaMFpKU3l0RFFVRkJRa0ZOUVZKNlFrWkJhVVZCQ25rNVMyTlpOMjlNVTBKR1pUaG5WMjFEV0VoaGFuZHJNelJzY2tkTGJWTlphVGNyV2pCM1dWcDNVRFJEU1VWTVlXNXJWV1pYWW5Sdk1HZGhLelIzVFRnS1lYQkpielpITjJvcmNVNVpaV3d2VEdnMFVISm1VR3h0VFVGdlIwTkRjVWRUVFRRNVFrRk5SRUV5WjBGTlIxVkRUVkZEWWtsRmRTOU1jMFI2VldOMlVRcEtiMm9yZGtjeWQzUXdOR2h1TlUxR1RteFZhbWxETTFKVFlucENVbFZXVjBJMk9VSnZjSG8yWkU5d1ptTkhlVk5DY0RoRFRVZ3ZjMDVyYWxCV1QwNXJDbkZsYjBaUmVVMU9LM294WkhJMlNuUkxkSFZvUW1Ga01FVlpRakJuV0dWaWJFVldTM2hTZDFweFJIRktSM1ZuV1hSMk4zSndaejA5Q2kwdExTMHRSVTVFSUVORlVsUkpSa2xEUVZSRkxTMHRMUzBLIn19fX0="
       }
     ],
     "timestampVerificationData": {}
@@ -61,8 +58,8 @@
   "messageSignature": {
     "messageDigest": {
       "algorithm": "SHA2_256",
-      "digest": "OT37QOSCiNxEZQoUxJDUlzBDLdvMLYM+lLJ54yq4JRM="
+      "digest": "PNTGOyfHqrVO8Kzp681UnIJmLnXVNuxkwnJz/UoFDjU="
     },
-    "signature": "MEUCIHs2kxfCtoCR8r85zkmGM0/9o4gFC6aaCE8kCn8oYIvWAiEAhmJbS9NHoHxzWbbs54Qy9trAUL3ARbt6fgWisvRMsWk="
+    "signature": "MEUCIQCiogxGMG2I+gVnvpMjxTkB8q4vpG7LQOB2DuRUov3BewIgPdmyZJPjwJfrlp7Qk34i9m7xXYEyINOK6FnjtW1th48="
   }
 }

package/dist/commands/global-update.js

@@ -29,11 +29,13 @@ const GLOBAL_UPDATE_EXECUTOR_MAX_BYTES = 512 * 1024 * 1024;
 class ChildCommandError extends Error {
     status;
     diagnostic;
-    constructor(command, status, diagnostic) {
+    stdout;
+    constructor(command, status, diagnostic, stdout = '') {
         super(`${path.basename(command)} failed with status ${status ?? 'unknown'}`);
         this.name = 'ChildCommandError';
         this.status = status;
         this.diagnostic = diagnostic;
+        this.stdout = stdout;
     }
 }
 function cleanEnvironment() {
@@ -69,7 +71,7 @@ function defaultRunner(command, args, cwd = process.cwd()) {
         }
         catch {
         }
-        throw new ChildCommandError(command, result.status, diagnostic);
+        throw new ChildCommandError(command, result.status, diagnostic, result.stdout ?? '');
     }
     return result.stdout;
 }
@@ -280,10 +282,33 @@ export function inspectGlobalUpdate(run = defaultRunner) {
 function runInstalledJson(run, cliPath, args) {
     return parseJson(run(process.execPath, [cliPath, ...args]).trim(), args.join('_'));
 }
+function childCommandStdout(error) {
+    const stdout = error?.stdout;
+    return typeof stdout === 'string' && stdout.trim() !== '' ? stdout : undefined;
+}
+function readServiceStatus(run, cliPath, service) {
+    try {
+        return runInstalledJson(run, cliPath, [service, 'status', '--json']);
+    }
+    catch (error) {
+        const stdout = childCommandStdout(error);
+        if (stdout === undefined)
+            throw error;
+        try {
+            const parsed = JSON.parse(stdout.trim());
+            if (!parsed || typeof parsed !== 'object' || Array.isArray(parsed))
+                throw error;
+            return parsed;
+        }
+        catch {
+            throw error;
+        }
+    }
+}
 function serviceSnapshot(run, cliPath) {
     return {
-        server: runInstalledJson(run, cliPath, ['server', 'status', '--json']),
-        cockpit: runInstalledJson(run, cliPath, ['cockpit', 'status', '--json']),
+        server: readServiceStatus(run, cliPath, 'server'),
+        cockpit: readServiceStatus(run, cliPath, 'cockpit'),
     };
 }
 function assertHealthyServices(services) {
@@ -565,6 +590,7 @@ export function dispatchGlobalUpdate(options, run = defaultRunner) {
                 rollbackPerformed: false,
                 error: safeUpdateError(error),
                 events: [],
+                eventTimes: [],
             });
         }
         throw new Error(`global update candidate executor failed; diagnostic record: ${resultPath}`, { cause: error });
@@ -652,24 +678,161 @@ function rollbackServerApplication(run, cliPath, updateId, serverPath, expectedR
 const defaultExecutionDependencies = {
     fetch: globalThis.fetch.bind(globalThis),
     sleep: (milliseconds) => new Promise((resolve) => setTimeout(resolve, milliseconds)),
+    now: () => new Date(),
 };
+class GlobalUpdateEventLog {
+    now;
+    names = [];
+    times = [];
+    constructor(now) {
+        this.now = now;
+    }
+    push(event) {
+        this.names.push(event);
+        this.times.push(this.now().toISOString());
+    }
+    includes(event) {
+        return this.names.includes(event);
+    }
+    get events() {
+        return [...this.names];
+    }
+    get eventTimes() {
+        return [...this.times];
+    }
+}
 class StartupHealthPending extends Error {
-    constructor(cause) {
+    detail;
+    constructor(cause, detail) {
         super('global_update_health_startup_pending', { cause });
+        this.detail = detail;
+    }
+}
+function serviceHealthFacts(services) {
+    const liveness = services.server.liveness;
+    return {
+        serverState: services.server.runtimeState,
+        serverHealth: liveness?.health,
+        serverReason: services.server.error,
+        cockpitState: services.cockpit.runtimeState,
+        cockpitHealth: services.cockpit.health,
+        cockpitReason: services.cockpit.reason,
+    };
+}
+const HEALTH_SUBJECTS = new Set([
+    'install-readback', 'server-status', 'cockpit-status', 'service-health',
+    'server', 'cockpit', 'cockpit-proxy',
+]);
+const HEALTH_PHASES = new Set(['startup', 'steady']);
+const SAFE_STATE = /^[a-z][a-z0-9-]{0,40}$/u;
+const SAFE_REASON_CODE = /\b(?:aops|community|global_update)_[a-z0-9_]+\b/iu;
+function sanitizeHealthDetail(detail) {
+    const safe = {
+        subject: typeof detail.subject === 'string' && HEALTH_SUBJECTS.has(detail.subject)
+            ? detail.subject
+            : 'unrecognized',
+    };
+    if (typeof detail.phase === 'string' && HEALTH_PHASES.has(detail.phase))
+        safe.phase = detail.phase;
+    if (typeof detail.reachable === 'boolean')
+        safe.reachable = detail.reachable;
+    for (const key of ['sample', 'attempts', 'childStatus', 'status']) {
+        const value = detail[key];
+        if (typeof value === 'number' && Number.isSafeInteger(value))
+            safe[key] = value;
+    }
+    for (const key of ['serverState', 'serverHealth', 'cockpitState', 'cockpitHealth']) {
+        const value = detail[key];
+        if (value === undefined || value === null)
+            continue;
+        safe[key] = typeof value === 'string' && SAFE_STATE.test(value) ? value : 'unrecognized';
     }
+    for (const key of ['serverReason', 'cockpitReason']) {
+        const value = detail[key];
+        if (value === undefined || value === null)
+            continue;
+        safe[key] = typeof value === 'string'
+            ? SAFE_REASON_CODE.exec(value)?.[0]?.toLowerCase() ?? 'unrecognized'
+            : 'unrecognized';
+    }
+    return safe;
+}
+function childCommandStatus(error) {
+    const status = error?.status;
+    return typeof status === 'number' ? status : undefined;
+}
+class ForwardSchemaRetainsTarget extends Error {
+    applicationRollbackError;
+    constructor(applicationRollbackError) {
+        super('global_update_forward_schema_retains_target');
+        this.applicationRollbackError = applicationRollbackError;
+    }
+}
+export class StableHealthFailure extends Error {
+    healthFailure;
+    constructor(detail) {
+        const safe = sanitizeHealthDetail(detail);
+        super(`global_update_stable_health_failed:${String(safe.subject)}`);
+        this.healthFailure = Object.freeze(safe);
+    }
+}
+export function resolveRecoveryClosure(state) {
+    if (!state.applicationSideEffectPossible)
+        return 'prior';
+    return state.applicationRolledBack ? 'prior' : 'target';
+}
+const APPLICATION_PRE_EFFECT_CODES = new Set([
+    'community_native_application_update_content_unchanged',
+]);
+export function applicationSideEffectPossible(attempted, updateError) {
+    if (!attempted)
+        return false;
+    const diagnostic = nestedCommunityDiagnostic(updateError);
+    if (!diagnostic)
+        return true;
+    const cause = diagnostic.cause;
+    const codes = [diagnostic.code, cause?.code];
+    return !codes.some((code) => typeof code === 'string' && APPLICATION_PRE_EFFECT_CODES.has(code));
 }
 async function assertStableHealth(run, plan, execution) {
     const evidence = [];
+    const fail = (error, startup, detail) => {
+        if (startup)
+            throw new StartupHealthPending(error, detail);
+        throw new StableHealthFailure({ ...detail, phase: 'steady' });
+    };
     const collectSample = async (sample, startup) => {
-        const installed = inspectGlobalInstall(run);
+        let installed;
+        try {
+            installed = inspectGlobalInstall(run);
+        }
+        catch (error) {
+            fail(error, startup, { subject: 'install-readback', sample, childStatus: childCommandStatus(error) });
+            throw error;
+        }
         let services;
         try {
-            services = serviceSnapshot(run, installed.cliPath);
+            services = {
+                server: readServiceStatus(run, installed.cliPath, 'server'),
+                cockpit: { runtimeState: 'not-read' },
+            };
+        }
+        catch (error) {
+            fail(error, startup, { subject: 'server-status', sample, childStatus: childCommandStatus(error) });
+            throw error;
+        }
+        try {
+            services = { ...services, cockpit: readServiceStatus(run, installed.cliPath, 'cockpit') };
+        }
+        catch (error) {
+            fail(error, startup, { subject: 'cockpit-status', sample, childStatus: childCommandStatus(error) });
+            throw error;
+        }
+        try {
             assertHealthyServices(services);
         }
         catch (error) {
-            if (startup)
-                throw new StartupHealthPending(error);
+            fail(error, startup, { subject: 'service-health', sample, ...serviceHealthFacts(services) });
             throw error;
         }
         const serverOrigin = validateLoopbackOrigin(services.server.origin, 'AOPS Server origin');
@@ -685,14 +848,12 @@ async function assertStableHealth(run, plan, execution) {
                 response = await execution.fetch(url, { cache: 'no-store', signal: AbortSignal.timeout(15_000) });
             }
             catch (error) {
-                if (startup)
-                    throw new StartupHealthPending(error);
+                fail(error, startup, { subject: name, sample, reachable: false });
                 throw error;
             }
-            if (response.status !== 200 && startup) {
-                throw new StartupHealthPending(new Error(`${name} health returned ${response.status}`));
+            if (response.status !== 200) {
+                fail(new Error(`${name} health returned ${response.status}`), startup, { subject: name, sample, reachable: true, status: response.status });
             }
-            assert.equal(response.status, 200, `${name} health returned ${response.status}`);
             const body = await response.arrayBuffer();
             endpoints.push({ name, url, status: response.status, bytes: body.byteLength });
         }
@@ -708,7 +869,11 @@ async function assertStableHealth(run, plan, execution) {
         catch (error) {
             if (!(error instanceof StartupHealthPending))
                 throw error;
-            startupError = error.cause ?? error;
+            startupError = new StableHealthFailure({
+                ...error.detail,
+                phase: 'startup',
+                attempts: attempt,
+            });
             if (attempt < plan.safety.healthStartupAttempts) {
                 await execution.sleep(plan.safety.healthStartupIntervalMs);
             }
@@ -755,6 +920,9 @@ function nestedCommunityDiagnostic(error) {
     return undefined;
 }
 function safeUpdateError(error) {
+    if (error instanceof StableHealthFailure) {
+        return { code: 'global_update_stable_health_failed', healthFailure: error.healthFailure };
+    }
     const diagnostic = nestedCommunityDiagnostic(error);
     if (diagnostic) {
         const details = diagnostic.details;
@@ -785,6 +953,160 @@ function writeTerminalUpdateResult(plan, result) {
     const resultPath = path.join(plan.operationRoot, RESULT_FILE);
     writeFileSync(resultPath, `${JSON.stringify(result, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
 }
+const RECOVERY_CONTRACT = 'aops.global-update-recovery/v1';
+const RECOVERY_RESULT_PATTERN = /^update-recovery-(0|[1-9]\d*)\.json$/u;
+const RECOVERABLE_TERMINAL_STATUSES = new Set(['recovery-required']);
+function recoveryAttemptFiles(plan) {
+    const operationRoot = plainDirectory(plan.operationRoot, 'global update operation root');
+    const attempts = [];
+    for (const entry of readdirSync(operationRoot)) {
+        const match = RECOVERY_RESULT_PATTERN.exec(entry);
+        if (match)
+            attempts.push({ attempt: Number(match[1]), path: path.join(operationRoot, entry) });
+    }
+    return attempts.sort((left, right) => left.attempt - right.attempt);
+}
+function nextRecoveryResultPath(plan) {
+    const attempts = recoveryAttemptFiles(plan);
+    const next = attempts.length === 0 ? 1 : attempts[attempts.length - 1].attempt + 1;
+    return path.join(plan.operationRoot, `update-recovery-${next}.json`);
+}
+function sameClosure(installed, expected) {
+    try {
+        assert.deepEqual(installed, expected);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function writeRecoveryResult(resultPath, result) {
+    writeFileSync(resultPath, `${JSON.stringify(result, null, 2)}\n`, { flag: 'wx', mode: 0o600 });
+}
+function preflightGlobalUpdateRecovery(options, run) {
+    const plan = readGlobalUpdatePlan(options.plan);
+    assert.equal(options.confirm, plan.planId, 'global update recovery confirmation does not match the exact plan');
+    const terminalPath = path.join(plan.operationRoot, RESULT_FILE);
+    assert.equal(existsSync(terminalPath), true, 'global_update_recovery_requires_terminal_result');
+    const terminal = parseJson(readFileSync(terminalPath, 'utf8'), 'global_update_result');
+    assert.equal(terminal.planId, plan.planId, 'terminal result belongs to a different plan');
+    const terminalStatus = String(terminal.status);
+    assert.equal(RECOVERABLE_TERMINAL_STATUSES.has(terminalStatus), true, `global_update_recovery_status_not_recoverable:${terminalStatus}`);
+    const installed = inspectGlobalInstall(run);
+    assert.equal(installed.globalPrefix, plan.globalPrefix, 'global npm prefix changed after update planning');
+    const installedClosure = [installed.packages, installed.topology];
+    const atTarget = sameClosure(installedClosure, [plan.target.packages, plan.target.topology]);
+    const atPrior = sameClosure(installedClosure, [plan.prior.packages, plan.prior.topology]);
+    assert.equal(atTarget || atPrior, true, 'global_update_recovery_closure_drifted');
+    const succeeded = recoveryAttemptFiles(plan)
+        .map((file) => ({
+        ...file,
+        record: parseJson(readFileSync(file.path, 'utf8'), 'global_update_recovery_result'),
+    }))
+        .find((entry) => entry.record.status === 'recovered');
+    if (succeeded) {
+        assert.equal(atTarget, true, 'global_update_recovery_recorded_but_closure_moved');
+    }
+    return { plan, terminalStatus, installed, atTarget, atPrior, succeeded };
+}
+export function dispatchGlobalUpdateRecovery(options, run = defaultRunner) {
+    const preflight = preflightGlobalUpdateRecovery(options, run);
+    const { plan } = preflight;
+    if (preflight.succeeded)
+        return preflight.succeeded.record;
+    const resultPath = nextRecoveryResultPath(plan);
+    let executorStarted = false;
+    try {
+        const { receipt, receiptPath } = stageCandidateGlobalUpdateExecutor(plan, run);
+        executorStarted = true;
+        return parseJson(run(process.execPath, [
+            receipt.entrypoint,
+            'update',
+            'recover',
+            '--plan',
+            options.plan,
+            '--confirm',
+            options.confirm,
+            '--executor-receipt',
+            receiptPath,
+            '--json',
+        ]).trim(), 'global_update_recovery_result');
+    }
+    catch (error) {
+        if (!existsSync(resultPath)) {
+            writeRecoveryResult(resultPath, {
+                schemaVersion: 1,
+                contract: RECOVERY_CONTRACT,
+                status: executorStarted ? 'executor-result-missing' : 'executor-staging-failed',
+                planId: plan.planId,
+                failedStage: executorStarted ? 'candidate-executor' : 'stage-candidate-executor',
+                globalState: executorStarted ? 'unknown-requires-inspection' : 'unchanged',
+                error: safeUpdateError(error),
+                events: [],
+                eventTimes: [],
+            });
+        }
+        throw new Error(`global update recovery executor failed; diagnostic record: ${resultPath}`, { cause: error });
+    }
+}
+export async function recoverGlobalUpdate(options, run = defaultRunner, execution = defaultExecutionDependencies) {
+    const preflight = preflightGlobalUpdateRecovery(options, run);
+    const { plan, installed: current, atTarget, terminalStatus } = preflight;
+    const installedCliRoot = plainDirectory(path.dirname(path.dirname(current.cliPath)), 'installed global CLI root');
+    const invokedEntrypoint = plainFile(process.argv[1], 'invoked AOPS CLI entrypoint');
+    const relativeToInstalled = path.relative(installedCliRoot, invokedEntrypoint);
+    assert.equal(relativeToInstalled.startsWith('..') || path.isAbsolute(relativeToInstalled), true, 'global_update_recovery_must_not_run_from_the_replaced_cli');
+    if (preflight.succeeded)
+        return preflight.succeeded.record;
+    const resultPath = nextRecoveryResultPath(plan);
+    const events = new GlobalUpdateEventLog(execution.now ?? (() => new Date()));
+    try {
+        stopService(run, current.cliPath, 'cockpit', true);
+        stopService(run, current.cliPath, 'server', true);
+        if (atTarget) {
+            events.push('retained:target-closure');
+        }
+        else {
+            installGlobalUpdateClosure(run, plan, plan.candidates, plan.target.topology);
+            events.push('installed:target-closure');
+        }
+        const restored = inspectGlobalInstall(run);
+        assert.deepEqual(restored.packages, plan.target.packages, 'recovered closure is not the exact target');
+        assert.deepEqual(restored.topology, plan.target.topology, 'recovered topology is not canonical');
+        startService(run, restored.cliPath, 'server');
+        events.push('started:server');
+        startService(run, restored.cliPath, 'cockpit');
+        events.push('started:cockpit');
+        const healthEvidence = await assertStableHealth(run, plan, execution);
+        const result = {
+            schemaVersion: 1,
+            contract: RECOVERY_CONTRACT,
+            status: 'recovered',
+            planId: plan.planId,
+            installed: plan.target.packages,
+            recoveredFrom: terminalStatus,
+            events: events.events,
+            eventTimes: events.eventTimes,
+            healthEvidence,
+        };
+        writeRecoveryResult(resultPath, result);
+        return result;
+    }
+    catch (recoveryError) {
+        writeRecoveryResult(resultPath, {
+            schemaVersion: 1,
+            contract: RECOVERY_CONTRACT,
+            status: 'recovery-failed',
+            planId: plan.planId,
+            recoveredFrom: terminalStatus,
+            globalState: 'unknown-requires-inspection',
+            error: safeUpdateError(recoveryError),
+            events: events.events,
+            eventTimes: events.eventTimes,
+        });
+        throw recoveryError;
+    }
+}
 export async function applyGlobalUpdate(options, run = defaultRunner, execution = defaultExecutionDependencies) {
     const plan = readGlobalUpdatePlan(options.plan);
     assert.equal(options.confirm, plan.planId, 'global update confirmation does not match the exact plan');
@@ -794,8 +1116,9 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
     assert.deepEqual(current.topology, plan.prior.topology, 'global package topology changed after update planning');
     assert.equal(current.globalPrefix, plan.globalPrefix, 'global npm prefix changed after update planning');
     assertHealthyServices(serviceSnapshot(run, current.cliPath));
-    const events = [];
+    const events = new GlobalUpdateEventLog(execution.now ?? (() => new Date()));
     let applicationUpdateId = null;
+    let applicationUpdateAttempted = false;
     let failedStage = 'stop-cockpit';
     try {
         stopService(run, current.cliPath, 'cockpit');
@@ -817,6 +1140,7 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
         }
         else {
             failedStage = 'update-server-application';
+            applicationUpdateAttempted = true;
             applicationUpdateId = updateServerApplication(run, updated.cliPath, {
                 prior: plan.prior.packages.server,
                 target: plan.target.packages.server,
@@ -835,7 +1159,8 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
             planId: plan.planId,
             installed: updated.packages,
             rollbackPerformed: false,
-            events,
+            events: events.events,
+            eventTimes: events.eventTimes,
             healthEvidence,
             next: 'Exit and reopen the AOPS TUI to run the newly installed binary.',
         };
@@ -844,6 +1169,7 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
     }
     catch (updateError) {
         const updateStage = failedStage;
+        const sideEffectPossible = applicationSideEffectPossible(applicationUpdateAttempted, updateError);
         events.push('rollback:started');
         let rollbackError;
         try {
@@ -854,19 +1180,89 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
             const restored = inspectGlobalInstall(run);
             assert.deepEqual(restored.packages, plan.prior.packages, 'rollback package closure is not exact');
             assert.deepEqual(restored.topology, plan.prior.topology, 'rollback package topology is not exact');
+            let applicationRollbackError;
             if (applicationUpdateId) {
-                rollbackServerApplication(run, restored.cliPath, applicationUpdateId, restored.serverPath, plan.prior.packages.server);
-                events.push('rolled-back:server-application');
+                try {
+                    rollbackServerApplication(run, restored.cliPath, applicationUpdateId, restored.serverPath, plan.prior.packages.server);
+                    events.push('rolled-back:server-application');
+                }
+                catch (error) {
+                    applicationRollbackError = error;
+                    events.push('failed:server-application-rollback');
+                }
+            }
+            else if (sideEffectPossible) {
+                applicationRollbackError = new Error('global_update_application_outcome_unrecorded');
+                events.push('failed:server-application-outcome-unrecorded');
             }
             else {
                 startService(run, restored.cliPath, 'server');
                 events.push('started:server-restore');
             }
+            if (resolveRecoveryClosure({
+                applicationSideEffectPossible: sideEffectPossible,
+                applicationRolledBack: applicationUpdateId !== null && applicationRollbackError === undefined,
+            }) === 'target') {
+                throw new ForwardSchemaRetainsTarget(applicationRollbackError);
+            }
             startService(run, restored.cliPath, 'cockpit');
             await assertStableHealth(run, plan, execution);
             events.push('rollback:healthy');
         }
         catch (rollbackError) {
+            if (rollbackError instanceof ForwardSchemaRetainsTarget) {
+                try {
+                    installGlobalUpdateClosure(run, plan, plan.candidates, plan.target.topology);
+                    events.push('reinstalled:target-closure');
+                    const retained = inspectGlobalInstall(run);
+                    assert.deepEqual(retained.packages, plan.target.packages, 'retained target closure is not exact');
+                    assert.deepEqual(retained.topology, plan.target.topology, 'retained target topology is not canonical');
+                    startService(run, retained.cliPath, 'server');
+                    events.push('started:server-target-retained');
+                    startService(run, retained.cliPath, 'cockpit');
+                    events.push('started:cockpit-target-retained');
+                    await assertStableHealth(run, plan, execution);
+                    events.push('target-retained:healthy');
+                }
+                catch (retainError) {
+                    writeTerminalUpdateResult(plan, {
+                        schemaVersion: 1,
+                        contract: RESULT_CONTRACT,
+                        status: 'recovery-required',
+                        planId: plan.planId,
+                        failedStage: updateStage,
+                        rollbackPerformed: false,
+                        rollback: {
+                            status: 'failed',
+                            reason: 'application_rollback_failed_forward_schema',
+                            error: safeUpdateError(rollbackError.applicationRollbackError),
+                        },
+                        targetRetention: { status: 'failed', error: safeUpdateError(retainError) },
+                        error: safeUpdateError(updateError),
+                        events: events.events,
+                        eventTimes: events.eventTimes,
+                    });
+                    throw new AggregateError([updateError, rollbackError.applicationRollbackError, retainError], `global update failed, application rollback failed, and the schema-compatible target closure could not be restarted; services may remain stopped; recovery artifacts remain at ${plan.operationRoot}`);
+                }
+                writeTerminalUpdateResult(plan, {
+                    schemaVersion: 1,
+                    contract: RESULT_CONTRACT,
+                    status: 'failed-target-retained',
+                    planId: plan.planId,
+                    failedStage: updateStage,
+                    installed: plan.target.packages,
+                    rollbackPerformed: false,
+                    rollback: {
+                        status: 'not-applicable',
+                        reason: 'application_rollback_failed_forward_schema',
+                        applicationRollbackError: safeUpdateError(rollbackError.applicationRollbackError),
+                    },
+                    error: safeUpdateError(updateError),
+                    events: events.events,
+                    eventTimes: events.eventTimes,
+                });
+                throw new AggregateError([updateError, rollbackError.applicationRollbackError], 'global update failed and the application could not be rolled back; the schema-compatible target closure was reinstated and healthy services were restarted');
+            }
             try {
                 const restoredForRecovery = inspectGlobalInstall(run);
                 assert.deepEqual(restoredForRecovery.packages, plan.prior.packages, 'service recovery package closure is not exact');
@@ -891,7 +1287,8 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
                     rollback: { status: 'failed', error: safeUpdateError(rollbackError) },
                     serviceRecovery: { status: 'failed', error: safeUpdateError(serviceRecoveryError) },
                     error: safeUpdateError(updateError),
-                    events,
+                    events: events.events,
+                    eventTimes: events.eventTimes,
                 });
                 throw new AggregateError([updateError, rollbackError, serviceRecoveryError], `global update, automatic rollback, and service recovery failed; services may remain stopped; recovery artifacts remain at ${plan.operationRoot}`);
             }
@@ -909,7 +1306,8 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
                     applicationRollbackError: safeUpdateError(rollbackError),
                 },
                 error: safeUpdateError(updateError),
-                events,
+                events: events.events,
+                eventTimes: events.eventTimes,
             });
             throw new AggregateError([updateError, rollbackError], `global update and application rollback failed; prior exact packages and healthy services were restored; recovery artifacts remain at ${plan.operationRoot}`);
         }
@@ -923,7 +1321,8 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
             rollbackPerformed: true,
             rollback: { status: 'healthy' },
             error: safeUpdateError(updateError),
-            events,
+            events: events.events,
+            eventTimes: events.eventTimes,
         });
         throw new Error('global update failed; the prior exact packages were restored and are healthy', { cause: updateError });
     }
@@ -931,6 +1330,22 @@ export async function applyGlobalUpdate(options, run = defaultRunner, execution
 function output(value, json) {
     process.stdout.write(`${JSON.stringify(value, null, json ? 0 : 2)}\n`);
 }
+const defaultRecoveryCommandDependencies = {
+    dispatch: dispatchGlobalUpdateRecovery,
+    recover: recoverGlobalUpdate,
+    readPlan: readGlobalUpdatePlan,
+    validateExecutor: validateCandidateExecutorInvocation,
+    emit: output,
+};
+export async function runGlobalUpdateRecoveryCommand(options, dependencies = defaultRecoveryCommandDependencies) {
+    if (typeof options.executorReceipt === 'string') {
+        const plan = dependencies.readPlan(options.plan);
+        dependencies.validateExecutor(plan, options.executorReceipt);
+        dependencies.emit(await dependencies.recover(options), options.json === true);
+        return;
+    }
+    dependencies.emit(dependencies.dispatch(options), options.json === true);
+}
 export function makeGlobalUpdateCommand() {
     const command = new Command('update').description('Check, prepare, and apply a guarded global AOPS npm update');
     command
@@ -960,6 +1375,16 @@ export function makeGlobalUpdateCommand() {
         }
         output(dispatchGlobalUpdate(options), options.json === true);
     });
+    command
+        .command('recover')
+        .description('Finish one stranded exact plan at its target closure after a failed apply')
+        .requiredOption('--plan <path>', 'Exact update-plan.json path returned by prepare')
+        .requiredOption('--confirm <plan-id>', 'Exact sha256 plan id returned by prepare')
+        .addOption(new Option('--executor-receipt <path>').hideHelp())
+        .option('--json', 'Output JSON')
+        .action(async (options) => {
+        await runGlobalUpdateRecoveryCommand(options);
+    });
     command
         .command('bridge')
         .description('Apply an old-CLI plan from an externally launched exact public candidate')

package/dist/lib/agent-assets/native-fs.js

@@ -543,9 +543,9 @@ function defaultNativeRoot() {
     return moduleDirectory.endsWith(`${path.sep}dist`) ? bundled : compiledOrSource;
 }
 function injectedNativeManifestSha256() {
-    return typeof "8829e388a6594a397d3177b17cc67f390cb37902e6d297136cbdc67a6cd44371" === 'undefined'
+    return typeof "99724da24c7a8af713cd05f83646af0ddbf95c89fc892ce31f0edc7d21874483" === 'undefined'
         ? undefined
-        : "8829e388a6594a397d3177b17cc67f390cb37902e6d297136cbdc67a6cd44371";
+        : "99724da24c7a8af713cd05f83646af0ddbf95c89fc892ce31f0edc7d21874483";
 }
 function sha256(bytes) {
     return createHash('sha256').update(bytes).digest('hex');

package/dist/lib/community-cockpit-lifecycle.js

@@ -205,6 +205,71 @@ function terminalObservation(record, observedAt, disappeared = false) {
         signal: record.signal ?? null,
     };
 }
+export const COCKPIT_PID_START_TOLERANCE_MS = 300_000;
+export function classifyTerminalCockpitPids(params) {
+    if (params.identityPresent) {
+        return { stale: false, reason: 'community_cockpit_terminal_identity_file_present', findings: [] };
+    }
+    if (params.livePids.length === 0) {
+        return { stale: false, reason: 'community_cockpit_terminal_no_live_pid', findings: [] };
+    }
+    const recordedStart = Date.parse(params.record.startedAt);
+    if (!Number.isFinite(recordedStart)) {
+        return { stale: false, reason: 'community_cockpit_pid_record_start_unparsable', findings: [] };
+    }
+    const tolerance = params.startToleranceMs ?? COCKPIT_PID_START_TOLERANCE_MS;
+    const findings = [];
+    let blocked = null;
+    for (const { pid, role } of params.livePids) {
+        let inspection;
+        try {
+            inspection = params.inspect(pid);
+        }
+        catch (error) {
+            inspection = {
+                outcome: 'undetermined',
+                pid,
+                reason: error instanceof Error ? error.message : 'community_cockpit_pid_inspection_threw',
+            };
+        }
+        if (inspection.outcome === 'absent') {
+            findings.push({ pid, role, outcome: 'absent', disagreedOn: ['identity', 'start-time', 'host-entry'], reason: null });
+            continue;
+        }
+        if (inspection.outcome === 'undetermined') {
+            findings.push({ pid, role, outcome: 'undetermined', disagreedOn: [], reason: inspection.reason });
+            blocked ??= `community_cockpit_pid_inspection_undetermined:${pid}:${inspection.reason}`;
+            continue;
+        }
+        const observedStart = Date.parse(inspection.startedAt);
+        if (!Number.isFinite(observedStart)) {
+            findings.push({ pid, role, outcome: 'inspected', disagreedOn: [], reason: 'start_time_unparsable' });
+            blocked ??= `community_cockpit_pid_start_time_unparsable:${pid}`;
+            continue;
+        }
+        if (inspection.command.trim() === '') {
+            findings.push({ pid, role, outcome: 'inspected', disagreedOn: [], reason: 'command_unavailable' });
+            blocked ??= `community_cockpit_pid_command_unavailable:${pid}`;
+            continue;
+        }
+        const disagreedOn = ['identity'];
+        if (Math.abs(observedStart - recordedStart) > tolerance)
+            disagreedOn.push('start-time');
+        if (!commandNamesHostEntry(inspection.command, params.record.hostEntry))
+            disagreedOn.push('host-entry');
+        findings.push({ pid, role, outcome: 'inspected', disagreedOn, reason: null });
+        if (disagreedOn.length !== 3) {
+            blocked ??= `community_cockpit_pid_may_be_owned:${pid}:${disagreedOn.join('+')}`;
+        }
+    }
+    if (blocked)
+        return { stale: false, reason: blocked, findings };
+    return { stale: true, reason: 'community_cockpit_terminal_record_pid_reused', findings };
+}
+function commandNamesHostEntry(command, hostEntry) {
+    const normalise = (value) => value.split('\\').join('/').toLowerCase();
+    return normalise(command).includes(normalise(hostEntry));
+}
 async function observeCockpit(params) {
     const record = params.processRecord;
     const identityPresent = existsSync(params.paths.identityPath);
@@ -254,11 +319,40 @@ async function observeCockpit(params) {
                 terminalObservation: terminalObservation(record, record.updatedAt),
             };
         }
+        const observation = terminalObservation(record, record.updatedAt);
+        const verdict = observation.classification === 'clean-exit'
+            ? classifyTerminalCockpitPids({
+                record,
+                identityPresent,
+                livePids: [
+                    ...(supervisorAlive ? [{ pid: record.pid, role: 'supervisor' }] : []),
+                    ...(hostAlive && hostPid ? [{ pid: hostPid, role: 'host' }] : []),
+                ],
+                inspect: params.runtime.inspectProcess ?? ((pid) => ({
+                    outcome: 'undetermined',
+                    pid,
+                    reason: 'community_cockpit_pid_inspection_unavailable',
+                })),
+            })
+            : {
+                stale: false,
+                reason: `community_cockpit_terminal_record_with_live_or_unowned_process:${observation.classification}`,
+                findings: [],
+            };
+        if (verdict.stale) {
+            return {
+                ...base,
+                runtimeState: 'stopped', recoverable: true, process: record, identity,
+                supervisorAlive, hostAlive, health: 'not-checked',
+                reason: verdict.reason,
+                terminalObservation: observation,
+            };
+        }
         return {
             ...base,
             runtimeState: 'identity-conflict', recoverable: false, process: record, identity,
             supervisorAlive, hostAlive, health: 'not-checked',
-            reason: 'community_cockpit_terminal_record_with_live_or_unowned_process',
+            reason: verdict.reason,
             terminalObservation: null,
         };
     }

package/dist/lib/community-native-lifecycle.js

@@ -1,5 +1,5 @@
 import { createHash, randomBytes, randomUUID } from 'node:crypto';
-import { spawn } from 'node:child_process';
+import { spawn, spawnSync } from 'node:child_process';
 import { createRequire } from 'node:module';
 import { closeSync, existsSync, fsyncSync, lstatSync, mkdirSync, openSync, readdirSync, readSync, readFileSync, realpathSync, renameSync, rmSync, writeFileSync, } from 'node:fs';
 import path from 'node:path';
@@ -68,6 +68,56 @@ const PACKAGE_BUILD_PATHS = Object.freeze({
     handlerEntry: 'build/handler.js',
     cockpitIndex: 'cockpit/index.html',
 });
+export function inspectHostProcess(pid, execute = (command, args) => {
+    const result = spawnSync(command, args, { encoding: 'utf8', windowsHide: true, timeout: 5_000 });
+    if (result.error)
+        throw result.error;
+    return { status: result.status, stdout: result.stdout ?? '', stderr: result.stderr ?? '' };
+}, platform = process.platform) {
+    if (!Number.isSafeInteger(pid) || pid < 1) {
+        return { outcome: 'undetermined', pid, reason: 'pid_not_inspectable' };
+    }
+    try {
+        if (platform === 'win32') {
+            const result = execute('powershell.exe', [
+                '-NoProfile', '-NonInteractive', '-Command',
+                `$p = Get-CimInstance Win32_Process -Filter "ProcessId=${pid}" -ErrorAction Stop; ` +
+                    'if ($null -eq $p) { exit 3 }; ' +
+                    '"{0}`t{1}" -f $p.CreationDate.ToString("o"), $p.CommandLine',
+            ]);
+            if (result.status === 3)
+                return { outcome: 'absent', pid };
+            if (result.status !== 0) {
+                return { outcome: 'undetermined', pid, reason: `process_query_failed:${result.status ?? 'no_status'}` };
+            }
+            const [startedAt, ...rest] = result.stdout.trim().split('\t');
+            if (!startedAt)
+                return { outcome: 'undetermined', pid, reason: 'process_query_empty' };
+            return { outcome: 'inspected', pid, startedAt, command: rest.join('\t').trim() };
+        }
+        const result = execute('ps', ['-o', 'lstart=,args=', '-p', String(pid)]);
+        if (result.status === 1 && result.stdout.trim() === '')
+            return { outcome: 'absent', pid };
+        if (result.status !== 0) {
+            return { outcome: 'undetermined', pid, reason: `process_query_failed:${result.status ?? 'no_status'}` };
+        }
+        const line = result.stdout.split('\n')[0]?.trim() ?? '';
+        if (line === '')
+            return { outcome: 'absent', pid };
+        const fields = line.split(/\s+/u);
+        if (fields.length < 6)
+            return { outcome: 'undetermined', pid, reason: 'process_query_unparsable' };
+        const startedAt = fields.slice(0, 5).join(' ');
+        return { outcome: 'inspected', pid, startedAt, command: fields.slice(5).join(' ') };
+    }
+    catch (error) {
+        return {
+            outcome: 'undetermined',
+            pid,
+            reason: error instanceof Error ? `process_query_threw:${error.message.slice(0, 80)}` : 'process_query_threw',
+        };
+    }
+}
 function sha256(content) {
     return `sha256:${createHash('sha256').update(content).digest('hex')}`;
 }
@@ -1437,6 +1487,9 @@ export const communityNativeRuntime = {
             return Boolean(error && typeof error === 'object' && 'code' in error && error.code === 'EPERM');
         }
     },
+    inspectProcess(pid) {
+        return inspectHostProcess(pid);
+    },
     sleep: (milliseconds, signal) => new Promise((resolve, reject) => {
         if (signal?.aborted) {
             reject(new Error('community_operation_aborted'));

package/native/manifest.json

@@ -6,7 +6,7 @@
       "platform": "darwin",
       "architecture": "arm64",
       "relativePath": "bin/darwin-arm64/aops-agent-assets-fs",
-      "sha256": "8b51027fa9c2ae84480da09a48f5e1970b1b5444e65c79f2c95a84494af83aba",
+      "sha256": "aeff0f83ff7c53f1651ccee44d857f03c5a41846f30302433ade0f3705ae0940",
       "capabilityClass": "macos-exclusive-durable-v1",
       "qualification": null
     },
@@ -14,7 +14,7 @@
       "platform": "darwin",
       "architecture": "x64",
       "relativePath": "bin/darwin-x64/aops-agent-assets-fs",
-      "sha256": "4e9023fe80b0c019c7d3b822efad79227a8185f6a546fc4a3671d72e4484dcd8",
+      "sha256": "d04f3e6ae34c2711cf1cf6bb8a6d5edb669cf4aed4c21e315b23e9d78a0799ef",
       "capabilityClass": "macos-exclusive-durable-v1",
       "qualification": null
     },
@@ -22,7 +22,7 @@
       "platform": "linux",
       "architecture": "arm64",
       "relativePath": "bin/linux-arm64/aops-agent-assets-fs",
-      "sha256": "8e8457f64e9552a3094a910f3e2214ff2e309b8d2b4754af6fe30fd7fd674ff4",
+      "sha256": "4af380c99012b8e847570cb140c70c44c4dcdcee11c17cc5cb2bb8493b82dc8c",
       "capabilityClass": "linux-posix-durable-v1",
       "qualification": null
     },
@@ -30,7 +30,7 @@
       "platform": "linux",
       "architecture": "x64",
       "relativePath": "bin/linux-x64/aops-agent-assets-fs",
-      "sha256": "a313faedbbb5e4ebd570750ce567ab7e42b23077a8ddf60a4c61ba24965dc01c",
+      "sha256": "1c36cd295f0fcfdfd4192748413483b099ac4299e0f770a982846b8915fba31d",
       "capabilityClass": "linux-posix-durable-v1",
       "qualification": null
     },
@@ -38,11 +38,11 @@
       "platform": "win32",
       "architecture": "x64",
       "relativePath": "bin/win32-x64/aops-agent-assets-fs.exe",
-      "sha256": "9b54788cfec6108383d890fca1e79564258dfb9c8618f775d427b6ec371aac9d",
+      "sha256": "c1fcf2fe3689550f1552bdb60a064a9ac0c9e30cba4d9eb7c52140ee14794778",
       "capabilityClass": "windows-ntfs-crash-recoverable-v1",
       "qualification": {
         "relativePath": "qualifications/win32-x64.json",
-        "sha256": "98d28b5ea98eab250ae1849e88dc729a5986916db9aafda8c463a8d366e8c0c2"
+        "sha256": "ef348d39e5c9e229b21274d00f779dbe9e8fd7bdbc27cb5c797191bb1294a5ae"
       }
     }
   ]

package/native/qualifications/win32-x64.json

@@ -7,7 +7,7 @@
   "filesystem": "NTFS",
   "primitiveProfile": "windows-createfile-flush-movefileex-v1",
   "capabilityClass": "windows-ntfs-crash-recoverable-v1",
-  "evidenceSha256": "5bd395ea8e18d402e82eaed62da75009ddc767e29f27847184e6099707a37b7d",
+  "evidenceSha256": "d58ca525d9e4a57c111747e1912e4d74266c712b127cfb9857b7d9d2beb5d3c1",
   "crashInjectionPoints": [
     "authority-history",
     "authority-current",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@aopslabs/aops",
-  "version": "0.3.23",
+  "version": "0.3.24",
   "type": "module",
   "description": "AOPS CLI and terminal setup application.",
   "aopsDockerServerVersion": "0.2.17",
@@ -62,17 +62,17 @@
   },
   "dependencies": {
     "@aopslabs/aops-agent-runtime": "0.1.0",
-    "@aopslabs/aops-server": "0.2.17",
+    "@aopslabs/aops-server": "0.2.18",
     "@aopslabs/artifact-trust-contracts": "0.3.1",
     "@aopslabs/cli-kit": "0.1.0",
-    "@aopslabs/aops-host-registration": "0.2.1",
+    "@aopslabs/aops-host-registration": "0.2.2",
     "@aopslabs/aops-pg-bootstrap": "0.2.3",
-    "@aopslabs/aops-runtime-config": "0.2.1",
+    "@aopslabs/aops-runtime-config": "0.2.2",
     "@sigstore/bundle": "4.0.0",
     "@sigstore/protobuf-specs": "0.5.1",
     "@sigstore/tuf": "4.0.2",
     "@sigstore/verify": "3.1.1",
-    "@aopslabs/api-client": "0.2.1",
+    "@aopslabs/api-client": "0.2.2",
     "@aopslabs/domain-product-client-chatv3": "0.4.1",
     "@aopslabs/xf-cli-ui": "0.2.0",
     "commander": "14.0.3",