fix(cancellation): preserve caller abort reasons through late finalization (#6143)

* fix(cancellation): preserve caller abort reasons through late finalization

Caller aborts that arrived during final provider, cleanup, or protocol
handling were dropped or replaced by I/O, cleanup, or success results.
Each affected path now samples the caller signal after its owner has
settled and returns AnalysisCancelledError carrying the exact
signal.reason, keeping any completed partial Evidence or cleanup state.

- Web script export: keep the exact reason for an interrupted output
  write, and honor a cancellation fact recorded before a retried
  capture close succeeds.
- Native value tracing and Hopper regex search: check the signal after
  the final provider reply or regex worker settles.
- Apple asset catalog: stop assetutil with SIGTERM so cancellation
  settles only after the helper exits.
- CDP observation: end an armed window on a fatal protocol failure.
- ADB bugreport: prefer cancellation over the staging-removal output
  error when the caller aborted.
- JavaScript recovery: check the signal after provider success.
- export-web-scripts CLI: run under command cancellation and forward
  the signal into the export workflow.
- Objdump and Rizin CLI: report cancellation after cleanup completes.
- Binary session: keep cancellation primary when previous-client
  retirement fails after abort.

Fixes morluto/rea#6042
Fixes morluto/rea#6043
Fixes morluto/rea#6048
Fixes morluto/rea#6049
Fixes morluto/rea#6057
Fixes morluto/rea#6060
Fixes morluto/rea#6078
Fixes morluto/rea#6080
Fixes morluto/rea#6108
Fixes morluto/rea#6111
Fixes morluto/rea#6115

* fix(cancellation): keep caller reasons through export rollback and commit

- Rollback failure after a caller abort now returns AnalysisCancelledError
  with the exact signal.reason, attaching the rollback failure as cleanup
  and retaining any published result as partial observation.
- A capture close retry that succeeds after abort returns cancellation
  instead of the stale cleanup diagnostic.
- An abort that lands during the final output commit returns cancellation
  carrying the completed manifest as partial observation.
- Apple assetutil stop test: abort and await the run in finally so a
  timed-out wait does not leave the child running, and skip on Windows
  where the JavaScript SIGTERM handler cannot run.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 35b247e9-c793-4b8f-979a-807c27112cf5

* fix(cancellation): bind export cancellations to cleanup and caller reasons

- A rollback-failure cancellation is bound to the retained cleanup lease,
  so a later successful close clears cleanup_incomplete instead of
  reporting a residual directory that no longer exists.
- mapExportFailure wraps the caller's own AnalysisCancelledError reason
  under export_web_scripts rather than returning it as the export's error.

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Copilot-Session: 35b247e9-c793-4b8f-979a-807c27112cf5

---------

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>
Co-authored-by: morluto <76467478+morluto@users.noreply.github.com>
Copilot-Session: 35b247e9-c793-4b8f-979a-807c27112cf5

src/application/javascript/JavaScriptRecoveryService.test.ts

@@ -176,3 +176,29 @@ describe("JavaScript recovery workflow", () => {
     });
   });
 });
+
+it("returns cancellation with the validated Evidence when the caller aborts after provider success", async () => {
+  const controller = new AbortController();
+  const reason = { request: "stop recovery" };
+  const service = new JavaScriptRecoveryService({
+    recover: async () => {
+      controller.abort(reason);
+      return ok(
+        createAnalysisExecution(recoveryResult(), providerIdentity, {
+          subject: {
+            path: artifact.path,
+            sha256: artifact.sha256,
+            format: "javascript" as const,
+          },
+        }),
+      );
+    },
+  });
+  const result = await service.recover(input, { signal: controller.signal });
+  if (result.ok) throw new Error("expected cancellation");
+  expect(result.error._tag).toBe("AnalysisCancelledError");
+  expect(result.error.cause).toBe(reason);
+  expect(result.error.partialObservation).toMatchObject({
+    operation: "recover_javascript_sources",
+  });
+});

src/application/javascript/JavaScriptRecoveryService.ts

@@ -13,8 +13,9 @@ import {
 } from "../../domain/javascript/javascriptRecovery.js";
 import { jsonObjectSchema, jsonValueSchema } from "../../domain/jsonValue.js";
 import { analysisInputErrorFromIssues } from "../../domain/inputIssueProjection.js";
-import { err, ok, type Result } from "../../domain/result.js";
+import { err, type Result } from "../../domain/result.js";
 import type { ExecutionOptions } from "../AnalysisProvider.js";
+import { completeProviderEvidence } from "../ProviderOperationExecution.js";
 import type { JavaScriptRecoveryPort } from "./JavaScriptRecoveryPort.js";
 
 const OPERATION = "recover_javascript_sources";
@@ -107,8 +108,10 @@ export class JavaScriptRecoveryService {
           "Recovery source or engine identity disagrees with its Evidence binding",
         ),
       );
-    return ok(
-      createEvidence(execution.value.subject, execution.value.provider, {
+    const evidence = createEvidence(
+      execution.value.subject,
+      execution.value.provider,
+      {
         operation: OPERATION,
         parameters: jsonObjectSchema.parse(parsed.data),
         result: jsonValueSchema.parse(result.data),
@@ -117,7 +120,8 @@ export class JavaScriptRecoveryService {
         limitations: execution.value.limitations,
         confidence: "derived",
         authority: "shipped-artifact",
-      }),
+      },
     );
+    return completeProviderEvidence(evidence, options?.signal);
   }
 }